jstorimer-deep-test 0.1.0

data/sample_rails_project/vendor/rails/actionwebservice/examples/metaWeblog/apis/meta_weblog_service.rb

@@ -0,0 +1,48 @@
+require 'meta_weblog_api'
+
+class MetaWeblogService < ActionWebService::Base
+  web_service_api MetaWeblogAPI
+
+  def initialize
+    @postid = 0
+  end
+
+  def newPost(id, user, pw, struct, publish)
+    $stderr.puts "id=#{id} user=#{user} pw=#{pw}, struct=#{struct.inspect} [#{publish}]"
+    (@postid += 1).to_s
+  end
+
+  def editPost(post_id, user, pw, struct, publish)
+    $stderr.puts "id=#{post_id} user=#{user} pw=#{pw} struct=#{struct.inspect} [#{publish}]"
+    true
+  end
+
+  def getPost(post_id, user, pw)
+    $stderr.puts "get post #{post_id}"
+    Blog::Post.new(:title => 'hello world', :description => 'first post!')
+  end
+
+  def getCategories(id, user, pw)
+    $stderr.puts "categories for #{user}"
+    cat = Blog::Category.new(
+      :description => 'Tech',
+      :htmlUrl     => 'http://blog/tech',
+      :rssUrl      => 'http://blog/tech.rss')
+    [cat]
+  end
+
+  def getRecentPosts(id, user, pw, num)
+    $stderr.puts "recent #{num} posts for #{user} on blog #{id}"
+    post1 = Blog::Post.new(
+      :title => 'first post!',
+      :link => 'http://blog.xeraph.org/testOne.html',
+      :description => 'this is the first post'
+    )
+    post2 = Blog::Post.new(
+      :title => 'second post!',
+      :link => 'http://blog.xeraph.org/testTwo.html',
+      :description => 'this is the second post'
+    )
+    [post1, post2]
+  end
+end

data/sample_rails_project/vendor/rails/actionwebservice/examples/metaWeblog/controllers/xmlrpc_controller.rb

@@ -0,0 +1,16 @@
+#
+# example controller implementing both blogger and metaWeblog APIs
+# in a way that should be compatible with clients supporting both/either.
+#
+# test by pointing your client at http://URL/xmlrpc/api
+# 
+
+require 'meta_weblog_service'
+require 'blogger_service'
+
+class XmlrpcController < ApplicationController
+  web_service_dispatching_mode :layered
+
+  web_service :metaWeblog, MetaWeblogService.new
+  web_service :blogger, BloggerService.new
+end

data/sample_rails_project/vendor/rails/actionwebservice/lib/action_web_service/api.rb

