rapuncel 0.0.1.alpha

data/lib/rapuncel/core_ext/big_decimal.rb

@@ -0,0 +1,7 @@
+class BigDecimal
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.double self.to_s
+
+    b.to_xml
+  end
+end

data/lib/rapuncel/core_ext/boolean.rb

@@ -0,0 +1,29 @@
+class TrueClass
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.boolean "1"
+
+    b.to_xml
+  end
+end
+
+class FalseClass
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.boolean "0"
+
+    b.to_xml
+  end
+end
+
+# this is to catch the from_xml_rpc call from Object
+class Rapuncel::Boolean
+  def self.from_xml_rpc xml_node
+
+    # DISCUSS: need convention here:
+    case xml_node.text.downcase
+    when '1'
+      true
+    else
+      false
+    end
+  end
+end

data/lib/rapuncel/core_ext/float.rb

@@ -0,0 +1,11 @@
+class Float
+  def self.from_xml_rpc xml_node
+    xml_node.text.strip.to_f #calling to_float on the text between the (hopefully correct) tags
+  end
+
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.double to_s
+
+    b.to_xml
+  end
+end

data/lib/rapuncel/core_ext/hash.rb

@@ -0,0 +1,32 @@
+class Hash
+  # Hash will be translated into an XML-RPC "struct" object
+
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.struct do |b|
+      self.each_pair do |key, value|
+        b.member do |b|
+          b.name key.to_s
+
+          b.value do |b|
+            value.to_xml_rpc b
+          end
+        end
+      end
+    end
+
+    b.to_xml
+  end
+
+  def self.from_xml_rpc xml_node
+    keys_and_values = xml_node.element_children
+
+    new.tap do |hash|
+      keys_and_values.each do |kv|
+        key = kv.first_element_child.text.strip.to_sym
+        value = Object.from_xml_rpc kv.last_element_child.first_element_child
+
+        hash[key] = value
+      end
+    end
+  end
+end

data/lib/rapuncel/core_ext/integer.rb

@@ -0,0 +1,11 @@
+class Integer
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.int self.to_s
+
+    b.to_xml
+  end
+
+  def self.from_xml_rpc xml_node
+    xml_node.text.strip.to_i #calling to_i on the text between the i4 or int tags
+  end
+end

data/lib/rapuncel/core_ext/nil.rb

@@ -0,0 +1,7 @@
+class NilClass
+  def to_xml_rpc b = Rapuncel.get_builder
+    false.to_xml_rpc b
+
+    b.to_xml
+  end
+end

data/lib/rapuncel/core_ext/object.rb

@@ -0,0 +1,49 @@
+class Object
+  def to_xml_rpc b = Rapuncel.get_builder
+    if respond_to?(:acts_like?) && acts_like?(:time)
+      to_time.to_xml_rpc b
+    else
+      _collect_ivars_in_hash.to_xml_rpc b
+    end
+
+    b.to_xml
+  end
+
+  def self.from_xml_rpc xml_node
+    if xml_node.is_a? String
+      xml_node = Nokogiri::XML.parse(xml_node).root
+    end
+
+    return nil if xml_node.nil?
+
+    case xml_node.name
+    when 'i4', 'int'
+      Integer.from_xml_rpc xml_node
+    when 'array'
+      Array.from_xml_rpc xml_node
+    when 'struct'
+      Hash.from_xml_rpc xml_node
+    when 'double'
+      Float.from_xml_rpc xml_node
+    when 'boolean'
+      Rapuncel::Boolean.from_xml_rpc xml_node
+    when 'string'
+      String.from_xml_rpc xml_node
+    when 'dateTime.iso8601'
+      Time.from_xml_rpc xml_node
+    when 'base64'
+      raise 'Now its time to implement Base64'
+    else
+      raise "What is this? I didn't know #{xml_node.name} was part of the XMLRPC specification? Anyway, the value was: #{xml_node.text.strip}"
+    end
+  end
+
+  private
+  def _collect_ivars_in_hash
+    {}.tap do |hsh|
+      instance_variables.each do |ivar|
+        hsh[ivar[1..-1]] = instance_variable_get ivar
+      end
+    end
+  end
+end

data/lib/rapuncel/core_ext/string.rb

@@ -0,0 +1,12 @@
+class String
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.string self
+
+    b.to_xml
+  end
+
+  def self.from_xml_rpc xml_node
+    xml_node.text.gsub(/(\r\n|\r)/, "\n") #just give back the string between the 'string' tags
+    # DISCUSS: to strip or not to strip
+  end
+end

data/lib/rapuncel/core_ext/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  def to_xml_rpc b = Rapuncel.get_builder
+    b.string to_s
+
+    b.to_xml
+  end
+end

data/lib/rapuncel/core_ext/time.rb

@@ -0,0 +1,14 @@
+require 'time'
+
+class Time
+
+  def to_xml_rpc b=Rapuncel.get_builder
+    b.send "dateTime.iso8601", self.iso8601
+
+    b.to_xml
+  end
+
+  def self.from_xml_rpc xml_node
+    Time.parse xml_node.text.strip #make a Time object of this string which is hopefully in the right format
+  end
+end

data/lib/rapuncel/proxy.rb

@@ -0,0 +1,82 @@
+require 'rapuncel/request'
+
+module Rapuncel
+  class Proxy
+    PROXY_METHODS  = %w(tap inspect clone freeze dup class initialize).freeze
+    LOCKED_METHODS = %w(method_missing).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
+      # 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
+    end
+
+    PROXY_METHODS.each do |name|
+      alias_method "__#{name}__", name
+    end
+
+    instance_methods.each do |name|
+      unless LOCKED_METHODS.include?(name) || LOCKED_PATTERN.match(name)
+        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,49 @@
+
+
+
+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

@@ -0,0 +1,92 @@
+require 'active_support/core_ext/module/delegation'
+
+module Rapuncel
+  class Response
+    class Exception < ::Exception
+      attr_accessor :code, :string
+
+      def initialize code, string
+        @code, @string = code, string
+      end
+
+      def exception
+        self
+      end
+    end
+    class Fault < Exception ; end
+    class Error < Exception ; end
+
+    attr_accessor :http_response, :status, :status_code
+
+    delegate  :body,
+              :to => :http_response
+
+    def initialize http_response
+      @http_response = http_response
+
+      evaluate_status
+    end
+
+    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'
+      end
+    end
+
+    def success?
+      status == 'success'
+    end
+
+    def fault?
+      status == 'fault'
+    end
+
+    def error?
+      status == 'error'
+    end
+
+    def fault
+      if fault?
+        @fault ||= begin
+          fault_node = parsed_body.xpath('/methodResponse/fault/value/struct').first
+          fault_hash = Hash.from_xml_rpc(fault_node)
+
+          Fault.new fault_hash[:faultCode], fault_hash[:faultString]
+        end
+      end
+    end
+
+    def error
+      if error?
+        @error ||= Error.new @status_code, body
+      end
+    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
+    end
+
+    def to_ruby
+      result || fault || error
+    end
+
+    protected
+    def parsed_body
+      @xml_doc ||= Nokogiri::XML.parse body
+    end
+
+    def method_response_success?
+      parsed_body.xpath('/methodResponse/fault').empty?
+    end
+  end
+end

data/rapuncel.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = "rapuncel"
+  s.version     = "0.0.1.alpha"
+  s.date        = "2010-12-02"
+  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_development_dependency 'mocha'
+end