rapuncel 0.0.5.RC1 → 0.0.5.RC2

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    rapuncel (0.0.5.RC1)
+      activesupport (>= 3.0.0)
+      nokogiri
+
+GEM
+  remote: http://www.rubygems.org/
+  specs:
+    activesupport (3.0.9)
+    diff-lcs (1.1.2)
+    nokogiri (1.5.0)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rapuncel!
+  rspec (>= 2.6.0)

data/README.md

@@ -6,10 +6,8 @@ It's based on Nokogiri for XML parsing and thus provides a major performance imp
 ## I need your help
 I currently have exactly 1 application for Rapuncel, and that's [Kangaroo](https://github.com/cice/kangARoo), i.e.
 the OpenERP XMLRPC service, where it works absolutely fine. To improve Rapuncel i need your experience with
-other services and their quirks.
+other services and their quirks. Just open a feature request or file a bug report.
   
-This Readme is for the upcoming 0.1 release, 0.0.x Readme [here](https://github.com/cice/rapuncel/blob/be19d4427dba14dbc656de1d90501f9d42aa4ef8/README.md) 
-
 ## Installation
 
 ### Rails
@@ -45,29 +43,32 @@ First you have to create a client with the connection details, e.g.
 Available options are:
 
 * **host**
-hostname or ip-address,
-_default_: localhost
+hostname or ip-address,  
+_default_: `localhost`
 * **port**
-port where your XMLRPC service is listening,
-_default_: 8080
+port where your XMLRPC service is listening,  
+_default_: `8080`
 * **path**
-path to the service,
-_default_: /
+path to the service,  
+_default_: `/`
 * **user**
-Username for HTTP Authentication
+Username for HTTP Authentication  
 _default_: _empty_
 * **password**
-Password for HTTP Authentication
+Password for HTTP Authentication  
 _default_: _empty_
 * **headers**
-Hash to set additional HTTP headers for the request, e.g. to send an X-ApiKey header for authentication
-_default_: {}
+Hash to set additional HTTP headers for the request, e.g. to send an X-ApiKey header for authentication  
+_default_: `{}`
 * **ssl**
-Flag wether to use SSL
-_default_: false
+Flag wether to use SSL  
+_default_: `false`
 * **raise_on**
-Lets you define the behavior on errors or faults, if set to _:fault_, _:error_ or _:both_,
+Lets you define the behavior on errors or faults, if set to `:fault`, `:error` or `:both`,  
 an Exception will be raised if something goes wrong
+* **serialization**
+Use your own (extended) (De)Serializers. See Custom Serialization  
+_default_: `Rapuncel::XmlRpc`
 
 ### Get a proxy object and ...
 A proxy object receives ruby method calls, redirects them to your XMLRPC service and returns the response as ruby objects!
@@ -91,8 +92,8 @@ Rapuncel supports natively following object-types (and all their subclasses):
 * Array
 * Hash
 * TrueClass, FalseClass
-* Float
-* BigDecimal (treated like Float)
+* Float / Double
+* BigDecimal (treated like Float, unless you set `double_as_bigdecimal` to true)
 * Time, Time-like objects
 * Base64
 
@@ -112,7 +113,7 @@ Base64 return values from normal String return values.
 ## Supported methods
 You can use most methods via
 
-    proxy.methodname *args
+    proxy.methodname 'a', 1, [:a, :b], :a => :d
 
 However methods starting with \_\_, or ending with a bang \! or a question mark ? are not supported. To call those methods you can always
 use
@@ -127,11 +128,11 @@ note
 
     client.call 'methodname', *args
 
-will return a Rapuncel::Response object, use _call\_to\_ruby_ to get standard ruby objects
+will return a Rapuncel::Response object, use _call\_to\_ruby_ to get a parsed result
 
 ## Deserialization options
 
-At the moment there are 2 options, to be set quite ugly as class attributes on Rapuncel::XmlRpcDeserializer,
+At the moment there are 2 options, to be set quite ugly as class attributes on Rapuncel::XmlRpc::Deserializer,
 which will definitely change.
 
 1. **double\_as\_bigdecimal**
@@ -139,6 +140,17 @@ Deserialize all <double> tags as BigDecimal.
 2. **hash\_keys\_as\_string**
 Don't use Symbols as keys for deserialized <struct>, but Strings.
 
+## Custom Serialization
+
+    module MySpecialSerialization
+      class Serializer < Rapuncel::XmlRpc::Serializer
+      end
+      class Deserializer < Rapuncel::XmlRpc::Deserializer
+      end
+    end
+    
+    client = Rapuncel::Client.new :serialization => MySpecialSerialization
+    # or :serialization => 'MySpecialSerialization'
 
 ## Todo ?
 
@@ -155,11 +167,21 @@ See Usage -> configuration -> raise\_on switch
 ### Malformed XML/XMLRPC
 Rapuncel will most likely fail hard.
 
+## Changelog
+
+* **0.0.5**
+  * Refactored serialization, preparation for pluggable extensions
+  * Deserialization option "double\_as\_bigdecimal"
+  * Deserialization option "hash\_keys\_as\_string"
+  * base64 support
+  * Object#to\_xmlrpc now should expect a XmlRpc::Serializer instance, 
+    not a Builder (you can access the Builder directly via XmlRpc::Serializer#builder)
+
 ## Open Source
 
 ### License
 
-Copyright (c) 2010 ['Marian Theisen', 'Michael Eickenberg']
+Copyright (c) 2011 ['Marian Theisen', 'Michael Eickenberg']
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/rapuncel/base_64_string.rb

@@ -10,22 +10,27 @@ end
 
 module Rapuncel
   class Base64String < String
-    def base64_encoded
-      if RUBY_VERSION =~ /^1\.9/
+
+    if RUBY_VERSION =~ /^1\.9/
+
+      def base64_encoded
         [self].pack 'm'
-      else
+      end
+    
+      def self.decode_base64 string
+        new string.unpack('m')[0]
+      end
+      
+    else
+
+      def base64_encoded
         Base64.encode64 self
       end
-    end
     
-    class << self
-      def decode_base64 string
-        if RUBY_VERSION =~ /^1\.9/
-          new string.unpack('m')[0]
-        else
-          new Base64.decode64 string
-        end
+      def self.decode_base64 string
+        new Base64.decode64 string
       end
+
     end
   end
-end
+end

data/lib/rapuncel/client.rb

@@ -1,6 +1,9 @@
 require 'rapuncel/adapters/net_http_adapter'
 require 'rapuncel/connection'
+require 'rapuncel/xml_rpc/serializer'
+require 'rapuncel/xml_rpc/deserializer'
 require 'active_support/core_ext/hash/except'
+require 'active_support/inflector/methods'
 
 module Rapuncel
   class Client
@@ -17,8 +20,9 @@ module Rapuncel
     end
 
     def initialize configuration = {}
-      @connection = Connection.new configuration.except(:raise_on)
-
+      @connection = Connection.new configuration.except(:raise_on, :serialization)
+      @serialization = configuration[:serialization]
+      
       @raise_on_fault, @raise_on_error = case configuration[:raise_on]
       when :fault
         [true, false]
@@ -31,10 +35,12 @@ module Rapuncel
       end
     end
 
+    # Dispatch a method call and return the response as Rapuncel::Response object.
     def call name, *args
       execute Request.new(name, *args)
     end
 
+    # Dispatch a method call and return the response as parsed ruby.
     def call_to_ruby name, *args
       response = call name, *args
 
@@ -46,9 +52,28 @@ module Rapuncel
 
     protected
     def execute request
-      xml = XmlRpcSerializer.new(request).to_xml
+      xml = serializer[request]
 
-      Response.new send_method_call(xml)
+      Response.new send_method_call(xml), deserializer
+    end
+    
+    def serialization
+      case @serialization
+      when Module
+        @serialization
+      when String, Symbol
+        ActiveSupport::Inflector.constantize(@serialization.to_s)
+      else
+        XmlRpc
+      end
+    end
+    
+    def serializer
+      @serializer ||= serialization.const_get 'Serializer'
+    end
+    
+    def deserializer
+      @deserializer ||= serialization.const_get 'Deserializer'
     end
     
     private

data/lib/rapuncel/connection.rb

@@ -42,6 +42,7 @@ module Rapuncel
     def protocol
       ssl? ? 'https' : 'http'
     end
+    alias_method :scheme, :protocol
     
     def auth?
       !!user && !!password
@@ -57,7 +58,7 @@ module Rapuncel
       self.path     = configuration[:path]    || '/'
       self.headers  = configuration[:headers] || {}
       self.user     = configuration[:user]
-      self.password   = configuration[:password]
+      self.password = configuration[:password]
     end
   end
 end

data/lib/rapuncel/proxy.rb

@@ -3,13 +3,13 @@ require 'rapuncel/request'
 module Rapuncel
   class Proxy
     PROXY_METHODS  = %w(tap inspect clone freeze dup class initialize to_s).freeze
-    LOCKED_METHODS = %w(method_missing).freeze
+    LOCKED_METHODS = %w(method_missing object_id).freeze
     LOCKED_PATTERN = /(\A__|\?\Z|!\Z)/.freeze
 
     class << self
       # Initialize a new Proxy object for a specific Client. Alternatively
       # you can pass a Hash containing configuration for a new Client, which
-      # will be created on-the-fly, but not accessible. The second parameter
+      # will be created on-the-fly, but is directly not accessible. The second parameter
       # specifies a specific interface/namespace for the remote calls,
       # i.e. if your RPC method is
       #
@@ -35,6 +35,13 @@ module Rapuncel
           end
         RUBY
       end
+      
+      # Predefine some proxy methods.
+      def define_proxy_methods *names
+        names.each do |name|
+          define_proxy_method name
+        end
+      end
     end
 
     PROXY_METHODS.each do |name|
@@ -44,7 +51,7 @@ module Rapuncel
     alias_method "__inspect__", "__to_s__"
 
     instance_methods.each do |name|
-      unless LOCKED_METHODS.include?(name) || LOCKED_PATTERN.match(name)
+      unless LOCKED_METHODS.include?(name.to_s) || LOCKED_PATTERN.match(name.to_s)
         define_proxy_method name
       end
     end

data/lib/rapuncel/request.rb

@@ -1,5 +1,3 @@
-require 'rapuncel/xml_rpc_serializer'
-
 module Rapuncel
   class Request
     attr_accessor :method_name, :arguments

data/lib/rapuncel/response.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/module/delegation'
-require 'rapuncel/xml_rpc_deserializer'
 
 module Rapuncel
   class Response
@@ -7,14 +6,14 @@ module Rapuncel
     class Fault < Exception ; end
     class Error < Exception ; end
 
-    attr_accessor :http_response, :status, :status_code, :response
+    attr_accessor :http_response, :status, :status_code, :response, :deserializer
 
     delegate  :body,
               :to => :http_response
 
-    def initialize http_response
-      @http_response = http_response
-
+    def initialize http_response, deserializer
+      @http_response, @deserializer = http_response, deserializer
+      
       evaluate_status
     end
 
@@ -64,7 +63,7 @@ module Rapuncel
 
     protected
     def deserialize_response
-      @response = XmlRpcDeserializer.new(body).to_ruby
+      @response = deserializer[body]
     end
   end
 end

data/lib/rapuncel/xml_rpc/deserializer.rb

@@ -0,0 +1,113 @@
+module Rapuncel
+  module XmlRpc
+    class Deserializer
+      XML_ENCODING = 'UTF-8'
+    
+      def initialize xml
+        @xml_doc = Nokogiri::XML.parse xml
+      end
+    
+      def deserialize xml_node = root_node
+        send "deserialize_#{xml_node.name}", xml_node
+      end
+    
+      def deserialize_base64 xml_node
+        Base64String.decode_base64 xml_node.text.strip
+      end
+    
+      def deserialize_string xml_node
+        xml_node.text.gsub(/(\r\n|\r)/, "\n")
+      end
+    
+      def deserialize_array xml_node
+        values = xml_node.first_element_child.element_children
+
+        values.map do |value|
+          deserialize value.first_element_child
+        end
+      end
+    
+      def deserialize_boolean xml_node
+        xml_node.text == "1"
+      end
+    
+      def deserialize_double xml_node
+        text = xml_node.text.strip
+      
+        if double_as_bigdecimal?
+          BigDecimal.new text
+        else
+          text.to_f
+        end
+      end
+    
+      def deserialize_struct xml_node
+        keys_and_values = xml_node.element_children
+
+        {}.tap do |hash|
+          keys_and_values.each do |key_value|
+            key = key_value.first_element_child.text.strip
+            key = key.to_sym unless hash_keys_as_string?
+          
+            value = deserialize key_value.last_element_child.first_element_child
+
+            hash[key] = value
+          end
+        end      
+      end
+    
+      def deserialize_int xml_node
+        xml_node.text.strip.to_i
+      end
+      alias_method :deserialize_i4, :deserialize_int
+    
+      define_method "deserialize_dateTime.iso8601" do |xml_node|
+        Time.parse xml_node.text.strip
+      end
+    
+      def deserialize_methodResponse xml_node
+        response = xml_node.first_element_child
+      
+        if response.name == 'fault'
+          deserialize_methodResponse_fault response
+        else
+          deserialize_methodResponse_params response
+        end
+      end
+    
+      def deserialize_methodResponse_params xml_node
+        deserialize xml_node.first_element_child.first_element_child.first_element_child
+      end
+    
+      def deserialize_methodResponse_fault xml_node
+        deserialize xml_node.first_element_child.first_element_child
+      end
+    
+      def to_ruby
+        deserialize
+      end
+    
+      protected
+      def root_node
+        @xml_doc.root
+      end
+    
+      def double_as_bigdecimal?
+        !!self.class.double_as_bigdecimal
+      end
+    
+      def hash_keys_as_string?
+        !!self.class.hash_keys_as_string
+      end
+    
+      class << self
+        attr_accessor :double_as_bigdecimal, :hash_keys_as_string
+      
+        def deserialize xml
+          new(xml).to_ruby
+        end
+        alias_method :[], :deserialize
+      end
+    end
+  end
+end