wsdl-mapper 0.0.7

data/lib/wsdl_mapper/deserializers/soap_array_mapping.rb

@@ -0,0 +1,34 @@
+require 'wsdl_mapper/dom/directory'
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/dom/builtin_type'
+
+module WsdlMapper
+  module Deserializers
+    class SoapArrayMapping
+      include ::WsdlMapper::Dom
+
+      def initialize(cls, type:)
+        @cls = cls
+        @type = Name.get(*type)
+      end
+
+      def start(_base, frame)
+        frame.object = @cls.new
+      end
+
+      def end(_base, frame)
+        frame.children.each do |child|
+          frame.object << child.object
+        end
+      end
+
+      def get_type_name_for_prop(_element_name)
+        @type
+      end
+
+      def wrapper?(_name)
+        false
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/deserializers/type_directory.rb

@@ -0,0 +1,39 @@
+require 'wsdl_mapper/dom/directory'
+require 'wsdl_mapper/deserializers/errors'
+require 'wsdl_mapper/deserializers/class_mapping'
+require 'wsdl_mapper/deserializers/soap_array_mapping'
+
+module WsdlMapper
+  module Deserializers
+    class TypeDirectory
+      def initialize(*base, &block)
+        @types = WsdlMapper::Dom::Directory.new on_nil: Errors::UnknownTypeError
+        @base = base
+
+        instance_exec(&block) if block_given?
+      end
+
+      def register_type(type_name, klass, simple: false, &block)
+        type_name = WsdlMapper::Dom::Name.get(*type_name)
+        @types[type_name] = ClassMapping.new klass, simple: simple, &block
+      end
+
+      def register_soap_array(type_name, klass, item_type_name)
+        type_name = WsdlMapper::Dom::Name.get(*type_name)
+        @types[type_name] = SoapArrayMapping.new klass, type: item_type_name
+      end
+
+      def each_type(&block)
+        if block_given?
+          @base.each do |base|
+            base.each_type(&block)
+          end
+          @types.each(&block)
+        else
+          types = @base.inject([]) { |sum, b| sum + b.each_type.to_a }
+          types + @types.each.to_a
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/attribute.rb

@@ -0,0 +1,42 @@
+require 'wsdl_mapper/dom/bounds'
+require 'wsdl_mapper/dom/type_base'
+
+module WsdlMapper
+  module Dom
+    class Attribute
+      class Ref < TypeBase
+        attr_accessor :containing_type
+      end
+
+      attr_reader :name, :type_name, :default, :use, :fixed, :form
+      attr_accessor :type
+      attr_accessor :documentation
+      attr_accessor :containing_type
+
+      def initialize(name, type_name, default: nil, use: nil, fixed: nil, form: nil)
+        @name, @type_name = name, type_name
+        @documentation = Documentation.new
+        @default = default
+        @use = use
+        @fixed = fixed
+        @form = form
+      end
+
+      def default?
+        !!@default
+      end
+
+      def fixed?
+        !!@fixed
+      end
+
+      def optional?
+        @use == 'optional'
+      end
+
+      def required?
+        @use == 'required'
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/bounds.rb

@@ -0,0 +1,15 @@
+module WsdlMapper
+  module Dom
+    class Bounds
+      attr_accessor :min, :max, :nillable
+
+      def initialize(min: nil, max: nil, nillable: nil)
+        @min, @max, @nillable = min, max, nillable
+      end
+
+      def dup
+        Bounds.new min: @min, max: @max, nillable: @nillable
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/builder.rb

