typo 5.2 → 5.2.98

data/vendor/actionwebservice/lib/action_web_service/base.rb

@@ -1,38 +0,0 @@
-module ActionWebService # :nodoc:
-  class ActionWebServiceError < StandardError # :nodoc:
-  end
-
-  # An Action Web Service object implements a specified API.
-  #
-  # Used by controllers operating in _Delegated_ dispatching mode.
-  #
-  # ==== Example
-  # 
-  #   class PersonService < ActionWebService::Base
-  #     web_service_api PersonAPI
-  #
-  #     def find_person(criteria)
-  #       Person.find(:all) [...]
-  #     end
-  #
-  #     def delete_person(id)
-  #       Person.find_by_id(id).destroy
-  #     end
-  #   end
-  #
-  #   class PersonAPI < ActionWebService::API::Base
-  #     api_method :find_person,   :expects => [SearchCriteria], :returns => [[Person]]
-  #     api_method :delete_person, :expects => [:int]
-  #   end
-  #
-  #   class SearchCriteria < ActionWebService::Struct
-  #     member :firstname, :string
-  #     member :lastname,  :string
-  #     member :email,     :string
-  #   end
-  class Base
-    # Whether to report exceptions back to the caller in the protocol's exception
-    # format
-    class_inheritable_option :web_service_exception_reporting, true
-  end
-end

data/vendor/actionwebservice/lib/action_web_service/casting.rb

@@ -1,144 +0,0 @@
-require 'time'
-require 'date'
-require 'xmlrpc/datetime'
-
-module ActionWebService # :nodoc:
-  module Casting # :nodoc:
-    class CastingError < ActionWebServiceError # :nodoc:
-    end
-
-    # Performs casting of arbitrary values into the correct types for the signature
-    class BaseCaster # :nodoc:
-      def initialize(api_method)
-        @api_method = api_method
-      end
-
-      # Coerces the parameters in +params+ (an Enumerable) into the types
-      # this method expects
-      def cast_expects(params)
-        self.class.cast_expects(@api_method, params)
-      end
-
-      # Coerces the given +return_value+ into the type returned by this
-      # method
-      def cast_returns(return_value)
-        self.class.cast_returns(@api_method, return_value)
-      end
-
-      class << self
-        include ActionWebService::SignatureTypes
-
-        def cast_expects(api_method, params) # :nodoc:
-          return [] if api_method.expects.nil?
-          api_method.expects.zip(params).map{ |type, param| cast(param, type) }
-        end
-
-        def cast_returns(api_method, return_value) # :nodoc:
-          return nil if api_method.returns.nil?
-          cast(return_value, api_method.returns[0])
-        end
-
-        def cast(value, signature_type) # :nodoc:
-          return value if signature_type.nil? # signature.length != params.length
-          return nil if value.nil?
-          # XMLRPC protocol doesn't support nil values. It uses false instead.
-          # It should never happen for SOAP.
-          if signature_type.structured? && value.equal?(false)
-            return nil
-          end
-          unless signature_type.array? || signature_type.structured?
-            return value if canonical_type(value.class) == signature_type.type
-          end
-          if signature_type.array?
-            unless value.respond_to?(:entries) && !value.is_a?(String)
-              raise CastingError, "Don't know how to cast #{value.class} into #{signature_type.type.inspect}"
-            end
-            value.entries.map do |entry|
-              cast(entry, signature_type.element_type)
-            end
-          elsif signature_type.structured?
-            cast_to_structured_type(value, signature_type)
-          elsif !signature_type.custom?
-            cast_base_type(value, signature_type)
-          end
-        end
-
-        def cast_base_type(value, signature_type) # :nodoc:
-          # This is a work-around for the fact that XML-RPC special-cases DateTime values into its own DateTime type
-          # in order to support iso8601 dates. This doesn't work too well for us, so we'll convert it into a Time,
-          # with the caveat that we won't be able to handle pre-1970 dates that are sent to us.
-          # 
-          # See http://dev.rubyonrails.com/ticket/2516
-          value = value.to_time if value.is_a?(XMLRPC::DateTime)
-
-          case signature_type.type
-          when :int
-            Integer(value)
-          when :string
-            value.to_s
-          when :base64
-            if value.is_a?(ActionWebService::Base64)
-              value
-            else
-              ActionWebService::Base64.new(value.to_s)
-            end
-          when :bool
-            return false if value.nil?
-            return value if value == true || value == false
-            case value.to_s.downcase
-            when '1', 'true', 'y', 'yes'
-              true
-            when '0', 'false', 'n', 'no'
-              false
-            else
-              raise CastingError, "Don't know how to cast #{value.class} into Boolean"
-            end
-          when :float
-            Float(value)
-          when :decimal
-            BigDecimal(value.to_s)
-          when :time
-            value = "%s/%s/%s %s:%s:%s" % value.values_at(*%w[2 3 1 4 5 6]) if value.kind_of?(Hash)
-            if value.kind_of?(Time) 
-              value
-            elsif value.kind_of?(DateTime)
-              value.to_time
-            else
-              Time.parse(value.to_s)
-            end
-          when :date
-            value = "%s/%s/%s" % value.values_at(*%w[2 3 1]) if value.kind_of?(Hash)
-            value.kind_of?(Date) ? value : Date.parse(value.to_s)
-          when :datetime
-            value = "%s/%s/%s %s:%s:%s" % value.values_at(*%w[2 3 1 4 5 6]) if value.kind_of?(Hash)
-            value.kind_of?(DateTime) ? value : DateTime.parse(value.to_s)
-          end
-        end
-
-        def cast_to_structured_type(value, signature_type) # :nodoc:
-          obj = nil
-          obj = value if canonical_type(value.class) == canonical_type(signature_type.type)
-          obj ||= signature_type.type_class.new
-          if value.respond_to?(:each_pair)
-            klass = signature_type.type_class
-            value.each_pair do |name, val|
-              type = klass.respond_to?(:member_type) ? klass.member_type(name) : nil
-              val = cast(val, type) if type
-              # See http://dev.rubyonrails.com/ticket/3567
-              val = val.to_time if val.is_a?(XMLRPC::DateTime)
-              obj.__send__("#{name}=", val) if obj.respond_to?(name)
-            end
-          elsif value.respond_to?(:attributes)
-            signature_type.each_member do |name, type|
-              val = value.__send__(name)
-              obj.__send__("#{name}=", cast(val, type)) if obj.respond_to?(name)
-            end
-          else
-            raise CastingError, "Don't know how to cast #{value.class} to #{signature_type.type_class}"
-          end
-          obj
-        end
-      end
-    end
-  end
-end

