actionwebservice 0.6.2 → 0.7.0

data/lib/action_web_service/vendor/ws/marshaling/xmlrpc_marshaling.rb

@@ -1,116 +0,0 @@
-module WS
-  module Marshaling
-    class XmlRpcError < WSError
-    end
-
-    class XmlRpcMarshaler < AbstractMarshaler
-      def initialize
-        @caster = BaseTypeCaster.new
-        @spec2binding = {}
-      end
-
-      def marshal(param)
-        transform_outbound(param)
-      end
-
-      def unmarshal(obj)
-        obj.param.value = transform_inbound(obj.param)
-        obj.param
-      end
-
-      def typed_unmarshal(obj, spec)
-        param = obj.param
-        param.info.data = register_type(spec)
-        param.value = transform_inbound(param)
-        param
-      end
-
-      def register_type(spec)
-        if @spec2binding.has_key?(spec)
-          return @spec2binding[spec]
-        end
-
-        klass = BaseTypes.canonical_param_type_class(spec)
-        type_binding = nil
-        if klass.is_a?(Array)
-          type_binding = XmlRpcArrayBinding.new(klass[0])
-        else
-          type_binding = XmlRpcBinding.new(klass)
-        end
-
-        @spec2binding[spec] = type_binding
-      end
-
-      def transform_outbound(param)
-        binding = param.info.data
-        case binding
-        when XmlRpcArrayBinding
-          param.value.map{|x| cast_outbound(x, binding.element_klass)}
-        when XmlRpcBinding
-          cast_outbound(param.value, param.info.type)
-        end
-      end
-
-      def transform_inbound(param)
-        return param.value if param.info.data.nil?
-        binding = param.info.data
-        param.info.type = binding.klass
-        case binding
-        when XmlRpcArrayBinding
-          param.value.map{|x| cast_inbound(x, binding.element_klass)}
-        when XmlRpcBinding
-          cast_inbound(param.value, param.info.type)
-        end
-      end
-
-      def cast_outbound(value, klass)
-        if BaseTypes.base_type?(klass)
-          @caster.cast(value, klass)
-        elsif value.is_a?(Exception)
-          XMLRPC::FaultException.new(2, value.message)
-        elsif Object.const_defined?('ActiveRecord') && value.is_a?(ActiveRecord::Base)
-          value.attributes
-        else
-          struct = {}
-          value.instance_variables.each do |name|
-            key = name.sub(/^@/, '')
-            struct[key] = value.instance_variable_get(name)
-          end
-          struct
-        end
-      end
-
-      def cast_inbound(value, klass)
-        if BaseTypes.base_type?(klass)
-          value = value.to_time if value.is_a?(XMLRPC::DateTime)
-          @caster.cast(value, klass)
-        elsif value.is_a?(XMLRPC::FaultException)
-          value
-        else
-          obj = klass.new
-          value.each do |name, val|
-            obj.send('%s=' % name.to_s, val)
-          end
-          obj
-        end
-      end
-    end
-
-    class XmlRpcBinding
-      attr :klass
-      
-      def initialize(klass)
-        @klass = klass
-      end
-    end
-
-    class XmlRpcArrayBinding < XmlRpcBinding
-      attr :element_klass
-
-      def initialize(element_klass)
-        super(Array)
-        @element_klass = element_klass
-      end
-    end
-  end
-end

data/lib/action_web_service/vendor/ws/types.rb