@@ -0,0 +1,77 @@
+require 'wsdl_mapper/dom/schema'
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/dom/complex_type'
+require 'wsdl_mapper/dom/property'
+require 'wsdl_mapper/dom/attribute'
+require 'wsdl_mapper/dom/bounds'
+
+
+module WsdlMapper
+  module Dom
+    class Builder
+      def initialize(xsd_file)
+        @xsd_file = xsd_file
+      end
+
+      def build
+        schema = Schema.new
+
+        @xsd_file.complex_types.each do |xsd_type|
+          schema.add_type build_type(schema, xsd_type)
+        end
+
+        schema
+      end
+
+      def build_type(schema, xsd_type)
+        name = build_name xsd_type.name
+
+        type = ComplexType.new name
+
+        xsd_type.elements.each do |element|
+          property = build_property schema, element
+          type.add_property property
+        end
+
+        type
+      end
+
+      def build_property(_schema, xsd_element)
+        name = build_name xsd_element.name
+        type_name = build_name xsd_element.type
+
+        sequence = get_sequence xsd_element
+        bounds = get_bounds xsd_element
+
+        Property.new name, type_name, sequence: sequence, bounds: bounds
+      end
+
+      def build_name(qname)
+        Name.get qname.namespace, qname.name
+      end
+
+      def get_bounds(xsd_element)
+        parent_bounds = get_parent_bounds xsd_element.parent
+        # bounds = get_attribute_bounds xsd_element
+
+        parent_bounds #.override bounds
+      end
+
+      def get_parent_bounds(xsd_element)
+        case xsd_element
+        when WSDL::XMLSchema::Sequence
+          Bounds.new min: 1, max: 1
+        else
+          Bounds.new
+        end
+      end
+
+      def get_sequence(xsd_element)
+        parent = xsd_element.parent
+        return 0 unless parent.is_a? WSDL::XMLSchema::Sequence
+
+        parent.elements.find_index xsd_element
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/builtin_type.rb

@@ -0,0 +1,17 @@
+require 'wsdl_mapper/dom/type_base'
+require 'wsdl_mapper/dom/shallow_schema'
+
+module WsdlMapper
+  module Dom
+    class BuiltinType < TypeBase
+      NAMESPACE = 'http://www.w3.org/2001/XMLSchema'.freeze
+
+      extend ShallowSchema
+      self.namespace = NAMESPACE
+
+      def root
+        self
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/complex_type.rb

@@ -0,0 +1,63 @@
+require 'wsdl_mapper/dom/type_base'
+
+module WsdlMapper
+  module Dom
+    class ComplexType < WsdlMapper::Dom::TypeBase
+      attr_reader :properties, :attributes
+      attr_accessor :base_type_name, :base, :simple_content, :soap_array, :soap_array_type, :soap_array_type_name,
+        :containing_property, :containing_element
+
+      def initialize(name)
+        super
+        @properties = {}
+        @attributes = {}
+        @simple_content = false
+        @soap_array = false
+        @base = nil
+      end
+
+      def add_attribute(attribute)
+        attribute.containing_type = self
+        @attributes[attribute.name] = attribute
+      end
+
+      def add_property(property)
+        property.containing_type = self
+        @properties[property.name] = property
+      end
+
+      def each_property(&block)
+        properties.values.each(&block)
+      end
+
+      def each_property_with_bases(&block)
+        [*bases, self].inject([]) do |arr, type|
+          arr + type.each_property.to_a
+        end.each(&block)
+      end
+
+      def each_attribute(&block)
+        attributes.values.each(&block)
+      end
+
+      def simple_content?
+        !!@simple_content
+      end
+
+      def soap_array?
+        !!@soap_array
+      end
+
+      def root
+        @base ? @base.root : self
+      end
+
+      def bases
+        # TODO: test
+        return [] unless @base
+
+        [*@base.bases, @base]
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/directory.rb

