DistelliServiceMarshallers 1.0

data/lib/distelli/servicemarshallers.rb

@@ -0,0 +1,431 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'date'
+require 'nokogiri'
+require 'distelli/serviceinterface'
+
+module Distelli
+  DATA_TYPES = ["int", "string", "boolean", "long", "double"]
+  class Marshaller
+    def initialize()
+      @object_map = Hash.new
+    end
+
+    def add_object(obj)
+      @object_map[obj.name] = obj
+    end
+  end
+
+  class MarshallException < StandardError
+  end
+
+  ################################
+  # JSON Marshaller
+  ################################
+
+  class JsonMarshaller < Marshaller
+    def initialize()
+      super
+    end
+
+    def encode(obj)
+      data = Hash.new
+      if obj.is_a?(Integer) or obj.is_a?(Float) or obj.is_a?(String) or obj.is_a?(TrueClass) or obj.is_a?(FalseClass)
+        return obj
+      elsif obj.is_a?(DateTime)
+        return obj.strftime("%Y-%m-%dT%H:%M:%S%z")
+      end
+
+      type_map_name = '_'+obj.class.name.split('::').last+'__type_map'
+      obj.instance_variables.each do |var|
+        var_name = var.to_s.delete('@')
+        if var_name == type_map_name
+          next
+        end
+        val = obj.instance_variable_get(var)
+        if val.is_a?(Integer) or val.is_a?(Float) or val.is_a?(String) or val.is_a?(TrueClass) or val.is_a?(FalseClass)
+          data[var_name] = val
+        elsif val.is_a?(DateTime)
+          data[var_name] = val.strftime("%Y-%m-%dT%H:%M:%S%z")
+        elsif val.instance_of?(Array)
+          array = Array.new
+          val.each do |elem|
+            encoded = encode(elem)
+            array.push(encoded)
+          end
+          data[var_name] = array
+        else val.kind_of?(Object)
+          encoded = encode(val)
+          data[var_name] = encoded
+        end
+      end
+      return data
+    end
+
+    def marshall(request)
+      data = encode(request)
+      request_wrapper = Hash.new
+      request_wrapper[request.class.name.split('::').last] = data
+      return request_wrapper.to_json
+    end
+
+    def marshall_error(error)
+      if not error.is_a?(Distelli::BaseException)
+        raise StandardError.new("Cannot marshall error: "+error.inspect) 
+      end
+      
+      err_msg = error.err_msg
+      err_code = error.err_code
+      return '{"Error":{"code":"'+err_code.to_s+'", "message":"'+err_msg.to_s+'"}}'
+    end
+
+    def unmarshall_error(json_data)
+      data_hash = JSON.load(json_data)
+      err_obj = data_hash[ServiceConstants::ERROR_KEY]
+      if err_obj == nil
+        return nil
+      end
+      err_code = err_obj[ServiceConstants::ERR_CODE_KEY]
+      err_msg = err_obj[ServiceConstants::ERR_MSG_KEY]
+      return [err_code, err_msg]
+    end
+
+    def unmarshall(json_data)
+      data_hash = JSON.load(json_data)
+      data_hash.each_pair do |k,v|
+        if v.is_a?(Hash)
+          return unmarshall_obj(k, v)
+        else
+          raise MarshallException.new("Invalid data "+json_data)
+        end
+      end
+    end
+
+    private
+    def to_obj_list(obj_name, list_data)
+      obj_list = Array.new
+      # If its a list type then its a list of complex objects
+      if list_data.is_a?(Array)
+        list_data.each do |v|
+          obj = unmarshall_obj(obj_name, v)
+          obj_list.push(obj)
+        end
+      else # Else its a map (hopefully) and its only a single complex object
+        obj = unmarshall_obj(obj_name, list_data)
+        obj_list.push(obj)
+      end
+      return obj_list
+    end
+
+    private
+    def to_date_list(list_data)
+      date_list = Array.new
+      list_data.each do |v|
+        date_val = DateTime.strptime(v, "%Y-%m-%dT%H:%M:%S%z")
+        date_list.push(date_val)
+      end
+      return date_list
+    end
+
+    private
+    def unmarshall_list(list_data, data_type)
+      if list_data.length == 0
+        return Array.new
+      end
+      actual_list = list_data
+      if data_type == "date"
+        return to_date_list(actual_list)
+      elsif DATA_TYPES.include?(data_type)
+        return actual_list
+      else
+        return to_obj_list(data_type, actual_list)
+      end
+    end
+
+    private
+    def unmarshall_obj(obj_name, data)
+#      puts "Unmarshalling object: "+obj_name
+      if !@object_map.has_key?(obj_name)
+        raise MarshallException.new("Unknown object: "+obj_name.to_s)
+      end
+      class_obj = @object_map[obj_name]
+      instance = class_obj.new
+      type_map_name = '@_'+obj_name+'__type_map'
+      type_map = instance.instance_variable_get(type_map_name)
+      data.each_pair do |k,v|
+        if !type_map.include?(k)
+          raise MarshallException.new("Unknown type for field: "+k)
+        end
+        field_type = type_map[k]
+        if field_type.is_a?(Array)
+          field_type = field_type[0]
+        end
+        if v.is_a?(Hash)
+          um_obj = unmarshall_obj(field_type, v)
+          instance.instance_variable_set('@'+k, um_obj)
+        elsif v.is_a?(Array)
+          um_list = unmarshall_list(v, field_type)
+          instance.instance_variable_set('@'+k, um_list)
+        else
+          if field_type == "date"
+            date_val = DateTime.strptime(v, "%Y-%m-%dT%H:%M:%S%z")
+            instance.instance_variable_set('@'+k, date_val)
+          elsif field_type == "int"
+            instance.instance_variable_set('@'+k, v.to_i)
+          elsif field_type == "double"
+            instance.instance_variable_set('@'+k, v.to_f)
+          elsif field_type == "long"
+            instance.instance_variable_set('@'+k, v.to_i)
+          else
+            instance.instance_variable_set('@'+k, v)
+          end
+        end
+      end
+      return instance
+    end
+  end
+
+  ################################
+  # XML Marshaller
+  ################################
+
+  class XmlMarshaller < Marshaller
+    def initialize()
+      super
+    end
+
+    def marshall(request)
+      root_tag_name = request.class.name.split('::').last
+      return ['<', root_tag_name,'>', encode_obj_xml(request), '</', root_tag_name, '>'].join('')
+    end
+
+    def unmarshall(xml_data)
+      xml_doc = Nokogiri::XML(xml_data)
+      root_node = xml_doc.root
+      return unmarshall_obj(root_node)
+    end
+
+    def marshall_error(error)
+      if not error.is_a?(Distelli::BaseException)
+        raise StandardError.new("Cannot marshall error: "+error.inspect) 
+      end
+
+      err_msg = error.err_msg
+      err_code = error.err_code
+      return "<Error><code>"+err_code.to_s+"</code><message>"+err_msg.to_s+"</message></Error>"
+    end
+
+    ##########################################################
+    # Unmarshalls an xml error response and returns the error
+    #     code and message.
+    #
+    #     This is what an xml error looks like:
+    #
+    #     <Error>
+    #       <code>MalformedRequest</code>
+    #       <message>The request is malformed</message>
+    #     </Error>
+    ##########################################################
+    def unmarshall_error(xml_data)
+      xml_doc = Nokogiri::XML(xml_data)
+      err_code_elem = xml_doc.xpath('//'+ServiceConstants::ERROR_KEY+'//'+ServiceConstants::ERR_CODE_KEY)
+      err_msg_elem = xml_doc.xpath('//'+ServiceConstants::ERROR_KEY+'//'+ServiceConstants::ERR_MSG_KEY)
+      err_code = nil
+      err_msg = nil
+      if err_code_elem != nil
+        err_code = err_code_elem.text
+      end
+      if err_msg_elem != nil
+        err_msg = err_msg_elem.text
+      end
+      return [err_code, err_msg]
+    end
+
+    private
+    def get_node_text(node)
+      children = node.children
+      if children.length == 0
+        return nil
+      end
+      if children.length != 1
+        raise MarshallException.new(node.to_s+" is not a text node")
+      end
+
+      text_node = children[0]
+      return text_node.content
+    end
+
+    private
+    def unmarshall_list(obj_node, list_type)
+#      puts "Unmarshalling list at "+obj_node.to_s
+      list_elements = obj_node.children
+      list_data = Array.new
+      list_elements.each do |elem|
+        # If its a simple type list
+#        puts "Unmarshalling list elemnt "+elem.name+" "+list_type
+        if list_type == "date"
+          obj_node_content = get_node_text(elem)
+          date_val = DateTime.strptime(obj_node.content, "%Y-%m-%dT%H:%M:%S%z")
+          list_data.push(date_val)
+        elsif DATA_TYPES.include?(list_type)
+#          puts "Unmarshalling primitive list element "+elem.name+" "+list_type
+          elem_text = get_node_text(elem)
+          if list_type == "int"
+            list_data.push(elem_text.to_i)
+          elsif list_type == "long"
+            list_data.push(elem_text.to_i)
+          elsif list_type == "boolean"
+            if elem_text.downcase == "true"
+              list_data.push(true)
+            else
+              list_data.push(false)
+            end
+          elsif list_type == "double"
+            list_data.push(elem_text.to_f)
+          else
+            list_data.push(elem_text)
+          end
+        else
+#          puts "Unmarshalling complex list element"+elem.name+" "+list_type
+          # Else its a list of complex types
+          unmarshalled_obj = unmarshall_obj(elem)
+          list_data.push(unmarshalled_obj)
+        end
+      end
+      return list_data
+    end
+
+    private
+    def unmarshall_obj(obj_node, parent_obj=nil)
+#      puts "Unmarshalling "+obj_node.name+" "+obj_node.inspect+" member of "+parent_obj.to_s
+      obj_name = obj_node.name
+      obj_instance = nil
+      if parent_obj == nil
+        if !@object_map.has_key?(obj_name)
+          raise MarshallException.new("Unknown object: "+obj_name.to_s)
+        end
+        class_obj = @object_map[obj_name]
+        obj_instance = class_obj.new
+      else
+        # Parent object is not none. So obj_node is a member of
+        # obj_instance and we can get the type from the parent obj
+        # First get the type map
+#        puts "Processing "+obj_name
+        type_map_name = '@_'+parent_obj.class.name.split('::').last+'__type_map'
+        type_map = parent_obj.instance_variable_get(type_map_name)
+        if type_map == nil
+          raise MarshallException.new(parent_obj.class.name+" cannot be unmarshalled. Missing type_map: "+type_map_name)
+        end
+
+        if !type_map.include?(obj_name)
+          raise MarshallException.new("Unknown type for field: "+obj_name+" in obj "+obj_instance.to_s)
+        end
+        obj_type = type_map[obj_name]
+#        puts "Unmarshalling "+obj_name+" "+obj_type.to_s
+        # Obj type can be either a list or one of the defined
+        # primitive types or a complex type
+        if obj_type.is_a?(Array)
+          list_type = obj_type[0]
+#          puts obj_name+" is a list in "+parent_obj.to_s+" of type "+list_type
+          unmarshalled_list = unmarshall_list(obj_node, list_type)
+#          puts "Unmarshalled list"+unmarshalled_list.to_s
+          parent_obj.instance_variable_set('@'+obj_name, unmarshalled_list)
+          return obj_instance
+        elsif obj_type == "date"
+          date_val = DateTime.strptime(obj_node.content, "%Y-%m-%dT%H:%M:%S%z")
+          parent_obj.instance_variable_set('@'+obj_name, date_val)
+          return obj_instance
+        elsif DATA_TYPES.include?(obj_type)
+#          puts obj_name+" is a primitive "+obj_type+" "+obj_node+" in "+parent_obj.to_s
+          if obj_type == "int" or obj_type == "long"
+            parent_obj.instance_variable_set('@'+obj_name, get_node_text(obj_node).to_i)
+          elsif obj_type == "boolean"
+            obj_text = get_node_text(obj_node)
+            if obj_text.downcase == "true"
+              parent_obj.instance_variable_set('@'+obj_name, true)
+            else
+              parent_obj.instance_variable_set('@'+obj_name, false)
+            end
+          elsif obj_type == "double"
+            parent_obj.instance_variable_set('@'+obj_name, get_node_text(obj_node).to_f)
+          else
+            parent_obj.instance_variable_set('@'+obj_name, get_node_text(obj_node))
+          end
+          return obj_instance
+        else
+#          puts obj_name+" is a complex type "+obj_type+" in "+parent_obj.to_s
+          if !@object_map.has_key?(obj_type)
+            raise MarshallException.new("Unknown object: "+obj_type.to_s)
+          end
+
+          class_obj = @object_map[obj_type]
+          obj_instance = class_obj.new
+          parent_obj.instance_variable_set('@'+obj_name, obj_instance)
+        end
+      end
+#      puts "Processing children of "+obj_node.name
+      children = obj_node.children
+      children.each do |child|
+        unmarshall_obj(child, parent_obj=obj_instance)
+      end
+      return obj_instance
+    end
+
+    private
+    def encode_primitive_xml(tag_name, value)
+      if value.is_a?(DateTime)
+        return ['<', tag_name, '>', value.strftime("%Y-%m-%dT%H:%M:%S%z"), '</', tag_name, '>'].join('')
+      else
+        ['<', tag_name, '>', value.to_s, '</', tag_name, '>'].join('')
+      end
+    end
+
+    private
+    def list_to_xml(list_obj, list_type)
+      xml_data = Array.new
+      list_obj.each do |item|
+        if item.is_a?(DateTime) or item.is_a?(Integer) or item.is_a?(Float) or item.is_a?(String) or item.is_a?(TrueClass) or item.is_a?(FalseClass)
+          xml_data.push(encode_primitive_xml(list_type, item))
+        else
+            xml_data.push(['<', list_type, '>', encode_obj_xml(item), '</', list_type, '>'].join(''))
+        end
+      end
+      return xml_data.join('')
+    end
+
+    private
+    def encode_obj_xml(obj)
+      type_map_name = '_'+obj.class.name.split('::').last+'__type_map'
+      type_map = obj.instance_variable_get('@'+type_map_name)
+      xml_data = Array.new
+
+      obj.instance_variables.each do |var|
+        k = var.to_s.delete('@')
+#        puts "Var: "+var.to_s+" TMN: "+type_map_name.to_s
+        if k == type_map_name
+          next
+        end
+        v = obj.instance_variable_get(var)
+        data_type = type_map[k]
+
+        if data_type.is_a?(Array)
+          data_type = data_type[0]
+        end
+
+#        print "Encoding "+k.to_s+" "+v.to_s
+        key = k
+        if v.is_a?(Array)
+          xml_data.push(['<', key, '>', list_to_xml(v, data_type), '</', key, '>'].join(''))
+        elsif v.is_a?(DateTime)
+          xml_data.push(encode_primitive_xml(key, v))
+        elsif DATA_TYPES.include?(data_type)
+            xml_data.push(encode_primitive_xml(key, v))
+        else
+            xml_data.push(['<', key, '>', encode_obj_xml(v), '</', key, '>'].join(''))
+        end
+      end
+      return xml_data.join('')
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: DistelliServiceMarshallers
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Rahul Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: DistelliServiceInterface
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Distelli Service Marshallers for Ruby Servers and Clients
+email: rsingh@distelli.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/distelli/servicemarshallers.rb
+homepage: http://www.distelli.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Distelli Service Marshaller classes
+test_files: []