data/vendor/actionwebservice/lib/action_web_service/client.rb

@@ -1,3 +0,0 @@
-require 'action_web_service/client/base'
-require 'action_web_service/client/soap_client'
-require 'action_web_service/client/xmlrpc_client'

data/vendor/actionwebservice/lib/action_web_service/client/base.rb

@@ -1,28 +0,0 @@
-module ActionWebService # :nodoc:
-  module Client # :nodoc:
-    class ClientError < StandardError # :nodoc:
-    end
-
-    class Base # :nodoc:
-      def initialize(api, endpoint_uri)
-        @api = api
-        @endpoint_uri = endpoint_uri
-      end
-
-      def method_missing(name, *args) # :nodoc:
-        call_name = method_name(name)
-        return super(name, *args) if call_name.nil?
-        self.perform_invocation(call_name, args)
-      end
-
-      private
-        def method_name(name)
-          if @api.has_api_method?(name.to_sym)
-            name.to_s
-          elsif @api.has_public_api_method?(name.to_s)
-            @api.api_method_name(name.to_s).to_s
-          end
-        end
-    end
-  end
-end

data/vendor/actionwebservice/lib/action_web_service/client/soap_client.rb

@@ -1,113 +0,0 @@
-require 'soap/rpc/driver'
-require 'uri'
-
-module ActionWebService # :nodoc:
-  module Client # :nodoc:
-
-    # Implements SOAP client support (using RPC encoding for the messages).
-    #
-    # ==== Example Usage
-    #
-    #   class PersonAPI < ActionWebService::API::Base
-    #     api_method :find_all, :returns => [[Person]]
-    #   end
-    #
-    #   soap_client = ActionWebService::Client::Soap.new(PersonAPI, "http://...")
-    #   persons = soap_client.find_all
-    #
-    class Soap < Base
-      # provides access to the underlying soap driver
-      attr_reader :driver
-
-      # Creates a new web service client using the SOAP RPC protocol.
-      #
-      # +api+ must be an ActionWebService::API::Base derivative, and
-      # +endpoint_uri+ must point at the relevant URL to which protocol requests
-      # will be sent with HTTP POST.
-      #
-      # Valid options:
-      # [<tt>:namespace</tt>]    If the remote server has used a custom namespace to
-      #                          declare its custom types, you can specify it here. This would
-      #                          be the namespace declared with a [WebService(Namespace = "http://namespace")] attribute
-      #                          in .NET, for example.
-      # [<tt>:driver_options</tt>]    If you want to supply any custom SOAP RPC driver
-      #                               options, you can provide them as a Hash here
-      #
-      # The <tt>:driver_options</tt> option can be used to configure the backend SOAP
-      # RPC driver. An example of configuring the SOAP backend to do
-      # client-certificate authenticated SSL connections to the server:
-      #
-      #   opts = {}
-      #   opts['protocol.http.ssl_config.verify_mode'] = 'OpenSSL::SSL::VERIFY_PEER'
-      #   opts['protocol.http.ssl_config.client_cert'] = client_cert_file_path
-      #   opts['protocol.http.ssl_config.client_key'] = client_key_file_path
-      #   opts['protocol.http.ssl_config.ca_file'] = ca_cert_file_path
-      #   client = ActionWebService::Client::Soap.new(api, 'https://some/service', :driver_options => opts)
-      def initialize(api, endpoint_uri, options={})
-        super(api, endpoint_uri)
-        @namespace = options[:namespace] || 'urn:ActionWebService'
-        @driver_options = options[:driver_options] || {}
-        @protocol = ActionWebService::Protocol::Soap::SoapProtocol.new @namespace
-        @soap_action_base = options[:soap_action_base]
-        @soap_action_base ||= URI.parse(endpoint_uri).path
-        @driver = create_soap_rpc_driver(api, endpoint_uri)
-        @driver_options.each do |name, value|
-          @driver.options[name.to_s] = value
-        end
-      end
-
-      protected
-        def perform_invocation(method_name, args)
-          method = @api.api_methods[method_name.to_sym]
-          args = method.cast_expects(args.dup) rescue args
-          return_value = @driver.send(method_name, *args)
-          method.cast_returns(return_value.dup) rescue return_value
-        end
-
-        def soap_action(method_name)
-          "#{@soap_action_base}/#{method_name}"
-        end
-
-      private
-        def create_soap_rpc_driver(api, endpoint_uri)
-          @protocol.register_api(api)
-          driver = SoapDriver.new(endpoint_uri, nil)
-          driver.mapping_registry = @protocol.marshaler.registry
-          api.api_methods.each do |name, method|
-            qname = XSD::QName.new(@namespace, method.public_name)
-            action = soap_action(method.public_name)
-            expects = method.expects
-            returns = method.returns
-            param_def = []
-            if expects
-              expects.each do |type|
-                type_binding = @protocol.marshaler.lookup_type(type)
-                if SOAP::Version >= "1.5.5"
-                  param_def << ['in', type.name.to_s, [type_binding.type.type_class.to_s]]
-                else
-                  param_def << ['in', type.name, type_binding.mapping]
-                end
-              end
-            end
-            if returns
-              type_binding = @protocol.marshaler.lookup_type(returns[0])
-              if SOAP::Version >= "1.5.5"
-                param_def << ['retval', 'return', [type_binding.type.type_class.to_s]]
-              else
-                param_def << ['retval', 'return', type_binding.mapping]
-              end
-            end
-            driver.add_method(qname, action, method.name.to_s, param_def)
-          end
-          driver
-        end
-
-        class SoapDriver < SOAP::RPC::Driver # :nodoc:
-          def add_method(qname, soapaction, name, param_def)
-            @proxy.add_rpc_method(qname, soapaction, name, param_def)
-            add_rpc_method_interface(name, param_def)
-          end
-        end
-    end
-  end
-end

