wsdl-mapper 0.0.7

data/lib/wsdl_mapper/deserializers/attr_mapping.rb

@@ -0,0 +1,21 @@
+module WsdlMapper
+  module Deserializers
+    class AttrMapping < Struct.new(:accessor, :name, :type_name)
+      def getter
+        accessor
+      end
+
+      def setter
+        "#{accessor}="
+      end
+
+      def get(obj)
+        obj.send getter
+      end
+
+      def set(obj, value)
+        obj.send setter, value
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/class_mapping.rb

@@ -0,0 +1,122 @@
+require 'wsdl_mapper/dom/directory'
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/dom/builtin_type'
+require 'wsdl_mapper/deserializers/attr_mapping'
+require 'wsdl_mapper/deserializers/prop_mapping'
+require 'wsdl_mapper/deserializers/errors'
+
+module WsdlMapper
+  module Deserializers
+    class ClassMapping
+      class Delegate < Struct.new(:accessor, :type_name)
+      end
+
+      XSI_NS = 'http://www.w3.org/2001/XMLSchema-instance'
+      XSI_NIL = WsdlMapper::Dom::Name.get XSI_NS, 'nil'
+
+      include ::WsdlMapper::Dom
+      attr_reader :attributes, :properties
+
+      def initialize(cls, simple: false, &block)
+        @cls = cls
+        @attributes = Directory.new #on_nil: Errors::UnknownAttributeError
+        @properties = Directory.new on_nil: Errors::UnknownElementError
+        @simple = simple
+        @wrappers = Directory.new
+        @delegate = nil
+
+        instance_exec(&block)
+      end
+
+      def register_attr(accessor, attr_name, type_name)
+        attr_name = Name.get(*attr_name)
+        @attributes[attr_name] = AttrMapping.new(accessor, attr_name, Name.get(*type_name))
+      end
+
+      def register_prop(accessor, prop_name, type_name, array: false)
+        prop_name = Name.get(*prop_name)
+        @properties[prop_name] = PropMapping.new(accessor, prop_name, Name.get(*type_name), array: array)
+      end
+
+      def register_delegate(accessor, type_name)
+        @delegate = Delegate.new accessor, Name.get(*type_name)
+      end
+
+      def register_wrapper(name)
+        name = Name.get(*name)
+        @wrappers[name] = true
+      end
+
+      def wrapper?(name)
+        @wrappers[name]
+      end
+
+      def start(_base, _frame)
+      end
+
+      def end(base, frame)
+        return if nil_attr?(frame.attrs)
+
+        frame.object = build_object base, frame
+
+        if @delegate
+          mapping = base.get_type_mapping @delegate.type_name
+          delegate = mapping.build_object base, frame
+          mapping.set_properties base, frame, delegate
+          mapping.set_attributes base, frame, delegate
+          frame.object.send "#{@delegate.accessor}=", delegate
+        else
+          set_attributes base, frame, frame.object
+          set_properties base, frame, frame.object
+        end
+      end
+
+      def nil_attr? attrs
+        # TODO: test
+        !!attrs.find do |(name, _)|
+          name == XSI_NIL
+        end
+      end
+
+      def build_object(base, frame)
+        if @simple
+          type_name = WsdlMapper::Dom::Name.get(*@simple)
+          content = base.to_ruby type_name, frame.text
+          @cls.new content
+        else
+          @cls.new
+        end
+      end
+
+      def get_type_name_for_prop(prop_name)
+        @properties[prop_name].type_name
+      rescue Errors::UnknownElementError => e
+        e.parent = @cls
+        raise e
+      end
+
+      def set_properties(base, frame, object)
+        frame.children.each do |child|
+          name = child.name
+          prop_mapping = properties[name]
+
+          if BuiltinType.builtin? prop_mapping.type_name
+            ruby_value = base.to_ruby prop_mapping.type_name, child.text
+            prop_mapping.set object, ruby_value
+          else
+            prop_mapping.set object, child.object
+          end
+        end
+      end
+
+      def set_attributes(base, frame, object)
+        frame.attrs.each do |(name, value)|
+          attr_mapping = attributes[name]
+          next unless attr_mapping
+          ruby_value = base.to_ruby attr_mapping.type_name, value
+          attr_mapping.set object, ruby_value
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/deserializer.rb

