wsdl-mapper 0.0.7

data/lib/wsdl_mapper/dom_parsing/default_resolver.rb

@@ -0,0 +1,30 @@
+require 'wsdl_mapper/dom_parsing/abstract_resolver'
+
+require 'wsdl_mapper/dom_parsing/local_file_resolver'
+require 'wsdl_mapper/dom_parsing/url_resolver'
+
+module WsdlMapper
+  module DomParsing
+    class DefaultResolver < AbstractResolver
+
+      def initialize(path)
+        @file_resolver = LocalFileResolver.new path
+        @url_resolver = UrlResolver.new
+      end
+
+      def resolve(name)
+        if url? name
+          @url_resolver.resolve name
+        else
+          # TODO: absolute paths?
+          @file_resolver.resolve name
+        end
+      end
+
+      protected
+      def url?(name)
+        name =~ /^https?\:\/\//
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/element_parser.rb

@@ -0,0 +1,43 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+require 'wsdl_mapper/dom/element'
+
+module WsdlMapper
+  module DomParsing
+    class ElementParser < ParserBase
+      # @param [Nokogiri::XML::Node] node
+      def parse(node)
+        name = parse_name_in_attribute 'name', node
+
+        element = Element.new name
+
+        element.type_name = parse_name_in_attribute 'type', node
+
+        each_element node do |child|
+          parse_element_child child, element
+        end
+
+        @base.schema.add_element element
+      end
+
+      protected
+      # @param [Nokogiri::XML::Node] node
+      # @param [WsdlMapper::Dom::Element] element
+      def parse_element_child(node, element)
+        case get_name node
+        when ANNOTATION
+          parse_annotation node, element
+        when COMPLEX_TYPE
+          element.type = @base.parsers[COMPLEX_TYPE].parse node
+          element.type.containing_element = element
+        when SIMPLE_TYPE
+          element.type = @base.parsers[SIMPLE_TYPE].parse node
+          element.type.containing_element = element
+        when UNIQUE
+          # ignore
+        else
+          log_msg node, :unknown
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/import_parser.rb

@@ -0,0 +1,31 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+require 'wsdl_mapper/dom/soap_encoding_type'
+
+module WsdlMapper
+  module DomParsing
+    class ImportParser < ParserBase
+      def parse(node)
+        # TODO: namespace attribute is optional
+        case node.attributes['namespace'].value
+        when SoapEncodingType::NAMESPACE, BuiltinType::NAMESPACE
+          # ignore
+        else
+          import_schema node
+        end
+      end
+
+      def import_schema(node)
+        ns = fetch_attribute_value 'namespace', node
+        location = fetch_attribute_value 'schemaLocation', node
+
+        if location.nil?
+          @base.schema.unresolved_imports << ns
+        else
+          doc = @base.import_resolver.resolve location
+          schema = @base.dup.parse doc
+          @base.schema.add_import ns, schema
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/linker.rb

@@ -0,0 +1,108 @@
+require 'wsdl_mapper/parsing/logging'
+
+module WsdlMapper
+  module DomParsing
+    class Linker
+      include WsdlMapper::Parsing::Logging
+
+      def initialize(schema)
+        @schema = schema
+        @log_msgs = []
+      end
+
+      def link
+        link_base_types
+        link_soap_array_types
+        link_property_types
+        link_attribute_types
+        link_element_types
+
+        @schema
+      end
+
+      private
+      def link_element_types
+        @schema.each_element do |element|
+          if element.type_name
+            element.type = @schema.get_type element.type_name
+
+            unless element.type
+              log_msg element.type, :missing_element_type
+            end
+          end
+        end
+      end
+
+      def link_property_types
+        @schema.each_type do |type|
+          next unless type.is_a? WsdlMapper::Dom::ComplexType
+
+          type.each_property do |prop|
+            if prop.is_a?(WsdlMapper::Dom::Property::Ref)
+              element = @schema.get_element prop.name
+              p = WsdlMapper::Dom::Property.new element.name, element.type_name,
+                sequence: prop.sequence,
+                bounds: prop.bounds,
+                fixed: prop.fixed,
+                form: prop.form,
+                default: prop.default
+              if p.type_name
+                p.type = @schema.get_type p.type_name
+              else
+                p.type = element.type
+              end
+              type.add_property p
+            elsif prop.type_name
+              prop.type = @schema.get_type prop.type_name
+
+              unless prop.type
+                log_msg prop, :missing_property_type
+              end
+            end
+          end
+        end
+      end
+
+      def link_attribute_types
+        @schema.each_type do |type|
+          next unless type.is_a? WsdlMapper::Dom::ComplexType
+
+          type.each_attribute do |attr|
+            if attr.is_a?(WsdlMapper::Dom::Attribute::Ref)
+              type.add_attribute @schema.get_attribute attr.name
+            elsif attr.type_name
+              attr.type = @schema.get_type attr.type_name
+
+              unless attr.type
+                log_msg attr, :missing_attribute_type
+              end
+            end
+          end
+        end
+      end
+
+      def link_base_types
+        @schema.each_type do |type|
+          next unless type.base_type_name
+
+          type.base = @schema.get_type type.base_type_name
+          unless type.base
+            log_msg type, :missing_base_type
+          end
+        end
+      end
+
+      def link_soap_array_types
+        @schema.each_type do |type|
+          next unless type.is_a? WsdlMapper::Dom::ComplexType
+          next unless type.soap_array?
+
+          type.soap_array_type = @schema.get_type type.soap_array_type_name
+          unless type.soap_array_type
+            log_msg type, :missing_soap_array_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/local_file_resolver.rb

