typo 5.3 → 5.4

data/vendor/actionwebservice/lib/action_web_service/protocol/soap_protocol/marshaler.rb

@@ -1,242 +0,0 @@
-require 'soap/mapping'
-
-# hack to improve the .Net interoperability
-class SOAP::Mapping::Object
-  def each_pair
-    self.__xmlele.each { |n, v| yield n.name, v.to_s }
-  end
-end
-
-module ActionWebService
-  module Protocol
-    module Soap
-      # Workaround for SOAP4R return values changing
-      class Registry < SOAP::Mapping::Registry
-        if SOAP::Version >= "1.5.4"
-          def find_mapped_soap_class(obj_class)
-            return @map.instance_eval { @obj2soap[obj_class][0] }
-          end
-
-          def find_mapped_obj_class(soap_class)
-            return @map.instance_eval { @soap2obj[soap_class][0] }
-          end
-        end
-      end
-
-      class SoapMarshaler
-        attr :namespace
-        attr :registry
-
-        def initialize(namespace=nil)
-          @namespace = namespace || 'urn:ActionWebService'
-          @registry = Registry.new
-          @type2binding = {}
-          register_static_factories
-        end
-
-        def soap_to_ruby(obj)
-          SOAP::Mapping.soap2obj(obj, @registry)
-        end
-
-        def ruby_to_soap(obj)
-          soap = SOAP::Mapping.obj2soap(obj, @registry)
-          soap.elename = XSD::QName.new if SOAP::Version >= "1.5.5" && soap.elename == XSD::QName::EMPTY
-          soap
-        end
-
-        def register_type(type)
-          return @type2binding[type] if @type2binding.has_key?(type)
-
-          if type.array?
-            array_mapping = @registry.find_mapped_soap_class(Array)
-            qname = XSD::QName.new(@namespace, soap_type_name(type.element_type.type_class.name) + 'Array')
-            element_type_binding = register_type(type.element_type)
-            @type2binding[type] = SoapBinding.new(self, qname, type, array_mapping, element_type_binding)
-          elsif (mapping = @registry.find_mapped_soap_class(type.type_class) rescue nil)
-            qname = mapping[2] ? mapping[2][:type] : nil
-            qname ||= soap_base_type_name(mapping[0])
-            @type2binding[type] = SoapBinding.new(self, qname, type, mapping)
-          else
-            qname = XSD::QName.new(@namespace, soap_type_name(type.type_class.name))
-            @registry.add(type.type_class,
-              SOAP::SOAPStruct,
-              typed_struct_factory(type.type_class),
-              { :type => qname })
-            mapping = @registry.find_mapped_soap_class(type.type_class)
-            @type2binding[type] = SoapBinding.new(self, qname, type, mapping)
-          end
-
-          if type.structured?
-            type.each_member do |m_name, m_type|
-              register_type(m_type)
-            end
-          end
-          
-          @type2binding[type]
-        end
-        alias :lookup_type :register_type
-
-        def annotate_arrays(binding, value)
-          if value.nil?
-            return
-          elsif binding.type.array?
-            mark_typed_array(value, binding.element_binding.qname)
-            if binding.element_binding.type.custom?
-              value.each do |element|
-                annotate_arrays(binding.element_binding, element)
-              end
-            end
-          elsif binding.type.structured?
-            binding.type.each_member do |name, type|
-              member_binding = register_type(type)
-              member_value = value.respond_to?('[]') ? value[name] : value.send(name)
-              annotate_arrays(member_binding, member_value) if type.custom?
-            end
-          end
-        end
-
-        private
-          def typed_struct_factory(type_class)
-            if Object.const_defined?('ActiveRecord')
-              if type_class.ancestors.include?(ActiveRecord::Base)
-                qname =  XSD::QName.new(@namespace, soap_type_name(type_class.name))
-                type_class.instance_variable_set('@qname', qname)
-                return SoapActiveRecordStructFactory.new
-              end
-            end
-            SOAP::Mapping::Registry::TypedStructFactory
-          end
-
-          def mark_typed_array(array, qname)
-            (class << array; self; end).class_eval do 
-              define_method(:arytype) do
-                qname
-              end
-            end
-          end
-
-          def soap_base_type_name(type)
-            xsd_type = type.ancestors.find{ |c| c.const_defined? 'Type' }
-            xsd_type ? xsd_type.const_get('Type') : XSD::XSDAnySimpleType::Type
-          end
-
-          def soap_type_name(type_name)
-            type_name.gsub(/::/, '..')
-          end
-
-          def register_static_factories
-            @registry.add(ActionWebService::Base64, SOAP::SOAPBase64, SoapBase64Factory.new, nil)
-            mapping = @registry.find_mapped_soap_class(ActionWebService::Base64)
-            @type2binding[ActionWebService::Base64] =
-              SoapBinding.new(self, SOAP::SOAPBase64::Type, ActionWebService::Base64, mapping)
-            @registry.add(Array, SOAP::SOAPArray, SoapTypedArrayFactory.new, nil)
-            @registry.add(::BigDecimal, SOAP::SOAPDouble, SOAP::Mapping::Registry::BasetypeFactory, {:derived_class => true})
-          end
-      end
-
-      class SoapBinding
-        attr :qname
-        attr :type
-        attr :mapping
-        attr :element_binding
-
-        def initialize(marshaler, qname, type, mapping, element_binding=nil)
-          @marshaler = marshaler
-          @qname = qname
-          @type = type
-          @mapping = mapping
-          @element_binding = element_binding
-        end
-
-        def type_name
-          @type.custom? ? @qname.name : nil
-        end
-
-        def qualified_type_name(ns=nil)
-          if @type.custom?
-            "#{ns ? ns : @qname.namespace}:#{@qname.name}"
-          else
-            ns = XSD::NS.new
-            ns.assign(XSD::Namespace, SOAP::XSDNamespaceTag)
-            ns.assign(SOAP::EncodingNamespace, "soapenc")
-            xsd_klass = mapping[0].ancestors.find{|c| c.const_defined?('Type')}
-            return ns.name(XSD::AnyTypeName) unless xsd_klass
-            ns.name(xsd_klass.const_get('Type'))
-          end
-        end
-
-        def eql?(other)
-          @qname == other.qname
-        end
-        alias :== :eql?
-
-        def hash
-          @qname.hash
-        end
-      end
-
-      class SoapActiveRecordStructFactory < SOAP::Mapping::Factory
-        def obj2soap(soap_class, obj, info, map)
-          unless obj.is_a?(ActiveRecord::Base)
-            return nil
-          end
-          soap_obj = soap_class.new(obj.class.instance_variable_get('@qname'))
-          obj.class.columns.each do |column|
-            key = column.name.to_s
-            value = obj.send(key)
-            soap_obj[key] = SOAP::Mapping._obj2soap(value, map)
-          end
-          soap_obj
-        end
-
-        def soap2obj(obj_class, node, info, map)
-          unless node.type == obj_class.instance_variable_get('@qname')
-            return false
-          end
-          obj = obj_class.new
-          node.each do |key, value|
-            obj[key] = value.data
-          end
-          obj.instance_variable_set('@new_record', false)
-          return true, obj
-        end
-      end
-
-      class SoapTypedArrayFactory < SOAP::Mapping::Factory
-        def obj2soap(soap_class, obj, info, map)
-          unless obj.respond_to?(:arytype)
-            return nil
-          end
-          soap_obj = soap_class.new(SOAP::ValueArrayName, 1, obj.arytype)
-          mark_marshalled_obj(obj, soap_obj)
-          obj.each do |item|
-            child = SOAP::Mapping._obj2soap(item, map)
-            soap_obj.add(child)
-          end
-          soap_obj
-        end
-      
-        def soap2obj(obj_class, node, info, map)
-          return false
-        end
-      end
-
-      class SoapBase64Factory < SOAP::Mapping::Factory
-        def obj2soap(soap_class, obj, info, map)
-          unless obj.is_a?(ActionWebService::Base64)
-            return nil
-          end
-          return soap_class.new(obj)
-        end
-
-        def soap2obj(obj_class, node, info, map)
-          unless node.type == SOAP::SOAPBase64::Type
-            return false
-          end
-          return true, obj_class.new(node.string)
-        end
-      end
-
-    end
-  end
-end