@@ -1,165 +0,0 @@
-require 'time'
-require 'date'
-
-module WS
-  module BaseTypes
-    class << self
-      def type_name_to_class(name)
-        case canonical_type_name(name)
-        when :int
-          Integer
-        when :string
-          String
-        when :bool
-          TrueClass
-        when :float
-          Float
-        when :time
-          Time
-        when :date
-          Date
-        end
-      end
-
-      def class_to_type_name(klass)
-        if WS.derived_from?(Integer, klass) || WS.derived_from?(Fixnum, klass) || WS.derived_from?(Bignum, klass)
-          :int
-        elsif klass == String
-          :string
-        elsif klass == TrueClass || klass == FalseClass
-          :bool
-        elsif WS.derived_from?(Float, klass) || WS.derived_from?(Precision, klass) || WS.derived_from?(Numeric, klass)
-          :float
-        elsif klass == Time || klass == DateTime
-          :time
-        elsif klass == Date
-          :date
-        else
-          raise(TypeError, "#{klass} is not a valid base type")
-        end
-      end
-
-      def base_type?(klass)
-        !(canonical_type_class(klass) rescue nil).nil?
-      end
-
-      def canonical_type_class(klass)
-        type_name_to_class(class_to_type_name(klass))
-      end
-
-      def canonical_param_type_class(spec)
-        klass = spec.is_a?(Hash) ? spec.values[0] : spec
-        array_element_class = klass.is_a?(Array) ? klass[0] : nil
-        klass = array_element_class ? array_element_class : klass
-        klass = type_name_to_class(klass) if klass.is_a?(Symbol) || klass.is_a?(String)
-        base_class = canonical_type_class(klass) rescue nil
-        klass = base_class unless base_class.nil?
-        array_element_class ? [klass] : klass
-      end
-
-      def canonical_param_type_spec(spec)
-        klass = canonical_param_type_class(spec)
-        spec.is_a?(Hash) ? {spec.keys[0]=>klass} : klass
-      end
-
-      def canonical_type_name(name)
-        name = name.to_sym
-        case name
-          when :int, :integer, :fixnum, :bignum
-            :int
-          when :string, :base64
-            :string
-          when :bool, :boolean
-            :bool
-          when :float, :double
-            :float
-          when :time, :datetime, :timestamp
-            :time
-          when :date
-            :date
-          else
-            raise(TypeError, "#{name} is not a valid base type")
-        end
-      end
-    end
-  end
-
-  class Param
-    attr_accessor :value
-    attr_accessor :info
-
-    def initialize(value, info)
-      @value = value
-      @info = info
-    end
-  end
-
-  class ParamInfo
-    attr_accessor :name
-    attr_accessor :type
-    attr_accessor :data
-
-    def initialize(name, type, data=nil)
-      @name = name
-      @type = type
-      @data = data
-    end
-
-    def self.create(spec, data, index=nil)
-      name = spec.is_a?(Hash) ? spec.keys[0].to_s : (index ? "param#{index}" : nil)
-      type = BaseTypes.canonical_param_type_class(spec)
-      ParamInfo.new(name, type, data)
-    end
-  end
-
-  class BaseTypeCaster
-    def initialize
-      @handlers = {}
-      install_handlers
-    end
-
-    def cast(value, klass)
-      type_class = BaseTypes.canonical_type_class(klass)
-      return value unless type_class
-      @handlers[type_class].call(value, type_class)
-    end
-
-    protected
-      def install_handlers
-        handler = method(:cast_base_type)
-        [:int, :string, :bool, :float, :time, :date].each do |name|
-          type = BaseTypes.type_name_to_class(name)
-          @handlers[type] = handler
-        end
-        @handlers[Fixnum] = handler
-      end
-
-      def cast_base_type(value, type_class)
-        desired_class = BaseTypes.canonical_type_class(type_class)
-        value_class = BaseTypes.canonical_type_class(value.class)
-        return value if desired_class == value_class
-        desired_name = BaseTypes.class_to_type_name(desired_class)
-        case desired_name
-        when :int
-          Integer(value)
-        when :string
-          value.to_s
-        when :bool
-          return false if value.nil?
-          int_value = Integer(value) rescue nil
-          return true if int_value == 1
-          return false if int_value == 0
-          value = value.to_s
-          return true if value == 'true'
-          return false if value == 'false'
-          raise(TypeError, "can't convert #{value} to boolean")
-        when :float
-          Float(value)
-        when :time
-          Time.parse(value.to_s)
-        when :date
-          Date.parse(value.to_s)
-        end
-      end
-  end
-end

data/test/ws/abstract_encoding.rb

@@ -1,68 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module Nested
-  class StructClass
-    attr_accessor :name
-    attr_accessor :version
-
-    def initialize
-      @name = 5
-      @version = "1.0"
-    end
-
-    def ==(other)
-      @name == other.name && @version == other.version
-    end
-  end
-end
-
-module EncodingTest
-  def setup
-    @call_signature = [:int, :bool, :string, :float, [:time], Nested::StructClass]
-    @call_params = [1, true, "string", 5.0, [Time.now], Nested::StructClass.new]
-    @response_signature = [:string]
-    @response_param = "hello world"
-    test_setup
-  end
-
-  def test_abstract
-    obj = WS::Encoding::AbstractEncoding.new
-    assert_raises(NotImplementedError) do
-      obj.encode_rpc_call(nil, nil)
-    end
-    assert_raises(NotImplementedError) do
-      obj.decode_rpc_call(nil)
-    end
-    assert_raises(NotImplementedError) do
-      obj.encode_rpc_response(nil, nil)
-    end
-    assert_raises(NotImplementedError) do
-      obj.decode_rpc_response(nil)
-    end
-  end
-
-  def encode_rpc_call(method_name, signature, params)
-    params = params.dup
-    (0..(signature.length-1)).each do |i|
-      type_binding = @marshaler.register_type(signature[i])
-      info = WS::ParamInfo.create(signature[i], type_binding, i)
-      params[i] = @marshaler.marshal(WS::Param.new(params[i], info))
-    end
-    @encoder.encode_rpc_call(method_name, params)
-  end
-
-  def decode_rpc_call(obj)
-    @encoder.decode_rpc_call(obj)
-  end
-
-  def encode_rpc_response(method_name, signature, param)
-    type_binding = @marshaler.register_type(signature[0])
-    info = WS::ParamInfo.create(signature[0], type_binding, 0)
-    param = @marshaler.marshal(WS::Param.new(param, info))
-    @encoder.encode_rpc_response(method_name, param)
-  end
-
-  def decode_rpc_response(obj)
-    @encoder.decode_rpc_response(obj)
-  end
-end