@@ -0,0 +1,83 @@
+require 'nokogiri'
+
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/dom/namespaces'
+require 'wsdl_mapper/type_mapping'
+require 'wsdl_mapper/dom/directory'
+
+require 'wsdl_mapper/deserializers/class_mapping'
+require 'wsdl_mapper/deserializers/soap_array_mapping'
+require 'wsdl_mapper/deserializers/sax_document'
+
+require 'wsdl_mapper/deserializers/errors'
+
+module WsdlMapper
+  module Deserializers
+    class Deserializer
+      include WsdlMapper::Dom
+
+      def initialize(type_mapping: WsdlMapper::TypeMapping::DEFAULT,
+          qualified_elements: false,
+          qualified_attributes: false,
+          skip_unknown_elements: false
+      )
+        @tm = type_mapping
+        @element_mappings = Directory.new on_nil: Errors::UnknownElementError
+        @type_mappings = Directory.new on_nil: Errors::UnknownTypeError
+        @element_type_mappings = Directory.new do |name|
+          get_type_mapping get_element_type name
+        end
+        @qualified_elements = qualified_elements
+        @qualified_attributes = qualified_attributes
+        @skip_unknown_elements = skip_unknown_elements
+      end
+
+      def from_xml(xml)
+        doc = SaxDocument.new self
+        parser = Nokogiri::XML::SAX::Parser.new doc
+        parser.parse xml
+        doc.object
+      end
+
+      def register_element(element_name, type_name)
+        element_name = Name.get(*element_name)
+        type_name = Name.get(*type_name)
+        @element_mappings[element_name] = type_name
+      end
+
+      def register_type(type_name, class_mapping)
+        type_name = Name.get(*type_name)
+        @type_mappings[type_name] = class_mapping
+      end
+
+      def get_element_type(element_name)
+        @element_mappings[element_name]
+      end
+
+      def get_element_type_mapping(element_name)
+        @element_type_mappings[element_name]
+      end
+
+      def get_type_mapping(type_name)
+        return if WsdlMapper::Dom::BuiltinType.builtin? type_name
+        @type_mappings[type_name]
+      end
+
+      def to_ruby(type, value)
+        @tm.to_ruby type, value
+      end
+
+      def qualified_elements?
+        !!@qualified_elements
+      end
+
+      def qualified_attributes?
+        !!@qualified_attributes
+      end
+
+      def skip_unknown_elements?
+        !!@skip_unknown_elements
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/element_directory.rb

@@ -0,0 +1,66 @@
+require 'wsdl_mapper/dom/directory'
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/deserializers/errors'
+
+module WsdlMapper
+  module Deserializers
+    class ElementDirectory
+      class ElementItem < Struct.new(:element_name, :type_name, :require_path, :class_name)
+        attr_accessor :loaded
+      end
+
+      def initialize(type_directory, *base, &block)
+        @type_directory = type_directory
+        @directory = WsdlMapper::Dom::Directory.new on_nil: Errors::UnknownElementError
+        @base = base
+
+        instance_exec(&block) if block_given?
+      end
+
+      def register_element(element_name, type_name, require_path, class_name)
+        element_name = WsdlMapper::Dom::Name.get(*element_name)
+        type_name = WsdlMapper::Dom::Name.get(*type_name)
+        @directory[element_name] = ElementItem.new element_name, type_name, require_path, class_name
+      end
+
+      def knows?(element_name)
+        @directory.has_key?(element_name) || @base.any? { |b| b.knows? element_name }
+      end
+
+      def load(element_name)
+        if @directory.has_key? element_name
+          item = @directory[element_name]
+          if item.loaded
+            false
+          else
+            require item.require_path
+            item.loaded = true
+            true
+          end
+        else
+          base = @base.find { |b| b.knows? element_name }
+          unless base
+            raise Errors::UnknownElementError.new element_name
+          end
+          base.load element_name
+        end
+      end
+
+      def each_element(&block)
+        if block_given?
+          @base.each do |base|
+            base.each_element(&block)
+          end
+          @directory.each(&block)
+        else
+          types = @base.inject([]) { |sum, b| sum + b.each_element.to_a }
+          types + @directory.each.to_a
+        end
+      end
+
+      def each_type(&block)
+        @type_directory.each_type(&block)
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/errors.rb