@@ -0,0 +1,19 @@
+require 'nokogiri'
+
+require 'wsdl_mapper/dom_parsing/abstract_resolver'
+
+module WsdlMapper
+  module DomParsing
+    class LocalFileResolver < AbstractResolver
+      def initialize(path)
+        @path = path
+      end
+
+      def resolve(name)
+        path = File.join @path, name
+
+        Nokogiri::XML::Document.parse File.read(path)
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/parser.rb

@@ -0,0 +1,127 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+
+require 'wsdl_mapper/dom_parsing/xsd'
+require 'wsdl_mapper/dom_parsing/complex_type_parser'
+require 'wsdl_mapper/dom_parsing/simple_type_parser'
+require 'wsdl_mapper/dom_parsing/annotation_parser'
+require 'wsdl_mapper/dom_parsing/import_parser'
+require 'wsdl_mapper/dom_parsing/element_parser'
+require 'wsdl_mapper/dom_parsing/attribute_parser'
+
+require 'wsdl_mapper/dom/schema'
+require 'wsdl_mapper/dom/namespaces'
+require 'wsdl_mapper/dom_parsing/linker'
+
+module WsdlMapper
+  module DomParsing
+    class Parser < ParserBase
+      include WsdlMapper::DomParsing::Xsd
+
+      class ParserException < StandardError ; end
+      class InvalidRootException < ParserException ; end
+      class InvalidNsException < ParserException ; end
+
+      attr_reader :schema, :parsers, :namespaces, :target_namespace, :default_namespace, :log_msgs, :import_resolver
+
+      # @param [WsdlMapper::DomParsing::AbstractResolver] import_resolver
+      def initialize(import_resolver: nil)
+        @base = self
+        @schema = WsdlMapper::Dom::Schema.new
+
+        @parsers = {
+          COMPLEX_TYPE => ComplexTypeParser.new(self),
+          ANNOTATION => AnnotationParser.new(self),
+          SIMPLE_TYPE => SimpleTypeParser.new(self),
+          IMPORT => ImportParser.new(self),
+          ELEMENT => ElementParser.new(self),
+          ATTRIBUTE => AttributeParser.new(self)
+        }
+
+        @import_resolver = import_resolver
+        @namespaces = Namespaces.new
+        @target_namespace = nil
+        @default_namespace = nil
+        @linker = Linker.new schema
+      end
+
+      # @param [Nokogiri::XML::Document] doc
+      # @return [WsdlMapper::Dom::Schema]
+      def parse(doc, parse_only: false)
+        # Phase 1: Parsing
+        parse_doc doc
+
+        # Phase 2: Linking
+        unless parse_only
+          @linker.link
+        end
+
+        collect_logs
+
+        @schema
+      end
+
+      # @return [WsdlMapper::DomParsing::Parser]
+      def dup
+        self.class.new import_resolver: @import_resolver
+      end
+
+      protected
+      def collect_logs
+        @log_msgs ||= []
+        @parsers.values.each do |parser|
+          @log_msgs += parser.log_msgs
+        end
+        @log_msgs += @linker.log_msgs
+      end
+
+      # @param [Nokogiri::XML::Document] doc
+      def parse_doc(doc)
+        parse_namespaces doc
+        schema_node = get_schema_node doc
+        parse_attributes schema_node
+        each_element schema_node do |node|
+          parse_node node
+        end
+      end
+
+      # @param [Nokogiri::XML::Node] schema_node
+      def parse_attributes(schema_node)
+        @schema.target_namespace = parse_target_namespace schema_node
+        parse_element_form_default schema_node
+        parse_attribute_form_default schema_node
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      def parse_attribute_form_default(node)
+        attr = node.attributes[ATTRIBUTE_FORM_DEFAULT]
+        if attr && attr.value == 'qualified'
+          @schema.qualified_attributes = true
+        end
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      def parse_element_form_default(node)
+        attr = node.attributes[ELEMENT_FORM_DEFAULT]
+        if attr && attr.value == 'qualified'
+          @schema.qualified_elements = true
+        end
+      end
+
+      # @param [Nokogiri::XML::Document] doc
+      def get_schema_node(doc)
+        return doc if is_element?(doc) && get_name(doc) == SCHEMA
+        schema_node = first_element doc
+
+        if schema_node.namespace.nil? || schema_node.namespace.href != NS
+          raise InvalidNsException
+        end
+
+        unless name_matches? schema_node, SCHEMA
+          raise InvalidRootException
+        end
+
+        schema_node
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/parser_base.rb

