socialcast-rapuncel 0.0.7.RC1

data/lib/rapuncel/proxy.rb

@@ -0,0 +1,91 @@
+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 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 is directly not accessible. The second parameter
+      # specifies a specific interface/namespace for the remote calls,
+      # i.e. if your RPC method is
+      #
+      #     int numbers.add(int a, int b)
+      #
+      # You can create a specific proxy for +numbers+, and use +add+ directly
+      #
+      #     proxy = Proxy.new client, 'numbers'
+      #     proxy.add(40, 2) -> 42
+      #
+      def new client_or_configuration, interface = nil
+        client_or_configuration = Client.new client_or_configuration if client_or_configuration.is_a?(Hash)
+
+        allocate.__tap__ do |new_proxy|
+          new_proxy.__initialize__ client_or_configuration, interface
+        end
+      end
+
+      def define_proxy_method name
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name} *args, &block
+            call! '#{name}', *args, &block
+          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|
+      alias_method "__#{name}__", name
+    end
+    
+    alias_method "__inspect__", "__to_s__"
+
+    instance_methods.each do |name|
+      unless LOCKED_METHODS.include?(name.to_s) || LOCKED_PATTERN.match(name.to_s)
+        define_proxy_method name
+      end
+    end
+
+    def call! name, *args
+      name = "#{@interface}.#{name}" if @interface
+
+      @client.call_to_ruby(name, *args).tap do |response|
+
+        if block_given?
+          yield response
+        end
+      end
+    end
+
+    def __initialize__ client, interface #:nodoc:
+      @interface = interface
+      @client = client
+    end
+
+    def respond_to? name #:nodoc:
+      LOCKED_PATTERN.match(name.to_s) ? super : true
+    end
+
+    protected
+    def method_missing name, *args, &block #:nodoc:
+      name = name.to_s
+
+      if LOCKED_PATTERN.match name
+        super name.to_sym, *args, &block
+      else
+        self.__class__.define_proxy_method name
+        call! name, *args, &block
+      end
+    end
+  end
+end

data/lib/rapuncel/request.rb

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

data/lib/rapuncel/response.rb

@@ -0,0 +1,69 @@
+require 'active_support/core_ext/module/delegation'
+
+module Rapuncel
+  class Response
+    class Exception < ::Exception ; end
+    class Fault < Exception ; end
+    class Error < Exception ; end
+
+    attr_accessor :http_response, :status, :status_code, :response, :deserializer
+
+    delegate  :body,
+              :to => :http_response
+
+    def initialize http_response, deserializer
+      @http_response, @deserializer = http_response, deserializer
+      
+      evaluate_status
+    end
+
+    def evaluate_status
+      @status_code = http_response.code.to_i
+
+      @status = unless http_response.success?
+        'error'
+      else
+        deserialize_response
+        
+        if Hash === response && response[:faultCode]
+          'fault'
+        else
+          'success'
+        end
+      end
+    end
+
+    def success?
+      status == 'success'
+    end
+
+    def fault?
+      status == 'fault'
+    end
+
+    def error?
+      status == 'error'
+    end
+
+    def fault
+      fault? && @response
+    end
+
+    def error
+      error? && { :http_code => @status_code, :http_body => body }
+    end
+
+    def result
+      success? && @response
+    end
+
+    def to_ruby
+      result || fault || error
+    end
+
+    protected
+    def deserialize_response
+      @response = deserializer[body]
+    end
+  end
+end

data/lib/rapuncel/xml_rpc/deserializer.rb

@@ -0,0 +1,116 @@
+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
+        return unless xml_node
+        if self.respond_to?("deserialize_#{xml_node.name}")
+          send "deserialize_#{xml_node.name}", xml_node
+        end
+      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

data/lib/rapuncel/xml_rpc/serializer.rb