@@ -0,0 +1,28 @@
+module WsdlMapper
+  module Deserializers
+    module Errors
+      class UnknownError < StandardError
+        attr_reader :name
+        attr_accessor :parent
+
+        def initialize(name)
+          @name = name
+          super "Unknown: #{name}"
+        end
+
+        def to_s
+          "Unknown: #{name} in #{parent}"
+        end
+      end
+
+      class UnknownElementError < UnknownError
+      end
+
+      class UnknownAttributeError < UnknownError
+      end
+
+      class UnknownTypeError < UnknownError
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/frame.rb

@@ -0,0 +1,31 @@
+module WsdlMapper
+  module Deserializers
+    class Frame
+      attr_reader :name, :parent, :attrs, :base, :mapping, :namespaces, :children, :type_name
+      attr_accessor :text, :object
+
+      def initialize(name, type_name, attrs, parent, namespaces, base, mapping)
+        @name = name
+        @type_name = type_name
+        @parent = parent
+        @attrs = attrs
+        @namespaces = namespaces
+        @base = base
+        @mapping = mapping
+        @children = []
+      end
+
+      def start
+        if @mapping
+          @mapping.start @base, self
+        end
+      end
+
+      def end
+        if @mapping
+          @mapping.end @base, self
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/lazy_loading_deserializer.rb

@@ -0,0 +1,39 @@
+require 'wsdl_mapper/deserializers/deserializer'
+
+module WsdlMapper
+  module Deserializers
+    class LazyLoadingDeserializer < Deserializer
+      def initialize(element_directory,
+          type_mapping: WsdlMapper::TypeMapping::DEFAULT,
+          qualified_elements: false,
+          qualified_attributes: false,
+          skip_unknown_elements: false)
+        super(type_mapping: type_mapping,
+            qualified_elements: qualified_elements,
+            qualified_attributes: qualified_attributes,
+            skip_unknown_elements: skip_unknown_elements
+        )
+        @element_directory = element_directory
+        reload
+      end
+
+      def get_element_type(element_name)
+        if @element_directory.load element_name
+          reload
+        end
+        super
+      end
+
+      protected
+      def reload
+        @element_type_mappings.clear
+        @element_directory.each_element do |(elm_name, item)|
+          @element_mappings[elm_name] = item.type_name
+        end
+        @element_directory.each_type do |(type_name, class_mapping)|
+          @type_mappings[type_name] = class_mapping
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/prop_mapping.rb

@@ -0,0 +1,26 @@
+require 'wsdl_mapper/deserializers/attr_mapping'
+
+module WsdlMapper
+  module Deserializers
+    class PropMapping < AttrMapping
+      def initialize(*args, array: false)
+        super(*args)
+        @array = array
+      end
+
+      def array?
+        !!@array
+      end
+
+      def set(obj, value)
+        if array?
+          obj.send setter, obj.send(getter) || []
+          obj.send(getter) << value
+        else
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/wsdl_mapper/deserializers/sax_document.rb

