wsdl-mapper 0.0.7

data/lib/wsdl_mapper/dom_generation/documented_enum_generator.rb

@@ -0,0 +1,30 @@
+require 'wsdl_mapper/dom_generation/default_enum_generator'
+require 'wsdl_mapper/generation/yard_doc_formatter'
+
+module WsdlMapper
+  module DomGeneration
+    class DocumentedEnumGenerator < DefaultEnumGenerator
+
+      protected
+      def generate_constant_assignments(f, values_to_generate)
+        yard = WsdlMapper::Generation::YardDocFormatter.new f
+        values_to_generate.each do |vtg|
+          if vtg.type.documentation.present?
+            yard.text vtg.type.documentation.default
+            yard.blank_line
+          end
+          yard.tag 'xml_value', vtg.type.value
+          f.statement value_constant_assignment vtg
+          f.blank_line
+        end
+        f.after_constants
+      end
+
+      def in_class(f, ttg)
+        yard = WsdlMapper::Generation::YardDocFormatter.new f
+        yard.class_doc ttg.type
+        super
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_generation/documented_schema_generator.rb

@@ -0,0 +1,51 @@
+require 'wsdl_mapper/dom_generation/schema_generator'
+require 'wsdl_mapper/dom_generation/documented_wrapping_type_generator'
+require 'wsdl_mapper/dom_generation/documented_class_generator'
+require 'wsdl_mapper/dom_generation/documented_ctr_generator'
+require 'wsdl_mapper/dom_generation/documented_enum_generator'
+
+module WsdlMapper
+  module DomGeneration
+    class DocumentedSchemaGenerator < SchemaGenerator
+
+      def initialize(context,
+        skip_modules: false,
+        formatter_factory: DefaultFormatter,
+        namer: WsdlMapper::Naming::DefaultNamer.new,
+        class_generator_factory: DocumentedClassGenerator,
+        module_generator_factory: DefaultModuleGenerator,
+        ctr_generator_factory: DocumentedCtrGenerator,
+        enum_generator_factory: DocumentedEnumGenerator,
+        value_defaults_generator_factory: DefaultValueDefaultsGenerator,
+        wrapping_type_generator_factory: DocumentedWrappingTypeGenerator,
+        type_mapping: WsdlMapper::TypeMapping::DEFAULT,
+        value_generator: DefaultValueGenerator.new)
+
+        super
+      end
+
+      def generate(schema)
+        result = super
+
+        generate_yard_opts
+
+        result
+      end
+
+      protected
+      def generate_yard_opts
+        file_name = @context.path_join '.yardopts'
+
+        File.write file_name, <<SH
+--tag xml_name:"XML Name"
+--tag xml_namespace:"XML Namespace"
+--tag xml_value:"XML Value"
+--tag soap_name:"SOAP Name"
+--markup markdown
+--markup-provider kramdown
+**/*.rb
+SH
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_generation/documented_wrapping_type_generator.rb

@@ -0,0 +1,17 @@
+require 'wsdl_mapper/dom_generation/default_wrapping_type_generator'
+require 'wsdl_mapper/generation/yard_doc_formatter'
+
+module WsdlMapper
+  module DomGeneration
+    class DocumentedWrappingTypeGenerator < DefaultWrappingTypeGenerator
+
+      protected
+      def in_class(f, ttg)
+        yard = WsdlMapper::Generation::YardDocFormatter.new f
+        yard.class_doc ttg.type
+
+        super
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_generation/facade.rb

@@ -0,0 +1,18 @@
+require 'wsdl_mapper/dom_generation/schema_generator'
+require 'wsdl_mapper/dom_generation/documented_schema_generator'
+require 'wsdl_mapper/generation/facade'
+require 'wsdl_mapper/dom_generation/default_ctr_generator'
+
+module WsdlMapper
+  module DomGeneration
+    class Facade < WsdlMapper::Generation::Facade
+      def generator_class
+        @generator_class ||= @docs ? DocumentedSchemaGenerator : SchemaGenerator
+      end
+
+      def generator
+        @generator ||= generator_class.new context, namer: namer, ctr_generator_factory: WsdlMapper::DomGeneration::DefaultCtrGenerator
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_generation/generator_base.rb

@@ -0,0 +1,66 @@
+require 'wsdl_mapper/generation/base'
+
+module WsdlMapper
+  module DomGeneration
+    # @abstract
+    class GeneratorBase < WsdlMapper::Generation::Base
+      def initialize(generator)
+        @generator = generator
+
+        super(generator.context)
+      end
+
+      protected
+      def get_formatter(io)
+        @generator.get_formatter io
+      end
+
+      def add_prop_require(requires, prop, schema)
+        if prop.type_name
+          add_type_require requires, prop.type_name, schema
+        elsif prop.type
+          name = @generator.namer.get_type_name @generator.namer.get_inline_type prop
+          requires << name.require_path
+        end
+      end
+
+      def add_type_require(requires, type_name, schema)
+        if WsdlMapper::Dom::BuiltinType.builtin? type_name
+          @generator.type_mapping.requires(type_name).each do |req|
+            requires << req
+          end
+        elsif WsdlMapper::Dom::SoapEncodingType.builtin? type_name
+          # ignore
+        else
+          type = schema.get_type type_name
+          begin
+            name = @generator.namer.get_type_name type
+          rescue => e
+            raise e
+          end
+          requires << name.require_path
+        end
+      end
+
+      def add_base_require(requires, type, schema)
+        if type.base_type_name && @generator.get_ruby_type_name(type.base)
+          add_type_require requires, type.base_type_name, schema
+        end
+      end
+
+      def write_requires(f, requires)
+        f.requires(*requires)
+      end
+
+      def close_modules(f, modules)
+        modules.each { f.end }
+      end
+
+      def open_modules(f, modules)
+        modules.each do |mod|
+          f.begin_module mod.module_name
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_generation/null_ctr_generator.rb

@@ -0,0 +1,20 @@
+module WsdlMapper
+  module DomGeneration
+    # noinspection RubyUnusedLocalVariable
+    class NullCtrGenerator
+      def initialize(generator)
+        @generator = generator
+      end
+
+      def generate(ttg, f, result)
+      end
+
+      def generate_simple(ttg, f, result)
+      end
+
+      def generate_wrapping(ttg, f, result, var_name, par_name)
+      end
+    end
+  end
+end
+

data/lib/wsdl_mapper/dom_generation/schema_generator.rb

@@ -0,0 +1,134 @@
+require 'wsdl_mapper/naming/default_namer'
+
+require 'wsdl_mapper/generation/result'
+require 'wsdl_mapper/generation/default_formatter'
+require 'wsdl_mapper/generation/default_module_generator'
+require 'wsdl_mapper/dom_generation/default_class_generator'
+require 'wsdl_mapper/dom_generation/null_ctr_generator'
+require 'wsdl_mapper/dom_generation/default_value_defaults_generator'
+require 'wsdl_mapper/dom_generation/default_enum_generator'
+require 'wsdl_mapper/dom_generation/default_wrapping_type_generator'
+require 'wsdl_mapper/dom_generation/default_value_generator'
+require 'wsdl_mapper/generation/type_to_generate'
+require 'wsdl_mapper/generation/base'
+
+require 'wsdl_mapper/dom/complex_type'
+require 'wsdl_mapper/dom/simple_type'
+
+require 'wsdl_mapper/type_mapping'
+
+module WsdlMapper
+  module DomGeneration
+    class SchemaGenerator < WsdlMapper::Generation::Base
+      include WsdlMapper::Generation
+
+      attr_reader :context, :namer
+
+      attr_reader :class_generator, :module_generator, :ctr_generator, :enum_generator, :type_mapping, :value_defaults_generator, :value_generator, :wrapping_type_generator
+
+      def initialize(context,
+        skip_modules: false,
+        formatter_factory: DefaultFormatter,
+        namer: WsdlMapper::Naming::DefaultNamer.new,
+        class_generator_factory: DefaultClassGenerator,
+        module_generator_factory: DefaultModuleGenerator,
+        ctr_generator_factory: NullCtrGenerator,
+        enum_generator_factory: DefaultEnumGenerator,
+        value_defaults_generator_factory: DefaultValueDefaultsGenerator,
+        wrapping_type_generator_factory: DefaultWrappingTypeGenerator,
+        type_mapping: WsdlMapper::TypeMapping::DEFAULT,
+        value_generator: DefaultValueGenerator.new)
+
+        super(context)
+
+        @formatter_factory = formatter_factory
+        @namer = namer
+        @class_generator = class_generator_factory.new self
+        @module_generator = module_generator_factory.new self
+        @ctr_generator = ctr_generator_factory.new self
+        @enum_generator = enum_generator_factory.new self
+        @value_defaults_generator = value_defaults_generator_factory.new self
+        @wrapping_type_generator = wrapping_type_generator_factory.new self
+        @type_mapping = type_mapping
+        @value_generator = value_generator
+        @skip_modules = skip_modules
+      end
+
+      def generate(schema)
+        result = Result.new schema: schema
+
+        generate_complex_types schema, result
+        generate_enumerations schema, result
+        generate_restrictions schema, result
+
+        unless @skip_modules
+          result.module_tree.each do |module_node|
+            @module_generator.generate module_node, result
+          end
+        end
+
+        result
+      end
+
+      def get_formatter(io)
+        @formatter_factory.new io
+      end
+
+      def get_ruby_type_name(type)
+        if type.name.nil?
+          type = get_type_name type
+        end
+
+        if WsdlMapper::Dom::BuiltinType.builtin? type.name
+          type_mapping.ruby_type type.name
+        elsif WsdlMapper::Dom::SoapEncodingType.builtin? type.name
+          '::Array'
+        else
+          namer.get_type_name(type).name
+        end
+      end
+
+      def generate_restrictions(schema, result)
+        types = schema.each_type.select(&WsdlMapper::Dom::SimpleType).reject(&:enumeration?).to_a
+
+        types_to_generate = types.map do |type|
+          name = namer.get_type_name get_type_name(type)
+
+          TypeToGenerate.new type, name
+        end
+
+        types_to_generate.each do |ttg|
+          @wrapping_type_generator.generate ttg, result
+        end
+      end
+
+      def generate_enumerations(schema, result)
+        enum_types = schema.each_type.select(&WsdlMapper::Dom::SimpleType).select(&:enumeration?).to_a
+
+        types_to_generate = enum_types.map do |type|
+          name = namer.get_type_name get_type_name(type)
+
+          TypeToGenerate.new type, name
+        end
+
+        types_to_generate.each do |ttg|
+          @enum_generator.generate ttg, result
+        end
+      end
+
+      def generate_complex_types(schema, result)
+        complex_types = schema.each_type.select(&WsdlMapper::Dom::ComplexType).to_a
+
+        types_to_generate = complex_types.map do |type|
+          name = namer.get_type_name get_type_name(type)
+
+          TypeToGenerate.new type, name
+        end
+
+        types_to_generate.each do |ttg|
+          @class_generator.generate ttg, result
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/abstract_resolver.rb

@@ -0,0 +1,10 @@
+module WsdlMapper
+  module DomParsing
+    # @abstract
+    class AbstractResolver
+      def resolve(name)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/annotation_parser.rb

@@ -0,0 +1,25 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+
+module WsdlMapper
+  module DomParsing
+    class AnnotationParser < ParserBase
+      def parse(node)
+        return Documentation.new(nil) unless node
+
+        doc_node = find_node node, DOCUMENTATION
+        text = doc_node && doc_node.text
+
+        doc = Documentation.new text
+        doc.app_info = parse_app_info node
+
+        doc
+      end
+
+      def parse_app_info(node)
+        app_info_node = find_node node, APPINFO
+
+        app_info_node && app_info_node.children.to_s
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/attribute_parser.rb

@@ -0,0 +1,47 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+require 'wsdl_mapper/dom/attribute'
+
+module WsdlMapper
+  module DomParsing
+    class AttributeParser < ParserBase
+      # @param [Nokogiri::XML::Node] node
+      def parse(node)
+        parse_attribute node, @base.schema
+      end
+
+      def parse_attribute(node, container)
+        name = parse_name_in_attribute 'name', node
+        ref = parse_name_in_attribute 'ref', node
+
+        attr = if name
+          type_name = parse_name_in_attribute 'type', node
+
+          Attribute.new name, type_name,
+            default: fetch_attribute_value('default', node),
+            use: fetch_attribute_value('use', node, 'optional'),
+            fixed: fetch_attribute_value('fixed', node),
+            form: fetch_attribute_value('form', node)
+        elsif ref
+          Attribute::Ref.new ref
+        else
+          log_msg node, :invalid_attribute
+        end
+
+        container.add_attribute attr
+
+        each_element node do |child|
+          case get_name child
+          when ANNOTATION
+            parse_annotation child, attr
+          when SIMPLE_TYPE
+            # TODO: test
+            attr.type = @base.parsers[SIMPLE_TYPE].parse child
+            attr.type.containing_property = attr
+          else
+            log_msg child, :unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/complex_type_parser.rb

@@ -0,0 +1,213 @@
+require 'wsdl_mapper/dom_parsing/parser_base'
+require 'wsdl_mapper/dom/complex_type'
+require 'wsdl_mapper/dom/property'
+require 'wsdl_mapper/dom/attribute'
+require 'wsdl_mapper/dom/soap_encoding_type'
+require 'wsdl_mapper/svc_desc_parsing/wsdl11'
+
+module WsdlMapper
+  module DomParsing
+    class ComplexTypeParser < ParserBase
+
+      def parse(node)
+        name = parse_name_in_attribute 'name', node
+
+        type = ComplexType.new name
+
+        each_element node do |child|
+          parse_complex_type_child child, type
+        end
+
+        @base.schema.add_type type
+      end
+
+      def parse_complex_type_child(node, type)
+        case get_name node
+        when SEQUENCE
+          parse_complex_type_sequence node, type
+        when CHOICE
+          parse_complex_type_choice node, type
+        when ALL
+          parse_complex_type_all node, type
+        when COMPLEX_CONTENT
+          parse_complex_content node, type
+        when SIMPLE_CONTENT
+          parse_simple_content node, type
+        when ANNOTATION
+          parse_annotation node, type
+        when ATTRIBUTE
+          parse_attribute node, type
+        when ANY_ATTRIBUTE
+          # ignore
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_complex_type_choice(node, type)
+        # TODO: test
+        each_element node do |child|
+          case get_name child
+          when SEQUENCE
+            # Just include all sequences. Setting the appropriate properties to nil
+            # to fulfill the choice requirements is the users responsibility.
+            # Known issue: Sequence of generated elements can not be guaranteed, if the
+            # same elements occur in different choices with different ordering.
+            parse_complex_type_sequence child, type
+          when ALL
+            parse_complex_type_all child, type
+          when ELEMENT
+            parse_complex_type_property child, type, 0, ALL
+          else
+            log_msg child, :unknown
+          end
+        end
+      end
+
+      def parse_attribute(node, type)
+        @base.parsers[ATTRIBUTE].parse_attribute node, type
+      end
+
+      def parse_complex_type_all(node, type)
+        each_element node do |child|
+          parse_complex_type_property child, type, -1, ALL
+        end
+      end
+
+      def parse_simple_content(node, type)
+        type.simple_content = true
+        each_element node do |child|
+          case get_name child
+          when EXTENSION
+            parse_extension child, type
+          else
+            log_msg node, :unknown
+          end
+        end
+      end
+
+      def parse_complex_content(node, type)
+        child = first_element node
+
+        case get_name child
+        when EXTENSION
+          parse_extension child, type
+        when ANNOTATION
+        when RESTRICTION
+          parse_complex_content_restriction child, type
+        else
+          log_msg child, :unknown
+        end
+      end
+
+      def parse_complex_content_restriction(node, type)
+        parse_base node, type
+
+        case type.base_type_name
+        when SoapEncodingType['Array'].name
+          parse_soap_array node, type
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_soap_array(node, type)
+        type.soap_array = true
+        each_element node do |child|
+          case get_name child
+          when ATTRIBUTE
+            parse_soap_array_attribute child, type
+          else
+            log_msg child, :unknown
+          end
+        end
+      end
+
+      def parse_soap_array_attribute(node, type)
+        ref = parse_name_in_attribute 'ref', node
+
+        if ref != SoapEncodingType['arrayType'].name
+          raise StandardError.new("Invalid ref attribute for SOAP array node: #{ref}")
+        end
+
+        type_name = parse_name node.attribute_with_ns(WsdlMapper::SvcDescParsing::Wsdl11::ARRAY_TYPE.name, WsdlMapper::SvcDescParsing::Wsdl11::ARRAY_TYPE.ns).value, node
+        type.soap_array_type_name = Name.get type_name.ns, type_name.name[0..-3]
+      end
+
+      def parse_extension(node, type)
+        parse_base node, type
+
+        each_element node do |child|
+          case get_name child
+          when SEQUENCE
+            parse_extension_sequence child, type
+          when ATTRIBUTE
+            parse_attribute child, type
+          else
+            log_msg child, :unknown
+          end
+        end
+      end
+
+      def parse_extension_sequence(node, type)
+        parse_complex_type_sequence node, type
+      end
+
+      def parse_complex_type_sequence(node, type)
+        i = 0
+
+        each_element node do |elm|
+          next unless name_matches? elm, ELEMENT
+
+          parse_complex_type_property elm, type, i, SEQUENCE
+          i += 1
+        end
+      end
+
+      def parse_complex_type_property(node, type, i, container)
+        name = parse_name_in_attribute 'name', node
+        type_name = parse_name_in_attribute 'type', node
+        ref = parse_name_in_attribute 'ref', node
+
+        bounds = parse_bounds node, container
+
+        options = {
+          sequence: i,
+          bounds: bounds,
+          default: fetch_attribute_value('default', node),
+          fixed: fetch_attribute_value('fixed', node),
+          form: fetch_attribute_value('form', node)
+        }
+
+        prop = if ref
+          Property::Ref.new ref, **options
+        else
+          Property.new name, type_name, **options
+        end
+
+        type.add_property prop
+
+        each_element node do |child|
+          parse_property_child child, prop
+        end
+      end
+
+      def parse_property_child(child, prop)
+        case get_name child
+        when ANNOTATION
+          parse_annotation child, prop
+        when COMPLEX_TYPE
+          prop.type = parse child
+          prop.type.containing_property = prop
+        when SIMPLE_TYPE
+          prop.type = @base.parsers[SIMPLE_TYPE].parse child
+          prop.type.containing_property = prop
+        when UNIQUE
+          # ignore
+        else
+          log_msg child, :unknown
+        end
+      end
+    end
+  end
+end