data/vendor/actionwebservice/lib/action_web_service/client/xmlrpc_client.rb

@@ -1,58 +0,0 @@
-require 'uri'
-require 'xmlrpc/client'
-
-module ActionWebService # :nodoc:
-  module Client # :nodoc:
-
-    # Implements XML-RPC client support
-    #
-    # ==== Example Usage
-    #
-    #   class BloggerAPI < ActionWebService::API::Base
-    #     inflect_names false
-    #     api_method :getRecentPosts, :returns => [[Blog::Post]]
-    #   end
-    #
-    #   blog = ActionWebService::Client::XmlRpc.new(BloggerAPI, "http://.../RPC", :handler_name => "blogger")
-    #   posts = blog.getRecentPosts
-    class XmlRpc < Base
-
-      # Creates a new web service client using the XML-RPC protocol.
-      #
-      # +api+ must be an ActionWebService::API::Base derivative, and
-      # +endpoint_uri+ must point at the relevant URL to which protocol requests
-      # will be sent with HTTP POST.
-      #
-      # Valid options:
-      # [<tt>:handler_name</tt>]    If the remote server defines its services inside special
-      #                             handler (the Blogger API uses a <tt>"blogger"</tt> handler name for example),
-      #                             provide it here, or your method calls will fail
-      def initialize(api, endpoint_uri, options={})
-        @api = api
-        @handler_name = options[:handler_name]
-        @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.new
-        @client = XMLRPC::Client.new2(endpoint_uri, options[:proxy], options[:timeout])
-      end
-
-      protected
-        def perform_invocation(method_name, args)
-          method = @api.api_methods[method_name.to_sym]
-          if method.expects && method.expects.length != args.length
-            raise(ArgumentError, "#{method.public_name}: wrong number of arguments (#{args.length} for #{method.expects.length})")
-          end
-          args = method.cast_expects(args.dup) rescue args
-          if method.expects
-            method.expects.each_with_index{ |type, i| args[i] = @protocol.value_to_xmlrpc_wire_format(args[i], type) }
-          end
-          ok, return_value = @client.call2(public_name(method_name), *args)
-          return (method.cast_returns(return_value.dup) rescue return_value) if ok
-          raise(ClientError, "#{return_value.faultCode}: #{return_value.faultString}")
-        end
-
-        def public_name(method_name)
-          public_name = @api.public_api_method_name(method_name)
-          @handler_name ? "#{@handler_name}.#{public_name}" : public_name
-        end
-    end
-  end
-end

