Class: ActionWebService::API::Base

Inherits:
Object
  • Object
show all
Extended by:
SignatureTypes
Defined in:
lib/action_web_service/api.rb,
lib/action_web_service/protocol/soap_protocol.rb,
lib/action_web_service/protocol/xmlrpc_protocol.rb

Overview

:nodoc:

Class Method Summary collapse

Methods included from SignatureTypes

canonical_signature, canonical_signature_entry, canonical_type, canonical_type_class, canonical_type_name, class_to_type_name, derived_from?, symbol_name, type_name_to_class

Class Method Details

.api_method(name, options = {}) ⇒ Object

API methods have a name, which must be the Ruby method name to use when performing the invocation on the web service object.

The signatures for the method input parameters and return value can by specified in options.

A signature is an array of one or more parameter specifiers. A parameter specifier can be one of the following:

  • A symbol or string representing one of the Action Web Service base types. See ActionWebService::SignatureTypes for a canonical list of the base types.

  • The Class object of the parameter type

  • A single-element Array containing one of the two preceding items. This will cause Action Web Service to treat the parameter at that position as an array containing only values of the given type.

  • A Hash containing as key the name of the parameter, and as value one of the three preceding items

If no method input parameter or method return value signatures are given, the method is assumed to take no parameters and/or return no values of interest, and any values that are received by the server will be discarded and ignored.

Valid options:

:expects

Signature for the method input parameters

:returns

Signature for the method return value

:expects_and_returns

Signature for both input parameters and return value



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/action_web_service/api.rb', line 70

def api_method(name, options={})
  unless options.is_a?(Hash)
    raise(ActionWebServiceError, "Expected a Hash for options")
  end
  validate_options([:expects, :returns, :expects_and_returns], options.keys)
  if options[:expects_and_returns]
    expects = options[:expects_and_returns]
    returns = options[:expects_and_returns]
  else
    expects = options[:expects]
    returns = options[:returns]
  end
  expects = canonical_signature(expects)
  returns = canonical_signature(returns)
  if expects
    expects.each do |type|
      type = type.element_type if type.is_a?(ArrayType)
      if Object.const_defined?('ActiveRecord')
        if type.type_class.ancestors.include?(ActiveRecord::Base) && !allow_active_record_expects
          raise(ActionWebServiceError, "ActiveRecord model classes not allowed in :expects")
        end
      end
    end
  end
  name = name.to_sym
  public_name = public_api_method_name(name)
  method = Method.new(name, public_name, expects, returns)
  self.api_methods_attr = self.api_methods_attr.merge({ name => method })
  self.api_public_method_names_attr = self.api_public_method_names_attr.merge({ public_name => name })
end

.api_method_instance(method_name) ⇒ Object

The Method instance for the given API method name, if any

class ProjectsApi < ActionWebService::API::Base
  api_method :getCount,          :returns => [:int]
  api_method :getCompletedCount, :returns => [:int]
end

ProjectsApi.api_method_instance(:getCount) #=> <ActionWebService::API::Method:0x24379d8 ...>
ProjectsApi.api_method_instance('GetCount') #=> <ActionWebService::API::Method:0x24379d8 ...>



187
188
189
 
# File 'lib/action_web_service/api.rb', line 187

def api_method_instance(method_name)
  api_methods[method_name]
end

.api_method_name(public_name) ⇒ Object

The corresponding service method name for the given public method name

class ProjectsApi < ActionWebService::API::Base
  api_method :getCount, :returns => [:int]
end

ProjectsApi.api_method_name('GetCount') #=> :getCount



145
146
147
 
# File 'lib/action_web_service/api.rb', line 145

def api_method_name(public_name)
  self.api_public_method_names_attr[public_name]
end

.api_methods ⇒ Object

A Hash containing all service methods on this API, and their associated metadata.

class ProjectsApi < ActionWebService::API::Base
  api_method :getCount,          :returns => [:int]
  api_method :getCompletedCount, :returns => [:int]
end

ProjectsApi.api_methods #=> 
  {:getCount=>#<ActionWebService::API::Method:0x24379d8 ...>,
   :getCompletedCount=>#<ActionWebService::API::Method:0x2437794 ...>}
ProjectsApi.api_methods[:getCount].public_name #=> "GetCount"



161
162
163
 
# File 'lib/action_web_service/api.rb', line 161

def api_methods
  self.api_methods_attr
end

.default_api_method_instance ⇒ Object

The Method instance for the default API method, if any



192
193
194
195
196
197
198
199
200
201
 
# File 'lib/action_web_service/api.rb', line 192

def default_api_method_instance
  return nil unless name = default_api_method
  instance = self.default_api_method_instance_attr
  if instance && instance.name == name
    return instance
  end
  instance = Method.new(name, public_api_method_name(name), nil, nil)
  self.default_api_method_instance_attr = instance
  instance
end

.has_api_method?(name) ⇒ Boolean

Whether the given method name is a service method on this API

class ProjectsApi < ActionWebService::API::Base
  api_method :getCount, :returns => [:int]
end

ProjectsApi.has_api_method?('GetCount')   #=> false
ProjectsApi.has_api_method?(:getCount)    #=> true

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/action_web_service/api.rb', line 109

def has_api_method?(name)
  self.api_methods_attr.has_key?(name)
end

.has_public_api_method?(public_name) ⇒ Boolean

Whether the given public method name has a corresponding service method on this API

class ProjectsApi < ActionWebService::API::Base
  api_method :getCount, :returns => [:int]
end

ProjectsApi.has_api_method?(:getCount)    #=> false
ProjectsApi.has_api_method?('GetCount')   #=> true

Returns:

  • (Boolean) 


122
123
124
 
# File 'lib/action_web_service/api.rb', line 122

def has_public_api_method?(public_name)
  self.api_public_method_names_attr.has_key?(public_name)
end

.public_api_method_instance(public_method_name) ⇒ Object

The Method instance for the given public API method name, if any

class ProjectsApi < ActionWebService::API::Base
  api_method :getCount,          :returns => [:int]
  api_method :getCompletedCount, :returns => [:int]
end

ProjectsApi.public_api_method_instance('GetCount')  #=> <#<ActionWebService::API::Method:0x24379d8 ...>
ProjectsApi.public_api_method_instance(:getCount)   #=> nil



174
175
176
 
# File 'lib/action_web_service/api.rb', line 174

def public_api_method_instance(public_method_name)
  api_method_instance(api_method_name(public_method_name))
end

.public_api_method_name(name) ⇒ Object

The corresponding public method name for the given service method name

ProjectsApi.public_api_method_name('GetCount')  #=> "GetCount"
ProjectsApi.public_api_method_name(:getCount)   #=> "GetCount"



130
131
132
133
134
135
136
 
# File 'lib/action_web_service/api.rb', line 130

def public_api_method_name(name)
  if inflect_names
    name.to_s.camelize
  else
    name.to_s
  end
end

.soap_client(endpoint_uri, options = {}) ⇒ Object 



9
10
11
 
# File 'lib/action_web_service/protocol/soap_protocol.rb', line 9

def self.soap_client(endpoint_uri, options={})
  ActionWebService::Client::Soap.new self, endpoint_uri, options
end

.xmlrpc_client(endpoint_uri, options = {}) ⇒ Object 



24
25
26
 
# File 'lib/action_web_service/protocol/xmlrpc_protocol.rb', line 24

def self.xmlrpc_client(endpoint_uri, options={})
  ActionWebService::Client::XmlRpc.new self, endpoint_uri, options
end