rapuncel 0.0.4 → 0.0.5.RC1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://www.rubygems.org'
+gemspec
+

data/README.md

@@ -3,8 +3,12 @@
 Rapuncel ([wikipedia](http://en.wikipedia.org/wiki/Rapunzel)) is a simple and lightweight, but fast XML-RPC client library for ruby.
 It's based on Nokogiri for XML parsing and thus provides a major performance improvement for large XML responses.
 
-## Alpha release!
-Not everything is working yet, especially: SSL, HTTP Basic Auth, ApiKey-Auth. If in doubt, have a look at the functionality being auto-tested.
+## 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.
+  
+This Readme is for the upcoming 0.1 release, 0.0.x Readme [here](https://github.com/cice/rapuncel/blob/be19d4427dba14dbc656de1d90501f9d42aa4ef8/README.md) 
 
 ## Installation
 
@@ -53,16 +57,14 @@ _default_: /
 Username for HTTP Authentication
 _default_: _empty_
 * **password**
-Username for HTTP Authentication
+Password for HTTP Authentication
 _default_: _empty_
-* **auth\_method**
-HTTP Auth method
-_default_: basic **IF** user or password is set
-* **api\_key**
-If set, sends all request with a X-ApiKey: _api\_key_ header
-* **api\_key\_header**
-Allows you to modify the header key for API-Key auth
-_default_: X-ApiKey
+* **headers**
+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
 * **raise_on**
 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
@@ -92,23 +94,20 @@ Rapuncel supports natively following object-types (and all their subclasses):
 * Float
 * BigDecimal (treated like Float)
 * Time, Time-like objects
+* Base64
 
 * Symbols are converted to Strings
-
+* All Hashs have symbol keys
 * All other objects are transformed into a Hash ('struct' in XMLRPC-speak) containing their instance variables as key-value-pairs.
 
-### Can i customize this behavior for my objects?
-Yes you can, and it's dead simple, just override _to\_xml\_rpc_ with following signature (this is taken from Symbol#to\_xml\_rpc):
-
-    def to_xml_rpc(builder = Rapuncel.get_builder)
-      self.to_s.to_xml_rpc(builder)
-    end
-
-Of course you don't have to delegate to #to\_s, you just can use the Builder object directly
+## Base64
+If you want a string to be encoded as Base64 in your RPC call, just mark it:
 
-    def to_xml_rpc(builder = Rapuncel.get_builder)
-      builder.string(self.to_s)
-    end
+    proxy.some_method "my base64 encoded string".as_base64
+    
+Return values that arrive Base64 encoded, are instances of Rapuncel::Base64String,
+which is a subclass of String, and therefore can be used as such, but allows you to differentiate
+Base64 return values from normal String return values.
 
 ## Supported methods
 You can use most methods via
@@ -130,13 +129,25 @@ note
 
 will return a Rapuncel::Response object, use _call\_to\_ruby_ to get standard ruby objects
 
+## Deserialization options
+
+At the moment there are 2 options, to be set quite ugly as class attributes on Rapuncel::XmlRpcDeserializer,
+which will definitely change.
+
+1. **double\_as\_bigdecimal**
+Deserialize all <double> tags as BigDecimal.
+2. **hash\_keys\_as\_string**
+Don't use Symbols as keys for deserialized <struct>, but Strings.
+
+
 ## Todo ?
 
 * RDoc
 * Extensive functional tests
+* HTTP-Proxy support
 * Async requests
-* Base64 support (or rather a consistent concept for Base64)
 * XMLRPC Extensions (pluggable support)
+* How do i test SSL?
 
 ## What happens if something goes wrong?
 ### HTTP Errors / XMLRPC Faults

data/Rakefile

@@ -2,18 +2,7 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Run Rapuncel Testsuite.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
 
-#TODO: sdoc
 desc 'Generate Rapuncel rdoc.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
@@ -22,3 +11,14 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+begin
+  require 'rspec/core/rake_task'
+  desc 'Run RSpec suite.'
+  RSpec::Core::RakeTask.new('spec')
+rescue LoadError
+  puts "RSpec is not available. In order to run specs, you must: gem install rspec"
+end
+
+desc 'Default: run unit tests.'
+task :default => :spec

data/lib/rapuncel.rb

@@ -1,25 +1,17 @@
-
-
 require 'active_support/core_ext/hash/keys'
-
 require 'nokogiri'
 
-require 'rapuncel/base'
+module Rapuncel
+  BUILDER_OPTIONS = {:encoding => 'UTF-8'}
+
+  def self.get_builder options = {}
+    Nokogiri::XML::Builder.new options
+  end
+end
+
 require 'rapuncel/request'
 require 'rapuncel/response'
 require 'rapuncel/client'
 require 'rapuncel/proxy'
 
-# Ruby Core extensions:
-require 'rapuncel/core_ext/object'
-require 'rapuncel/core_ext/string'
-require 'rapuncel/core_ext/symbol'
-require 'rapuncel/core_ext/integer'
-require 'rapuncel/core_ext/big_decimal'
-require 'rapuncel/core_ext/float'
-require 'rapuncel/core_ext/hash'
-require 'rapuncel/core_ext/array'
-require 'rapuncel/core_ext/boolean'
-require 'rapuncel/core_ext/nil'
-
-require 'rapuncel/core_ext/time'
+require 'rapuncel/base_64_string'

data/lib/rapuncel/adapters/net_http_adapter.rb

@@ -1,11 +1,10 @@
 require 'net/http'
-require 'active_support/memoizable'
+require 'net/https'
 
 module Rapuncel
   module Adapters
     module NetHttpAdapter
-      extend ActiveSupport::Memoizable
-
+      # Small response wrapper
       class HttpResponse
         def initialize response
           @response = response
@@ -24,10 +23,13 @@ module Rapuncel
         end
       end
 
+      # Dispatch a XMLRPC via HTTP and return a response object.
       def send_method_call str
-        req = Net::HTTP.new connection.host, connection.port
+        request = Net::HTTP.new connection.host, connection.port
+        request.use_ssl = connection.ssl?
+        request.basic_auth connection.user, connection.password if connection.auth?
 
-        HttpResponse.new req.post(connection.path, str, connection.headers.stringify_keys)
+        HttpResponse.new request.post(connection.path, str, connection.headers)
       end
     end
   end

data/lib/rapuncel/base_64_string.rb

@@ -0,0 +1,31 @@
+if RUBY_VERSION =~ /^1\.8/
+  require 'base64'
+end
+
+class String
+  def as_base64
+    Rapuncel::Base64String.new self
+  end
+end
+
+module Rapuncel
+  class Base64String < String
+    def base64_encoded
+      if RUBY_VERSION =~ /^1\.9/
+        [self].pack 'm'
+      else
+        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
+      end
+    end
+  end
+end

data/lib/rapuncel/client.rb

@@ -17,7 +17,7 @@ module Rapuncel
     end
 
     def initialize configuration = {}
-      @connection = Connection.build configuration.except(:raise_on)
+      @connection = Connection.new configuration.except(:raise_on)
 
       @raise_on_fault, @raise_on_error = case configuration[:raise_on]
       when :fault
@@ -46,7 +46,7 @@ module Rapuncel
 
     protected
     def execute request
-      xml = request.to_xml_rpc
+      xml = XmlRpcSerializer.new(request).to_xml
 
       Response.new send_method_call(xml)
     end

data/lib/rapuncel/connection.rb

@@ -1,40 +1,24 @@
 module Rapuncel
   class Connection
-    def self.build configuration = {}
-      configuration = configuration.symbolize_keys
-
-      case
-      when configuration[:user], configuration[:auth_method], configuration[:password]
-        AuthConnection.new configuration
-      when configuration[:api_key_header], configuration[:api_key]
-        ApiKeyAuthConnection.new configuration
-      else
-        new configuration
-      end
-    end
-
-    attr_accessor :host, :port, :path, :ssl, :headers
+    attr_accessor :host, :port, :path, :ssl, :user, :password
     alias_method :ssl?, :ssl
 
     def initialize configuration = {}
-
-      self.host     = configuration[:host]    || 'localhost'
-      self.port     = configuration[:port]    || '8080'
-      self.path     = configuration[:path]    || '/'
-      self.headers  = configuration[:headers] || {}
-
-      if ssl = configuration[:ssl]
-        @ssl = true
-        #TODO
-      end
+      load_configuration configuration
     end
 
     def url
-      "http://#{host}:#{port}#{path}"
+      "#{protocol}://#{host}:#{port}#{path}"
     end
     
     def host= value
-      @host = value.to_s.sub /^http\:\/\//, ''
+      @host = value.to_s.sub /^http(s)?\:\/\//, ''
+      
+      if $1 == 's'
+        @ssl = true
+      end
+      
+      @host
     end
     
     def path= value
@@ -44,43 +28,36 @@ module Rapuncel
       
       @path = value
     end
+    
+    def headers= headers
+      @headers = {
+        'User-Agent' => 'Rapuncel, Ruby XMLRPC Client'
+      }.merge headers.stringify_keys
+    end
 
     def headers
-      @headers.merge  :Accept => 'text/xml', :'content-type' => 'text/xml'
+      @headers.merge 'Accept' => 'text/xml', 'content-type' => 'text/xml'
     end
-
-    def http_auth? ; false ; end
-    def api_auth? ; false ; end
-  end
-
-  class AuthConnection < Connection
-    attr_accessor :auth_method, :user, :password
-
-    def initialize configuration = {}
-      super
-
-      @auth_method  = auth_method               || 'basic'
-      @user         = user                      || ''
-      @password     = configuration[:password]  || ''
+    
+    def protocol
+      ssl? ? 'https' : 'http'
     end
-
-    def http_auth? ; true ; end
-  end
-
-  class ApiKeyAuthConnection < Connection
-    attr_accessor :api_key_header, :api_key
-
-    def initialize configuration = {}
-      super
-
-      @api_key_header = configuration[:api_key_header] || "X-ApiKey"
-      @api_key        = configuration[:api_key]        || '' #DISCUSS: raise error ?
+    
+    def auth?
+      !!user && !!password
     end
-
-    def headers
-      super.merge api_key_header => api_key
+    
+    protected
+    def load_configuration configuration
+      configuration = configuration.symbolize_keys
+      
+      self.ssl      = !!configuration[:ssl]
+      self.host     = configuration[:host]    || 'localhost'
+      self.port     = configuration[:port]    || '8080'
+      self.path     = configuration[:path]    || '/'
+      self.headers  = configuration[:headers] || {}
+      self.user     = configuration[:user]
+      self.password   = configuration[:password]
     end
-
-    def api_auth? ; true ; end
   end
 end

data/lib/rapuncel/request.rb

@@ -1,49 +1,12 @@
-
-
+require 'rapuncel/xml_rpc_serializer'
 
 module Rapuncel
   class Request
     attr_accessor :method_name, :arguments
 
-
     # Create a new XML-RPC request
     def initialize method_name, *args
       @method_name, @arguments = method_name, args
     end
-
-    def to_xml_rpc builder = Rapuncel.get_builder
-      method_call! builder
-
-      builder.to_xml :encoding => 'UTF-8'
-    end
-
-    protected
-    def method_call! builder
-
-      builder.methodCall do |builder|
-        method_name! builder
-        params! builder
-      end
-    end
-
-    def method_name! builder
-      builder.methodName method_name
-    end
-
-    def params! builder
-      builder.params do |builder|
-        arguments.each do |value|
-          param! builder, value
-        end
-      end
-    end
-
-    def param! builder, value
-      builder.param do |builder|
-        builder.value do |builder|
-          value.to_xml_rpc builder
-        end
-      end
-    end
   end
 end

data/lib/rapuncel/response.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/module/delegation'
+require 'rapuncel/xml_rpc_deserializer'
 
 module Rapuncel
   class Response
@@ -6,7 +7,7 @@ module Rapuncel
     class Fault < Exception ; end
     class Error < Exception ; end
 
-    attr_accessor :http_response, :status, :status_code
+    attr_accessor :http_response, :status, :status_code, :response
 
     delegate  :body,
               :to => :http_response
@@ -20,10 +21,16 @@ module Rapuncel
     def evaluate_status
       @status_code = http_response.code.to_i
 
-      @status = case
-      when !http_response.success?                  then 'error'
-      when parsed_body && method_response_success?  then 'success'
-      else 'fault'
+      @status = unless http_response.success?
+        'error'
+      else
+        deserialize_response
+        
+        if Hash === response && response[:faultCode]
+          'fault'
+        else
+          'success'
+        end
       end
     end
 
@@ -40,31 +47,15 @@ module Rapuncel
     end
 
     def fault
-      if fault?
-        @fault ||= begin
-          fault_node = parsed_body.xpath('/methodResponse/fault/value/struct').first
-          
-          Hash.from_xml_rpc(fault_node).tap do |h|
-            h[:faultString] = h[:faultString].strip
-          end
-        end
-      end
+      fault? && @response
     end
 
     def error
-      if error?
-        @error ||= { :http_code => @status_code, :http_body => body }
-      end
+      error? && { :http_code => @status_code, :http_body => body }
     end
 
     def result
-      if success?
-        @result ||= begin
-          return_values = parsed_body.xpath('/methodResponse/params/param/value/*')
-
-          Object.from_xml_rpc return_values.first
-        end
-      end
+      success? && @response
     end
 
     def to_ruby
@@ -72,12 +63,8 @@ module Rapuncel
     end
 
     protected
-    def parsed_body
-      @xml_doc ||= Nokogiri::XML.parse body
-    end
-
-    def method_response_success?
-      parsed_body.xpath('/methodResponse/fault').empty?
+    def deserialize_response
+      @response = XmlRpcDeserializer.new(body).to_ruby
     end
   end
 end