@@ -0,0 +1,153 @@
+require 'bigdecimal'
+require 'time'
+
+module Rapuncel
+  module XmlRpc
+    class Serializer
+      XML_ENCODING = 'UTF-8'
+    
+      attr_reader :builder
+    
+      def initialize object
+        @builder = Nokogiri::XML::Builder.new :encoding => XML_ENCODING
+      
+        serialize object
+      end
+    
+      def serialize object
+        case object
+        when Base64String
+          serialize_base64 object
+        when Array
+          serialize_array object
+        when String, Symbol
+          serialize_string object.to_s
+        when TrueClass
+          serialize_true
+        when FalseClass
+          serialize_false
+        when Float
+          serialize_float object
+        when BigDecimal
+          serialize_big_decimal object
+        when Hash
+          serialize_hash object
+        when Integer
+          serialize_integer object
+        when NilClass
+          serialize_nil
+        when Time
+          serialize_time object
+        when Request
+          serialize_request object
+        else
+          if object.respond_to?(:acts_like?) && object.acts_like?(:time)
+            serialize_time object
+          elsif object.respond_to?(:to_xmlrpc)
+            object.to_xmlrpc self
+          else
+            serialize_hash instance_variable_hash(object)
+          end
+        end
+      
+        self
+      end
+    
+      def serialize_base64 string
+        builder.base64 string.base64_encoded
+      end
+    
+      def serialize_array array
+        builder.array do |builder|
+          builder.data do |builder|
+            array.each do |element|
+              builder.value do |_|
+                serialize element
+              end
+            end
+          end
+        end
+      end
+    
+      def serialize_string string
+        builder.string string
+      end
+    
+      def serialize_true
+        builder.boolean "1"
+      end
+    
+      def serialize_false
+        builder.boolean "0"
+      end
+      alias_method :serialize_nil, :serialize_false
+    
+      def serialize_float float
+        builder.double float.to_s
+      end
+    
+      def serialize_big_decimal big_decimal
+        builder.double big_decimal.to_s("F")
+      end
+    
+      def serialize_hash hash
+        builder.struct do |builder|
+          hash.each_pair do |key, value|
+            builder.member do |builder|
+              # Get a better string representation of BigDecimals
+              key = key.to_s("F") if BigDecimal === key
+              builder.name key.to_s
+
+              builder.value do |builder|
+                serialize value
+              end
+            end
+          end
+        end
+      end
+    
+      def serialize_integer int
+        builder.int int.to_s
+      end
+    
+      def serialize_time time
+        builder.send "dateTime.iso8601", time.iso8601
+      end
+    
+      def serialize_request request
+        builder.methodCall do |builder|
+          builder.methodName request.method_name
+          builder.params do |builder|
+            request.arguments.each do |argument|
+              builder.param do |builder|
+                builder.value do |builder|
+                  serialize argument
+                end
+              end
+            end
+          end
+        end
+      end
+    
+      def to_xml
+        @builder.to_xml
+      end
+    
+      protected
+      def instance_variable_hash object
+        {}.tap do |hash|
+          object.instance_variables.each do |ivar|
+            hash[ivar[1..-1]] = object.instance_variable_get ivar
+          end
+        end
+      end
+    
+      class << self
+        def serialize object
+          new(object).to_xml
+        end
+        alias_method :[], :serialize
+      end
+    end
+  end
+end

data/lib/rapuncel.rb

@@ -0,0 +1,17 @@
+require 'active_support/core_ext/hash/keys'
+require 'nokogiri'
+
+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'
+
+require 'rapuncel/base_64_string'

data/rapuncel.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name        = "socialcast-rapuncel"
+  s.version     = "0.0.7.RC1"
+  s.date        = Time.now.strftime("%Y-%m-%d")
+  s.authors     = ["Michael Eickenberg", "Marian Theisen"]
+  s.email       = 'marian@cice-online.net'
+  s.summary     = "Simple XML-RPC Client"
+  s.homepage    = "http://github.com/cice/rapuncel"
+  s.description = "Rapuncel is a simple XML-RPC Client based on Nokogiri, thus provides a fast and easy way to interact with XML-RPC services."
+
+  s.files        =  Dir["**/*"] -
+                    Dir["coverage/**/*"] -
+                    Dir["rdoc/**/*"] -
+                    Dir["doc/**/*"] -
+                    Dir["sdoc/**/*"] -
+                    Dir["rcov/**/*"]
+
+  s.add_dependency 'nokogiri'
+  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'cookiejar', '~> 0.3.0'
+
+  s.add_development_dependency 'rspec', '>= 2.6.0'
+  s.add_development_dependency 'rake'
+end