@@ -0,0 +1,156 @@
+require 'wsdl_mapper/deserializers/frame'
+
+module WsdlMapper
+  module Deserializers
+    class SaxDocument < ::Nokogiri::XML::SAX::Document
+      include WsdlMapper::Dom
+
+      attr_reader :object
+
+      XSI_NS = 'http://www.w3.org/2001/XMLSchema-instance'
+      XSI_TYPE = WsdlMapper::Dom::Name.get XSI_NS, 'type'
+
+      # @param [WsdlMapper::Deserializers::Deserializer] base
+      def initialize(base)
+        @base = base
+        @namespaces_stack = []
+        @buffer = ''
+        @wrapper = nil
+        @skipping = nil
+        @current_frame = nil
+      end
+
+      # @param [String] name
+      # @param [Array<Nokogiri::XML::Attr>] attrs
+      # @param [String] _prefix
+      # @param [String] uri
+      # @param [Array<Array<String, String>>] ns
+      def start_element_namespace(name, attrs = [], _prefix = nil, uri = nil, ns = [])
+        @buffer = ''
+        if @skipping
+          return
+        end
+        uri = inherit_element_namespace uri
+        name = Name.get uri, name
+        namespaces = Namespaces.for Hash[ns]
+        @namespaces_stack << namespaces
+        if @current_frame && @current_frame.mapping.wrapper?(name)
+          @wrapper = name
+          return
+        end
+        begin
+          type_name = get_type_name name, attrs
+          attrs = get_attributes type_name, attrs
+          parent = @current_frame
+          mapping = @base.get_type_mapping type_name
+          @current_frame = Frame.new name, type_name, attrs, parent, namespaces, @base, mapping
+          @current_frame.start
+        rescue WsdlMapper::Deserializers::Errors::UnknownElementError => e
+          if @base.skip_unknown_elements?
+            @skipping = name
+            return
+          else
+            raise e
+          end
+        end
+      end
+
+      # @param [String] name
+      # @param [String] _prefix
+      # @param [String] uri
+      def end_element_namespace(name, _prefix = nil, uri = nil)
+        @namespaces_stack.pop
+        if @wrapper == Name.get(uri, name)
+          @wrapper = nil
+          return
+        end
+        if @skipping
+          # Check if the sub-tree-to-skip is at its end
+          # TODO: edge case of nested same-element
+          if @skipping == Name.get(uri, name)
+            @skipping = nil
+            return
+          end
+          # If we are skipping this sub-tree, just return
+          return
+        end
+        @current_frame.text = @buffer
+        @buffer = ''
+        @last_frame = @current_frame
+        @current_frame = @current_frame.parent
+        if @current_frame
+          @current_frame.children << @last_frame
+        end
+        @last_frame.end
+      end
+
+      def end_document
+        @object = @last_frame.object
+      end
+
+      def characters(text)
+        @buffer << text
+      end
+
+      def cdata_block(text)
+        @buffer << text
+      end
+
+      protected
+      # @param [WsdlMapper::Dom::Name] element_name
+      # @return [WsdlMapper::Dom::Name]
+      def get_type_name(element_name, attrs)
+        if @current_frame
+          type_attr = get_type_attr attrs
+          if type_attr
+            # TODO: test
+            parse_name type_attr.value
+          else
+            @current_frame.mapping.get_type_name_for_prop element_name
+          end
+        else
+          @base.get_element_type element_name
+        end
+      end
+
+      def parse_name(name_str)
+        name, ns_code = name_str.split(':').reverse
+        ns = @namespaces_stack.reverse_each.map { |namespaces| namespaces[ns_code] }.find { |uri| !uri.nil? }
+
+        Name.get ns, name
+      end
+
+      def get_type_attr(attrs)
+        attrs.find do |attr|
+          attr.uri == XSI_TYPE.ns && attr.localname == XSI_TYPE.name
+        end
+      end
+
+      def inherit_element_namespace(ns)
+        # TODO: test
+        if ns.nil? && !@base.qualified_elements? && @current_frame
+          @wrapper ? @wrapper.ns : @current_frame.type_name.ns
+        else
+          ns
+        end
+      end
+
+      def inherit_attr_namespace(type_name, ns)
+        # TODO: test
+        if ns.nil? && !@base.qualified_attributes? && @current_frame
+          type_name.ns
+        else
+          ns
+        end
+      end
+
+      def get_attributes(type_name, attrs)
+        attrs.map do |attr|
+          uri = inherit_attr_namespace type_name, attr.uri
+          name = Name.get uri, attr.localname
+          [name, attr.value]
+        end
+      end
+    end
+  end
+end