@@ -0,0 +1,249 @@
+module ActionWebService # :nodoc:
+  module API # :nodoc:
+    # A web service API class specifies the methods that will be available for
+    # invocation for an API. It also contains metadata such as the method type
+    # signature hints.
+    #
+    # It is not intended to be instantiated.
+    #
+    # It is attached to web service implementation classes like
+    # ActionWebService::Base and ActionController::Base derivatives by using
+    # <tt>container.web_service_api</tt>, where <tt>container</tt> is an
+    # ActionController::Base or a ActionWebService::Base.
+    #
+    # See ActionWebService::Container::Direct::ClassMethods for an example
+    # of use.
+    class Base
+      # Action WebService API subclasses should be reloaded by the dispatcher in Rails
+      # when Dependencies.mechanism = :load.
+      include Reloadable::Deprecated
+      
+      # Whether to transform the public API method names into camel-cased names 
+      class_inheritable_option :inflect_names, true
+
+      # Whether to allow ActiveRecord::Base models in <tt>:expects</tt>.
+      # The default is +false+; you should be aware of the security implications
+      # of allowing this, and ensure that you don't allow remote callers to
+      # easily overwrite data they should not have access to.
+      class_inheritable_option :allow_active_record_expects, false
+
+      # If present, the name of a method to call when the remote caller
+      # tried to call a nonexistent method. Semantically equivalent to
+      # +method_missing+.
+      class_inheritable_option :default_api_method
+
+      # Disallow instantiation
+      private_class_method :new, :allocate
+      
+      class << self
+        include ActionWebService::SignatureTypes
+
+        # 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:
+        # [<tt>:expects</tt>]             Signature for the method input parameters
+        # [<tt>:returns</tt>]             Signature for the method return value
+        # [<tt>:expects_and_returns</tt>] Signature for both input parameters and return value
+        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 type.type_class.ancestors.include?(ActiveRecord::Base) && !allow_active_record_expects
+                raise(ActionWebServiceError, "ActiveRecord model classes not allowed in :expects")
+              end
+            end
+          end
+          name = name.to_sym
+          public_name = public_api_method_name(name)
+          method = Method.new(name, public_name, expects, returns)
+          write_inheritable_hash("api_methods", name => method)
+          write_inheritable_hash("api_public_method_names", public_name => name)
+        end
+
+        # Whether the given method name is a service method on this API
+        def has_api_method?(name)
+          api_methods.has_key?(name)
+        end
+  
+        # Whether the given public method name has a corresponding service method
+        # on this API
+        def has_public_api_method?(public_name)
+          api_public_method_names.has_key?(public_name)
+        end
+  
+        # The corresponding public method name for the given service method name
+        def public_api_method_name(name)
+          if inflect_names
+            name.to_s.camelize
+          else
+            name.to_s
+          end
+        end
+  
+        # The corresponding service method name for the given public method name
+        def api_method_name(public_name)
+          api_public_method_names[public_name]
+        end
+  
+        # A Hash containing all service methods on this API, and their
+        # associated metadata.
+        def api_methods
+          read_inheritable_attribute("api_methods") || {}
+        end
+
+        # The Method instance for the given public API method name, if any
+        def public_api_method_instance(public_method_name)
+          api_method_instance(api_method_name(public_method_name))
+        end
+
+        # The Method instance for the given API method name, if any
+        def api_method_instance(method_name)
+          api_methods[method_name]
+        end
+
+        # The Method instance for the default API method, if any
+        def default_api_method_instance
+          return nil unless name = default_api_method
+          instance = read_inheritable_attribute("default_api_method_instance")
+          if instance && instance.name == name
+            return instance
+          end
+          instance = Method.new(name, public_api_method_name(name), nil, nil)
+          write_inheritable_attribute("default_api_method_instance", instance)
+          instance
+        end
+
+        private
+          def api_public_method_names
+            read_inheritable_attribute("api_public_method_names") || {}
+          end
+  
+          def validate_options(valid_option_keys, supplied_option_keys)
+            unknown_option_keys = supplied_option_keys - valid_option_keys
+            unless unknown_option_keys.empty?
+              raise(ActionWebServiceError, "Unknown options: #{unknown_option_keys}")
+            end
+          end
+      end
+    end
+
+    # Represents an API method and its associated metadata, and provides functionality
+    # to assist in commonly performed API method tasks.
+    class Method
+      attr :name
+      attr :public_name
+      attr :expects
+      attr :returns
+
+      def initialize(name, public_name, expects, returns)
+        @name = name
+        @public_name = public_name
+        @expects = expects
+        @returns = returns
+        @caster = ActionWebService::Casting::BaseCaster.new(self)
+      end
+      
+      # The list of parameter names for this method
+      def param_names
+        return [] unless @expects
+        @expects.map{ |type| type.name }
+      end
+
+      # Casts a set of Ruby values into the expected Ruby values
+      def cast_expects(params)
+        @caster.cast_expects(params)
+      end
+
+      # Cast a Ruby return value into the expected Ruby value
+      def cast_returns(return_value)
+        @caster.cast_returns(return_value)
+      end
+
+      # Returns the index of the first expected parameter
+      # with the given name
+      def expects_index_of(param_name)
+        return -1 if @expects.nil?
+        (0..(@expects.length-1)).each do |i|
+          return i if @expects[i].name.to_s == param_name.to_s
+        end
+        -1
+      end
+
+      # Returns a hash keyed by parameter name for the given
+      # parameter list
+      def expects_to_hash(params)
+        return {} if @expects.nil?
+        h = {}
+        @expects.zip(params){ |type, param| h[type.name] = param }
+        h
+      end
+
+      # Backwards compatibility with previous API
+      def [](sig_type)
+        case sig_type
+        when :expects
+          @expects.map{|x| compat_signature_entry(x)}
+        when :returns
+          @returns.map{|x| compat_signature_entry(x)}
+        end
+      end
+
+      # String representation of this method
+      def to_s
+        fqn = ""
+        fqn << (@returns ? (@returns[0].human_name(false) + " ") : "void ")
+        fqn << "#{@public_name}("
+        fqn << @expects.map{ |p| p.human_name }.join(", ") if @expects
+        fqn << ")"
+        fqn
+      end
+
+      private
+        def compat_signature_entry(entry)
+          if entry.array?
+            [compat_signature_entry(entry.element_type)]
+          else
+            if entry.spec.is_a?(Hash)
+              {entry.spec.keys.first => entry.type_class}
+            else
+              entry.type_class
+            end
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+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
+    # Action WebService subclasses should be reloaded by the dispatcher in Rails
+    # when Dependencies.mechanism = :load.
+    include Reloadable::Deprecated
+
+    # 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/sample_rails_project/vendor/rails/actionwebservice/lib/action_web_service/casting.rb

@@ -0,0 +1,136 @@
+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 :time
+            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?(Time) ? value : Time.parse(value.to_s)
+          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/sample_rails_project/vendor/rails/actionwebservice/lib/action_web_service/client/base.rb

@@ -0,0 +1,28 @@
+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/sample_rails_project/vendor/rails/actionwebservice/lib/action_web_service/client/soap_client.rb

@@ -0,0 +1,113 @@
+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/sample_rails_project/vendor/rails/actionwebservice/lib/action_web_service/client/xmlrpc_client.rb

@@ -0,0 +1,58 @@
+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