data/spec/functional/client_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Rapuncel::Client do
+  it 'simple XMLRPC' do
+    client = Rapuncel::Client.new :port => 9485
+    proxy = client.proxy_for 'num'
+    
+    proxy.add(40, 2).should == 42
+  end
+  
+  it 'fault XMLRPC without raising' do
+    client = Rapuncel::Client.new :port => 9485
+    proxy = client.proxy_for 'num'
+    
+    lambda do
+      proxy.add 20, 20, 2
+    end.should_not raise_error Rapuncel::Response::Exception
+    
+    
+    proxy.add(20, 20, 2).should be_a Hash
+  end
+  
+  it 'fault XMLRPC with raising' do
+    client = Rapuncel::Client.new :port => 9485, :raise_on => :both
+    proxy = client.proxy_for 'num'
+    
+    lambda do
+      proxy.add 20, 20, 2
+    end.should raise_error Rapuncel::Response::Fault
+  end
+  
+  it 'error in connection without raising' do
+    client = Rapuncel::Client.new :host => 'www.google.de', :port => 80, :path => '/somefoobarurl'
+    proxy = client.proxy
+    
+    lambda do
+      proxy.foo :bar, :baz
+    end.should_not raise_error Rapuncel::Response::Error
+    
+    err = proxy.foo(:bar, :baz)
+    err.should be_a Hash
+    err[:http_code].should == 404
+  end
+  
+  it 'error in connection with raising' do
+    client = Rapuncel::Client.new :host => 'www.google.de', :port => 80, :path => '/somefoobarurl', :raise_on => :both
+    proxy = client.proxy
+    
+    lambda do
+      proxy.foo :bar
+    end.should raise_error Rapuncel::Response::Error
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'nokogiri'
+require 'rapuncel'
+require 'test_server'
+
+module SpecHelper
+  def anythings count
+    [anything] * count
+  end
+end
+
+RSpec.configure do |config|
+  config.before :all do
+    @server = TestServer.new
+    @server.start
+  end
+  
+  config.after :all do
+    @server.stop
+  end
+end
+
+String.class_eval do
+  def has_xpath? xpath, options = {}
+    eq = options[:content]
+    count = options[:count] || 1
+    doc = Nokogiri::XML.parse self, nil, nil, Nokogiri::XML::ParseOptions::STRICT
+    res = doc.xpath xpath
+
+    unless eq
+      res.size.should == count
+    else
+      eq = eq.strip
+
+      if count
+        res.to_a.select{ |node|
+          node.text.strip == eq
+        }.size.should == count
+      else
+        res.to_a.all?{ |node|
+          node.text.strip == eq
+        }.should == true
+      end
+    end
+  end
+end

data/spec/test_server.rb

@@ -0,0 +1,30 @@
+require "xmlrpc/server"
+require 'rubygems'
+
+class Num
+  INTERFACE = XMLRPC::interface("num") {
+    meth 'int add(int, int)', 'Add two numbers', 'add'
+    meth 'int div(int, int)', 'Divide two numbers'
+  }
+
+  def add(a, b) a + b end
+  def div(a, b) a / b end
+end
+
+class TestServer
+  attr_accessor :server
+  
+  def initialize
+    @server = XMLRPC::Server.new(9485, '127.0.0.1', 4, File.open('/dev/null','w')).tap do |s|
+      s.add_handler(Num::INTERFACE, Num.new)
+    end
+  end
+
+  def start
+    Thread.new { @server.serve }
+  end
+
+  def stop
+    @server.shutdown
+  end
+end

data/spec/unit/array_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Array do
+  describe "Serialization" do
+    before do
+      @array = (1..10).to_a.map &:to_s
+      
+      @xml = Rapuncel::XmlRpc::Serializer[@array]
+    end
+    
+    it "yields a value tag for each array element" do
+      @xml.should have_xpath('/array/data/value', :count => 10)
+    end
+    
+    it "preserves the element order" do
+      @xml.should have_xpath('/array/data/value[4]/string', :content => "4")
+      @xml.should have_xpath('/array/data/value[5]/string', :content => "5")
+    end
+  end
+  
+  describe "Deserialization" do
+    before do
+      @xml = <<-XML
+        <array><data>
+          <value><string>1</string></value>
+          <value><string>2</string></value>
+          <value><string>3</string></value>
+        </data></array>
+      XML
+      @array = Rapuncel::XmlRpc::Deserializer[@xml]
+    end
+    
+    it 'has correct number of elements' do
+      @array.count.should == 3
+    end
+    
+    it 'preserves element order' do
+      @array.should == ["1", "2", "3"]
+    end
+  end
+end

data/spec/unit/base64_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Base64" do
+  def to_base64 string
+    if RUBY_VERSION =~ /^1\.9/
+      [string].pack('m')
+    else
+      require 'base64'
+      Base64.encode64(string)
+    end
+  end
+  
+  it 'should encode Base64 marked strings as Base64' do
+    string = "abcdefghABCDEFGH1234567890".as_base64
+    string.should be_a Rapuncel::Base64String
+    
+    xml = Rapuncel::XmlRpc::Serializer[string]
+    xml.should have_xpath('/base64', :content => to_base64(string))
+  end
+  
+  it 'should decode base64 as Base64Strings' do
+    xml = <<-XML
+      <base64>YWJjZGVmZ2hBQkNERUZHSDEyMzQ1Njc4OTA=</base64>
+    XML
+    
+    string = Rapuncel::XmlRpc::Deserializer[xml]
+    string.should be_a Rapuncel::Base64String
+    string.should == "abcdefghABCDEFGH1234567890"
+  end
+end