data/test/ws/abstract_unit.rb

@@ -1,13 +0,0 @@
-require 'pathname'
-$:.unshift(Pathname.new(File.dirname(__FILE__)).realpath.to_s + '/../../lib/action_web_service/vendor')
-require 'test/unit'
-require 'ws'
-begin
-  require 'active_record'
-rescue LoadError
-  begin
-    require 'rubygems'
-    require_gem 'activerecord', '>= 1.6.0'
-  rescue LoadError
-  end
-end

data/test/ws/gencov

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-rcov -x '.*_test\.rb,rubygems,abstract_,/run' ./run

data/test/ws/run

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir[File.join(File.dirname(__FILE__), '*_test.rb')].each do |f|
-  require f
-end

data/test/ws/soap_marshaling_test.rb

@@ -1,91 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-
-module Nested
-  class MyClass
-    attr_accessor :id
-    attr_accessor :name
-
-    def initialize(id, name)
-      @id = id
-      @name = name
-    end
-
-    def ==(other)
-      @id == other.id && @name == other.name
-    end
-  end
-end
-
-class SoapMarshalingTest < Test::Unit::TestCase
-  def setup
-    @marshaler = WS::Marshaling::SoapMarshaler.new
-  end
-
-  def test_abstract
-    marshaler = WS::Marshaling::AbstractMarshaler.new
-    assert_raises(NotImplementedError) do
-      marshaler.marshal(nil)
-    end
-    assert_raises(NotImplementedError) do
-      marshaler.unmarshal(nil)
-    end
-    assert_equal(nil, marshaler.register_type(nil))
-  end
-
-  def test_marshaling
-    info = WS::ParamInfo.create(Nested::MyClass, @marshaler.register_type(Nested::MyClass))
-    param = WS::Param.new(Nested::MyClass.new(2, "name"), info)
-    new_param = @marshaler.unmarshal(@marshaler.marshal(param))
-    assert(param == new_param)
-  end
-  
-  def test_exception_marshaling
-    info = WS::ParamInfo.create(RuntimeError, @marshaler.register_type(RuntimeError))
-    param = WS::Param.new(RuntimeError.new("hello, world"), info)
-    new_param = @marshaler.unmarshal(@marshaler.marshal(param))
-    assert_equal("hello, world", new_param.value.detail.cause.message)
-  end
-
-  def test_registration
-    type_binding1 = @marshaler.register_type(:int)
-    type_binding2 = @marshaler.register_type(:int)
-    assert(type_binding1.equal?(type_binding2))
-  end
-
-  def test_active_record
-    if Object.const_defined?('ActiveRecord')
-      node_class = Class.new(ActiveRecord::Base) do
-        def initialize(*args)
-          super(*args)
-          @new_record = false
-        end
-
-        class << self
-          def name
-            "Node"
-          end
-
-          def columns(*args)
-            [
-              ActiveRecord::ConnectionAdapters::Column.new('id', 0, 'int'),
-              ActiveRecord::ConnectionAdapters::Column.new('name', nil, 'string'),
-              ActiveRecord::ConnectionAdapters::Column.new('email', nil, 'string'),
-            ]
-          end
-
-          def connection
-            self
-          end
-        end
-      end
-      info = WS::ParamInfo.create(node_class, @marshaler.register_type(node_class), 0)
-      ar_obj = node_class.new('name' => 'hello', 'email' => 'test@test.com') 
-      param = WS::Param.new(ar_obj, info)
-      obj = @marshaler.marshal(param)
-      param = @marshaler.unmarshal(obj)
-      new_ar_obj = param.value
-      assert_equal(ar_obj, new_ar_obj)
-      assert(!ar_obj.equal?(new_ar_obj))
-    end
-  end
-end