data/vendor/actionwebservice/lib/action_web_service/protocol/xmlrpc_protocol.rb

@@ -1,122 +0,0 @@
-require 'xmlrpc/marshal'
-require 'action_web_service/client/xmlrpc_client'
-
-module XMLRPC # :nodoc:
-  class FaultException # :nodoc:
-    alias :message :faultString
-  end
-  
-  class Create
-    def wrong_type(value)
-      if BigDecimal === value
-        [true, value.to_f]
-      else
-        false
-      end
-    end
-  end
-end
-
-module ActionWebService # :nodoc:
-  module API # :nodoc: 
-    class Base # :nodoc:
-      def self.xmlrpc_client(endpoint_uri, options={})
-        ActionWebService::Client::XmlRpc.new self, endpoint_uri, options
-      end
-    end
-  end
-
-  module Protocol # :nodoc:
-    module XmlRpc # :nodoc:
-      def self.included(base)
-        base.register_protocol(XmlRpcProtocol)
-      end
-      
-      class XmlRpcProtocol < AbstractProtocol # :nodoc:
-        def self.create(controller)
-          XmlRpcProtocol.new
-        end
-
-        def decode_action_pack_request(action_pack_request)
-          service_name = action_pack_request.parameters['action']
-          decode_request(action_pack_request.raw_post, service_name)
-        end
-
-        def decode_request(raw_request, service_name)
-          method_name, params = XMLRPC::Marshal.load_call(raw_request)
-          Request.new(self, method_name, params, service_name)
-        rescue
-          return nil
-        end
-
-        def encode_request(method_name, params, param_types)
-          if param_types
-            params = params.dup
-            param_types.each_with_index{ |type, i| params[i] = value_to_xmlrpc_wire_format(params[i], type) }
-          end
-          XMLRPC::Marshal.dump_call(method_name, *params)
-        end
-
-        def decode_response(raw_response)
-          [nil, XMLRPC::Marshal.load_response(raw_response)]
-        end
-
-        def encode_response(method_name, return_value, return_type, protocol_options={})
-          if return_value && return_type
-            return_value = value_to_xmlrpc_wire_format(return_value, return_type)
-          end
-          return_value = false if return_value.nil?
-          raw_response = XMLRPC::Marshal.dump_response(return_value)
-          Response.new(raw_response, 'text/xml', return_value)
-        end
-
-        def encode_multicall_response(responses, protocol_options={})
-          result = responses.map do |return_value, return_type|
-            if return_value && return_type
-              return_value = value_to_xmlrpc_wire_format(return_value, return_type) 
-              return_value = [return_value] unless return_value.nil?
-            end
-            return_value = false if return_value.nil?
-            return_value
-          end
-          raw_response = XMLRPC::Marshal.dump_response(result)
-          Response.new(raw_response, 'text/xml', result)
-        end
-
-        def protocol_client(api, protocol_name, endpoint_uri, options={})
-          return nil unless protocol_name == :xmlrpc
-          ActionWebService::Client::XmlRpc.new(api, endpoint_uri, options)
-        end
-
-        def value_to_xmlrpc_wire_format(value, value_type)
-          if value_type.array?
-            value.map{ |val| value_to_xmlrpc_wire_format(val, value_type.element_type) }
-          else
-            if value.is_a?(ActionWebService::Struct)
-              struct = {}
-              value.class.members.each do |name, type|
-                member_value = value[name]
-                next if member_value.nil?
-                struct[name.to_s] = value_to_xmlrpc_wire_format(member_value, type)
-              end
-              struct
-            elsif value.is_a?(ActiveRecord::Base)
-              struct = {}
-              value.attributes.each do |key, member_value|
-                next if member_value.nil?
-                struct[key.to_s] = member_value
-              end
-              struct
-            elsif value.is_a?(ActionWebService::Base64)
-              XMLRPC::Base64.new(value)
-            elsif value.is_a?(Exception) && !value.is_a?(XMLRPC::FaultException)
-              XMLRPC::FaultException.new(2, value.message)
-            else
-              value
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,281 +0,0 @@
-require 'benchmark'
-require 'pathname'
-
-module ActionWebService
-  module Scaffolding # :nodoc:
-    class ScaffoldingError < ActionWebServiceError # :nodoc:
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # Web service invocation scaffolding provides a way to quickly invoke web service methods in a controller. The
-    # generated scaffold actions have default views to let you enter the method parameters and view the
-    # results.
-    #
-    # Example:
-    #
-    #   class ApiController < ActionController
-    #     web_service_scaffold :invoke
-    #   end
-    #
-    # This example generates an +invoke+ action in the +ApiController+ that you can navigate to from
-    # your browser, select the API method, enter its parameters, and perform the invocation.
-    #
-    # If you want to customize the default views, create the following views in "app/views":
-    #
-    # * <tt>action_name/methods.html.erb</tt>
-    # * <tt>action_name/parameters.html.erb</tt>
-    # * <tt>action_name/result.html.erb</tt>
-    # * <tt>action_name/layout.html.erb</tt>
-    #
-    # Where <tt>action_name</tt> is the name of the action you gave to ClassMethods#web_service_scaffold.
-    #
-    # You can use the default views in <tt>RAILS_DIR/lib/action_web_service/templates/scaffolds</tt> as
-    # a guide.
-    module ClassMethods
-      # Generates web service invocation scaffolding for the current controller. The given action name
-      # can then be used as the entry point for invoking API methods from a web browser.
-      def web_service_scaffold(action_name)
-        add_template_helper(Helpers)
-        module_eval <<-"end_eval", __FILE__, __LINE__ + 1
-          def #{action_name}
-            if request.method == :get
-              setup_invocation_assigns
-              render_invocation_scaffold 'methods'
-            end
-          end
-
-          def #{action_name}_method_params
-            if request.method == :get
-              setup_invocation_assigns
-              render_invocation_scaffold 'parameters'
-            end
-          end
-
-          def #{action_name}_submit
-            if request.method == :post
-              setup_invocation_assigns
-              protocol_name = params['protocol'] ? params['protocol'].to_sym : :soap
-              case protocol_name
-              when :soap
-                @protocol = Protocol::Soap::SoapProtocol.create(self)
-              when :xmlrpc
-                @protocol = Protocol::XmlRpc::XmlRpcProtocol.create(self)
-              end
-              bm = Benchmark.measure do
-                @protocol.register_api(@scaffold_service.api)
-                post_params = params['method_params'] ? params['method_params'].dup : nil
-                params = []
-                @scaffold_method.expects.each_with_index do |spec, i|
-                  params << post_params[i.to_s]                                            
-                end if @scaffold_method.expects
-                params = @scaffold_method.cast_expects(params)
-                method_name = public_method_name(@scaffold_service.name, @scaffold_method.public_name)
-                @method_request_xml = @protocol.encode_request(method_name, params, @scaffold_method.expects)
-                new_request = @protocol.encode_action_pack_request(@scaffold_service.name, @scaffold_method.public_name, @method_request_xml)
-                prepare_request(new_request, @scaffold_service.name, @scaffold_method.public_name)
-                self.request = new_request
-                if @scaffold_container.dispatching_mode != :direct
-                  request.parameters['action'] = @scaffold_service.name
-                end
-                dispatch_web_service_request
-                @method_response_xml = response.body
-                method_name, obj = @protocol.decode_response(@method_response_xml)
-                return if handle_invocation_exception(obj)
-                @method_return_value = @scaffold_method.cast_returns(obj)
-              end
-              @method_elapsed = bm.real
-              reset_invocation_response
-              render_invocation_scaffold 'result'
-            end
-          end
-
-          private
-            def setup_invocation_assigns
-              @scaffold_class = self.class
-              @scaffold_action_name = "#{action_name}"
-              @scaffold_container = WebServiceModel::Container.new(self)
-              if params['service'] && params['method']
-                @scaffold_service = @scaffold_container.services.find{ |x| x.name == params['service'] }
-                @scaffold_method = @scaffold_service.api_methods[params['method']]
-              end
-            end
-
-            def render_invocation_scaffold(action)
-              customized_template = "\#{self.class.controller_path}/#{action_name}/\#{action}"
-              default_template = scaffold_path(action)
-              if template_exists?(customized_template)
-                content = @template.render(:file => customized_template)
-              else
-                content = @template.render(:file => default_template)
-              end
-              @template.instance_variable_set("@content_for_layout", content)
-              if self.active_layout.nil?
-                render :file => scaffold_path("layout")
-              else
-                render :file => self.active_layout, :use_full_path => true
-              end
-            end
-
-            def scaffold_path(template_name)
-              File.dirname(__FILE__) + "/templates/scaffolds/" + template_name + ".html.erb"
-            end
-
-            def reset_invocation_response
-              erase_render_results
-              response.headers = ::ActionController::AbstractResponse::DEFAULT_HEADERS.merge("cookie" => [])
-            end
-
-            def public_method_name(service_name, method_name)
-              if web_service_dispatching_mode == :layered && @protocol.is_a?(ActionWebService::Protocol::XmlRpc::XmlRpcProtocol)
-                service_name + '.' + method_name
-              else
-                method_name
-              end
-            end
-
-            def prepare_request(new_request, service_name, method_name)
-              new_request.parameters.update(request.parameters)
-              request.env.each{ |k, v| new_request.env[k] = v unless new_request.env.has_key?(k) }
-              if web_service_dispatching_mode == :layered && @protocol.is_a?(ActionWebService::Protocol::Soap::SoapProtocol)
-                new_request.env['HTTP_SOAPACTION'] = "/\#{controller_name()}/\#{service_name}/\#{method_name}"
-              end
-            end
-
-            def handle_invocation_exception(obj)
-              exception = nil
-              if obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && obj.detail.cause.is_a?(Exception)
-                exception = obj.detail.cause
-              elsif obj.is_a?(XMLRPC::FaultException)
-                exception = obj
-              end
-              return unless exception
-              reset_invocation_response
-              rescue_action(exception)
-              true
-            end
-        end_eval
-      end
-    end
-
-    module Helpers # :nodoc:
-      def method_parameter_input_fields(method, type, field_name_base, idx, was_structured=false)
-        if type.array?
-          return content_tag('em', "Typed array input fields not supported yet (#{type.name})")
-        end
-        if type.structured?
-          return content_tag('em', "Nested structural types not supported yet (#{type.name})") if was_structured
-          parameters = ""
-          type.each_member do |member_name, member_type|
-            label = method_parameter_label(member_name, member_type)
-            nested_content = method_parameter_input_fields(
-              method,
-              member_type,
-              "#{field_name_base}[#{idx}][#{member_name}]",
-              idx,
-              true)
-            if member_type.custom?
-              parameters << content_tag('li', label)
-              parameters << content_tag('ul', nested_content)
-            else
-              parameters << content_tag('li', label + ' ' + nested_content)
-            end
-          end
-          content_tag('ul', parameters)
-        else
-          # If the data source was structured previously we already have the index set          
-          field_name_base = "#{field_name_base}[#{idx}]" unless was_structured
-          
-          case type.type
-          when :int
-            text_field_tag "#{field_name_base}"
-          when :string
-            text_field_tag "#{field_name_base}"
-          when :base64
-            text_area_tag "#{field_name_base}", nil, :size => "40x5"
-          when :bool
-            radio_button_tag("#{field_name_base}", "true") + " True" +
-            radio_button_tag("#{field_name_base}", "false") + "False"
-          when :float
-            text_field_tag "#{field_name_base}"
-          when :time, :datetime
-            time = Time.now
-            i = 0
-            %w|year month day hour minute second|.map do |name|
-              i += 1
-              send("select_#{name}", time, :prefix => "#{field_name_base}[#{i}]", :discard_type => true)
-            end.join
-          when :date
-            date = Date.today
-            i = 0
-            %w|year month day|.map do |name|
-              i += 1
-              send("select_#{name}", date, :prefix => "#{field_name_base}[#{i}]", :discard_type => true)
-            end.join
-          end
-        end
-      end
-
-      def method_parameter_label(name, type)
-        name.to_s.capitalize + ' (' + type.human_name(false) + ')'
-      end
-
-      def service_method_list(service)
-        action = @scaffold_action_name + '_method_params'
-        methods = service.api_methods_full.map do |desc, name|
-          content_tag("li", link_to(desc, :action => action, :service => service.name, :method => name))
-        end
-        content_tag("ul", methods.join("\n"))
-      end
-    end
-
-    module WebServiceModel # :nodoc:
-      class Container # :nodoc:
-        attr :services
-        attr :dispatching_mode
-
-        def initialize(real_container)
-          @real_container = real_container
-          @dispatching_mode = @real_container.class.web_service_dispatching_mode
-          @services = []
-          if @dispatching_mode == :direct
-            @services << Service.new(@real_container.controller_name, @real_container)
-          else
-            @real_container.class.web_services.each do |name, obj|
-              @services << Service.new(name, @real_container.instance_eval{ web_service_object(name) })
-            end
-          end
-        end
-      end
-
-      class Service # :nodoc:
-        attr :name
-        attr :object
-        attr :api
-        attr :api_methods
-        attr :api_methods_full
-
-        def initialize(name, real_service)
-          @name = name.to_s
-          @object = real_service
-          @api = @object.class.web_service_api
-          if @api.nil?
-            raise ScaffoldingError, "No web service API attached to #{object.class}"
-          end
-          @api_methods = {}
-          @api_methods_full = []
-          @api.api_methods.each do |name, method|
-            @api_methods[method.public_name.to_s] = method
-            @api_methods_full << [method.to_s, method.public_name.to_s]
-          end
-        end
-
-        def to_s
-          self.name.camelize
-        end
-      end
-    end
-  end
-end