@@ -0,0 +1,41 @@
+require 'wsdl_mapper/dom_parsing/xsd'
+require 'wsdl_mapper/dom/documentation'
+require 'wsdl_mapper/dom/bounds'
+require 'wsdl_mapper/parsing/base'
+
+module WsdlMapper
+  module DomParsing
+    class ParserBase < WsdlMapper::Parsing::Base
+      include Xsd
+
+      protected
+      def parse_base(node, type)
+        type.base_type_name = parse_name_in_attribute 'base', node
+      end
+
+      def parse_annotation(node, type)
+        type.documentation = @base.parsers[ANNOTATION].parse node
+      end
+
+      def parse_bounds(node, container)
+        bounds = DEFAULT_BOUNDS[container].dup
+
+        if bounds.nil?
+          raise ArgumentError.new("Unknown container #{container}")
+        end
+
+        if node.attributes.has_key? 'minOccurs'
+          bounds.min = node.attributes['minOccurs'].value.to_i
+        end
+
+        if node.attributes.has_key? 'maxOccurs'
+          max = node.attributes['maxOccurs'].value
+          bounds.max = max == 'unbounded' ? nil : max.to_i
+        end
+
+        bounds
+      end
+    end
+  end
+end
+

data/lib/wsdl_mapper/dom_parsing/simple_type_parser.rb

@@ -0,0 +1,99 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+require 'wsdl_mapper/dom/simple_type'
+
+module WsdlMapper
+  module DomParsing
+    class SimpleTypeParser < ParserBase
+
+      def parse(node)
+        name = parse_name_in_attribute 'name', node
+
+        type = SimpleType.new name
+
+        each_element node do |child|
+          parse_simple_type_child child, type
+        end
+
+        @base.schema.add_type type
+      end
+
+      protected
+      def parse_simple_type_child(node, type)
+        case get_name node
+        when RESTRICTION
+          parse_simple_type_restriction node, type
+        when ANNOTATION
+          parse_annotation node, type
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_simple_type_restriction(node, type)
+        # TODO: test
+        parse_base node, type
+
+        each_element node do |child|
+          case get_name(child)
+          when ENUMERATION
+            parse_simple_type_enumeration child, type
+          when PATTERN
+            parse_simple_type_pattern child, type
+          when MIN_INCLUSIVE
+            parse_simple_type_min child, type, true
+          when MAX_INCLUSIVE
+            parse_simple_type_max child, type, true
+          when MIN_LENGTH
+            parse_simple_type_min child, type, false
+          when MAX_LENGTH
+            parse_simple_type_max child, type, false
+          when TOTAL_DIGITS
+            parse_simple_type_total_digits child, type
+          when FRACTION_DIGITS
+            parse_simple_type_fraction_digits child, type
+          else
+            log_msg child, :unknown
+          end
+        end
+      end
+
+      def parse_simple_type_fraction_digits(node, type)
+        type.fraction_digits = fetch_attribute_value 'value', node
+      end
+
+      def parse_simple_type_total_digits(node, type)
+        type.total_digits = fetch_attribute_value 'value', node
+      end
+
+      def parse_simple_type_pattern(node, type)
+        type.pattern = fetch_attribute_value 'value', node
+      end
+
+      def parse_simple_type_min(node, type, inclusive)
+        type.min = fetch_attribute_value 'value', node
+        type.min_inclusive = inclusive
+      end
+
+      def parse_simple_type_max(node, type, inclusive)
+        type.max = fetch_attribute_value 'value', node
+        type.max_inclusive = inclusive
+      end
+
+      def parse_simple_type_enumeration(node, type)
+        value = node.attributes['value'].value
+
+        enum_value = EnumerationValue.new value
+        type.enumeration_values << enum_value
+
+        each_element node do |child|
+          case get_name(child)
+          when ANNOTATION
+            parse_annotation child, enum_value
+          else
+            log_msg node, :unknown
+          end
+        end
+      end
+    end
+  end
+end