@@ -0,0 +1,74 @@
+require 'wsdl_mapper/dom/name'
+
+module WsdlMapper
+  module Dom
+    class Directory
+      include Enumerable
+
+      def initialize(on_nil: nil, &block)
+        if block
+          @data = Hash.new do |h, k|
+            h[k] = Hash.new do |h2, k2|
+              h2[k2] = block[WsdlMapper::Dom::Name.get(k, k2)]
+            end
+          end
+        else
+          @data = {}
+        end
+        @on_nil = on_nil
+      end
+
+      def clear
+        @data.clear
+      end
+
+      # @param [WsdlMapper::Dom::Name] name
+      # @return [Object]
+      def get(name)
+        hsh = @data[name.ns]
+        hsh && hsh[name.name] ||
+          on_nil(name)
+      end
+      alias_method :[], :get
+
+      def on_nil(name)
+        @on_nil && raise(@on_nil.new(name))
+      end
+
+      def has_key?(name)
+        hsh = @data[name.ns]
+        !!(hsh && hsh[name.name])
+      end
+
+      # @param [WsdlMapper::Dom::Name] name
+      # @param [Object] value
+      def set(name, value)
+        @data[name.ns] ||= {}
+        @data[name.ns][name.name] = value
+      end
+      alias_method :[]=, :set
+
+      def each(&block)
+        enum = Enumerator.new do |y|
+          @data.each do |ns, data|
+            data.each do |name, value|
+              y << [WsdlMapper::Dom::Name.get(ns, name), value]
+            end
+          end
+        end
+        block_given? ? enum.each(&block) : enum.each
+      end
+
+      def each_value(&block)
+        enum = Enumerator.new do |y|
+          @data.each do |_, data|
+            data.each do |_, value|
+              y << value
+            end
+          end
+        end
+        block_given? ? enum.each(&block) : enum.each
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/documentation.rb

@@ -0,0 +1,16 @@
+module WsdlMapper
+  module Dom
+    class Documentation
+      attr_reader :default
+      attr_accessor :app_info
+
+      def initialize(text = nil)
+        @default = text
+      end
+
+      def present?
+        !@default.nil?
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/element.rb

@@ -0,0 +1,15 @@
+require 'wsdl_mapper/dom/documentation'
+
+module WsdlMapper
+  module Dom
+    class Element
+      attr_reader :name
+      attr_accessor :type_name, :type, :documentation
+
+      def initialize(name)
+        @name = name
+        @documentation = Documentation.new
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/enumeration_value.rb

@@ -0,0 +1,11 @@
+require 'wsdl_mapper/dom/type_base'
+
+module WsdlMapper
+  module Dom
+    class EnumerationValue < TypeBase
+      def value
+        name
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom/name.rb

@@ -0,0 +1,69 @@
+module WsdlMapper
+  module Dom
+    # Represents a fully qualified name of an XML element, that means, it contains both the namespace,
+    # and the local name
+    class Name
+      # @!attribute [r] ns
+      #   @return [String] Namespace (URI) of this fully qualified name.
+
+      # @!attribute [r] name
+      #   @return [String] Local name of this fully qualified name.
+
+      attr_reader :ns, :name
+
+      # Initialize a new fully qualified name.
+      # @param [String] ns
+      # @param [String] name
+      def initialize(ns, name)
+        @ns, @name = ns, name
+        @hash = [ns, name].hash
+      end
+
+      # Check if this fully qualified name is equal to `other`.
+      # @param [Name] other Other name to compare to.
+      # @return [true, false] true if `self` and `other` are equal both in namespace and in local name.
+      def eql?(other)
+        self.class == other.class && name == other.name && ns == other.ns
+      end
+
+      # @see {#eql?}
+      def ==(other)
+        eql? other
+      end
+
+      def hash
+        @hash
+      end
+
+      # Returns the fully qualified name as string representation in the format
+      # `"{namespace-uri}/local-name"`
+      # @return [String] String representation of this FQN
+      def to_s
+        "{#{ns}}#{name}"
+      end
+
+      # Returns the namespace and local name as elements of a tuple / 2-element array:
+      # `["namespace-uri", "local-name"]`
+      # @return [Array<String>] An array containing namespace & local name.
+      def to_a
+        [ns, name]
+      end
+
+      # Gets the {Name} object for the given namespace and local name from the name cache to minimize the number of
+      # strings + objects used.
+      # @param [String] ns Namespace URI
+      # @param [String] name Local name
+      # @return [Name]
+      def self.get(ns, name)
+        @cache ||= Hash.new do |h, k|
+          h[k] = Hash.new do |h2, k2|
+            h2[k2] = new k, k2
+          end
+        end
+
+        name = name.to_s unless name.is_a?(String)
+        @cache[ns][name]
+      end
+    end
+  end
+end