data/vendor/actionwebservice/lib/action_web_service/container.rb

@@ -1,3 +0,0 @@
-require 'action_web_service/container/direct_container'
-require 'action_web_service/container/delegated_container'
-require 'action_web_service/container/action_controller_container'

data/vendor/actionwebservice/lib/action_web_service/container/action_controller_container.rb

@@ -1,93 +0,0 @@
-module ActionWebService # :nodoc:
-  module Container # :nodoc:
-    module ActionController # :nodoc:
-      def self.included(base) # :nodoc:
-        class << base
-          include ClassMethods
-          alias_method_chain :inherited, :api
-          alias_method_chain :web_service_api, :require
-        end
-      end
-
-      module ClassMethods
-        # Creates a client for accessing remote web services, using the
-        # given +protocol+ to communicate with the +endpoint_uri+.
-        #
-        # ==== Example
-        #
-        #   class MyController < ActionController::Base
-        #     web_client_api :blogger, :xmlrpc, "http://blogger.com/myblog/api/RPC2", :handler_name => 'blogger'
-        #   end
-        #
-        # In this example, a protected method named <tt>blogger</tt> will
-        # now exist on the controller, and calling it will return the
-        # XML-RPC client object for working with that remote service.
-        #
-        # +options+ is the set of protocol client specific options (see
-        # a protocol client class for details).
-        #
-        # If your API definition does not exist on the load path with the
-        # correct rules for it to be found using +name+, you can pass in
-        # the API definition class via +options+, using a key of <tt>:api</tt>
-        def web_client_api(name, protocol, endpoint_uri, options={})
-          unless method_defined?(name)
-            api_klass = options.delete(:api) || require_web_service_api(name)
-            class_eval do
-              define_method(name) do
-                create_web_service_client(api_klass, protocol, endpoint_uri, options)
-              end
-              protected name
-            end
-          end
-        end
-
-        def web_service_api_with_require(definition=nil) # :nodoc:
-          return web_service_api_without_require if definition.nil?
-          case definition
-          when String, Symbol
-            klass = require_web_service_api(definition)
-          else
-            klass = definition
-          end
-          web_service_api_without_require(klass)
-        end
-
-        def require_web_service_api(name) # :nodoc:
-          case name
-          when String, Symbol
-            file_name = name.to_s.underscore + "_api"
-            class_name = file_name.camelize
-            class_names = [class_name, class_name.sub(/Api$/, 'API')]
-            begin
-              require_dependency(file_name)
-            rescue LoadError => load_error
-              requiree = / -- (.*?)(\.rb)?$/.match(load_error).to_a[1]
-              msg = requiree == file_name ? "Missing API definition file in apis/#{file_name}.rb" : "Can't load file: #{requiree}"
-              raise LoadError.new(msg).copy_blame!(load_error)
-            end
-            klass = nil
-            class_names.each do |name|
-              klass = name.constantize rescue nil
-              break unless klass.nil?
-            end
-            unless klass
-              raise(NameError, "neither #{class_names[0]} or #{class_names[1]} found")
-            end
-            klass
-          else
-            raise(ArgumentError, "expected String or Symbol argument")
-          end
-        end
-
-        private
-          def inherited_with_api(child)
-            inherited_without_api(child)
-            begin child.web_service_api(child.controller_path)
-            rescue MissingSourceFile => e
-              raise unless e.is_missing?("apis/#{child.controller_path}_api")
-            end
-          end
-      end
-    end
-  end
-end