Fresh start

1 files changed, 286 insertions, 0 deletions

diff --git a/jni/ruby/lib/xmlrpc/create.rb b/jni/ruby/lib/xmlrpc/create.rb
new file mode 100644
index 0000000..695f8fe
--- /dev/null
+++ b/jni/ruby/lib/xmlrpc/create.rb
@@ -0,0 +1,286 @@
+#
+# Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
+#
+# $Id: create.rb 36958 2012-09-13 02:22:10Z zzak $
+#
+
+require "date"
+require "xmlrpc/base64"
+
+module XMLRPC # :nodoc:
+
+  module XMLWriter
+
+    class Abstract
+      def ele(name, *children)
+        element(name, nil, *children)
+      end
+
+      def tag(name, txt)
+        element(name, nil, text(txt))
+      end
+    end
+
+
+    class Simple < Abstract
+
+      def document_to_str(doc)
+        doc
+      end
+
+      def document(*params)
+        params.join("")
+      end
+
+      def pi(name, *params)
+        "<?#{name} " + params.join(" ") + " ?>"
+      end
+
+      def element(name, attrs, *children)
+        raise "attributes not yet implemented" unless attrs.nil?
+        if children.empty?
+          "<#{name}/>"
+        else
+          "<#{name}>" + children.join("") + "</#{name}>"
+        end
+      end
+
+      def text(txt)
+        cleaned = txt.dup
+        cleaned.gsub!(/&/, '&amp;')
+        cleaned.gsub!(/</, '&lt;')
+        cleaned.gsub!(/>/, '&gt;')
+        cleaned
+      end
+
+    end # class Simple
+
+
+    class XMLParser < Abstract
+
+      def initialize
+        require "xmltreebuilder"
+      end
+
+      def document_to_str(doc)
+        doc.to_s
+      end
+
+      def document(*params)
+        XML::SimpleTree::Document.new(*params)
+      end
+
+      def pi(name, *params)
+        XML::SimpleTree::ProcessingInstruction.new(name, *params)
+      end
+
+      def element(name, attrs, *children)
+        XML::SimpleTree::Element.new(name, attrs, *children)
+      end
+
+      def text(txt)
+        XML::SimpleTree::Text.new(txt)
+      end
+
+    end # class XMLParser
+
+    Classes = [Simple, XMLParser]
+
+    # yields an instance of each installed XML writer
+    def self.each_installed_writer
+      XMLRPC::XMLWriter::Classes.each do |klass|
+        begin
+          yield klass.new
+        rescue LoadError
+        end
+      end
+    end
+
+  end # module XMLWriter
+
+  # Creates XML-RPC call/response documents
+  #
+  class Create
+
+    def initialize(xml_writer = nil)
+      @writer = xml_writer || Config::DEFAULT_WRITER.new
+    end
+
+
+    def methodCall(name, *params)
+      name = name.to_s
+
+      if name !~ /[a-zA-Z0-9_.:\/]+/
+        raise ArgumentError, "Wrong XML-RPC method-name"
+      end
+
+      parameter = params.collect do |param|
+        @writer.ele("param", conv2value(param))
+      end
+
+      tree = @writer.document(
+               @writer.pi("xml", 'version="1.0"'),
+               @writer.ele("methodCall",
+                 @writer.tag("methodName", name),
+                 @writer.ele("params", *parameter)
+               )
+             )
+
+      @writer.document_to_str(tree) + "\n"
+    end
+
+
+
+    #
+    # Generates a XML-RPC methodResponse document
+    #
+    # When +is_ret+ is +false+ then the +params+ array must
+    # contain only one element, which is a structure
+    # of a fault return-value.
+    #
+    # When +is_ret+ is +true+ then a normal
+    # return-value of all the given +params+ is created.
+    #
+    def methodResponse(is_ret, *params)
+
+      if is_ret
+        resp = params.collect do |param|
+          @writer.ele("param", conv2value(param))
+        end
+
+        resp = [@writer.ele("params", *resp)]
+      else
+        if params.size != 1 or params[0] === XMLRPC::FaultException
+          raise ArgumentError, "no valid fault-structure given"
+        end
+        resp = @writer.ele("fault", conv2value(params[0].to_h))
+      end
+
+
+      tree = @writer.document(
+               @writer.pi("xml", 'version="1.0"'),
+               @writer.ele("methodResponse", resp)
+             )
+
+      @writer.document_to_str(tree) + "\n"
+    end
+
+
+
+    private
+
+    #
+    # Converts a Ruby object into a XML-RPC <code><value></code> tag
+    #
+    def conv2value(param) # :doc:
+
+        val = case param
+        when Fixnum, Bignum
+          # XML-RPC's int is 32bit int, and Fixnum also may be beyond 32bit
+          if Config::ENABLE_BIGINT
+            @writer.tag("i4", param.to_s)
+          else
+            if param >= -(2**31) and param <= (2**31-1)
+              @writer.tag("i4", param.to_s)
+            else
+              raise "Bignum is too big! Must be signed 32-bit integer!"
+            end
+          end
+        when TrueClass, FalseClass
+          @writer.tag("boolean", param ? "1" : "0")
+
+        when Symbol
+          @writer.tag("string", param.to_s)
+
+        when String
+          @writer.tag("string", param)
+
+        when NilClass
+          if Config::ENABLE_NIL_CREATE
+            @writer.ele("nil")
+          else
+            raise "Wrong type NilClass. Not allowed!"
+          end
+
+        when Float
+          raise "Wrong value #{param}. Not allowed!" unless param.finite?
+          @writer.tag("double", param.to_s)
+
+        when Struct
+          h = param.members.collect do |key|
+            value = param[key]
+            @writer.ele("member",
+              @writer.tag("name", key.to_s),
+              conv2value(value)
+            )
+          end
+
+          @writer.ele("struct", *h)
+
+        when Hash
+          # TODO: can a Hash be empty?
+
+          h = param.collect do |key, value|
+            @writer.ele("member",
+              @writer.tag("name", key.to_s),
+              conv2value(value)
+            )
+          end
+
+          @writer.ele("struct", *h)
+
+        when Array
+          # TODO: can an Array be empty?
+          a = param.collect {|v| conv2value(v) }
+
+          @writer.ele("array",
+            @writer.ele("data", *a)
+          )
+
+        when Time, Date, ::DateTime
+          @writer.tag("dateTime.iso8601", param.strftime("%Y%m%dT%H:%M:%S"))
+
+        when XMLRPC::DateTime
+          @writer.tag("dateTime.iso8601",
+            format("%.4d%02d%02dT%02d:%02d:%02d", *param.to_a))
+
+        when XMLRPC::Base64
+          @writer.tag("base64", param.encoded)
+
+        else
+          if Config::ENABLE_MARSHALLING and param.class.included_modules.include? XMLRPC::Marshallable
+            # convert Ruby object into Hash
+            ret = {"___class___" => param.class.name}
+            param.instance_variables.each {|v|
+              name = v[1..-1]
+              val = param.instance_variable_get(v)
+
+              if val.nil?
+                ret[name] = val if Config::ENABLE_NIL_CREATE
+              else
+                ret[name] = val
+              end
+            }
+            return conv2value(ret)
+          else
+            ok, pa = wrong_type(param)
+            if ok
+              return conv2value(pa)
+            else
+              raise "Wrong type!"
+            end
+          end
+        end
+
+        @writer.ele("value", val)
+    end
+
+    def wrong_type(value)
+      false
+    end
+
+
+  end # class Create
+
+end # module XMLRPC
+