wsdl-mapper 0.0.7

data/lib/wsdl_mapper/dom_parsing/url_resolver.rb

@@ -0,0 +1,16 @@
+require 'nokogiri'
+
+require 'wsdl_mapper/dom_parsing/abstract_resolver'
+require 'uri'
+require 'open-uri'
+
+module WsdlMapper
+  module DomParsing
+    class UrlResolver < AbstractResolver
+      def resolve(url)
+        uri = URI.parse url
+        Nokogiri::XML::Document.parse uri.read
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/dom_parsing/xsd.rb

@@ -0,0 +1,47 @@
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/dom/bounds'
+
+module WsdlMapper
+  module DomParsing
+    module Xsd
+      include WsdlMapper::Dom
+
+      NS = 'http://www.w3.org/2001/XMLSchema'.freeze
+
+      IMPORT = Name.get NS, 'import'
+      SCHEMA = Name.get NS, 'schema'
+      ELEMENT = Name.get NS, 'element'
+      SEQUENCE = Name.get NS, 'sequence'
+      COMPLEX_TYPE = Name.get NS, 'complexType'
+      SIMPLE_TYPE = Name.get NS, 'simpleType'
+      ANNOTATION = Name.get NS, 'annotation'
+      DOCUMENTATION = Name.get NS, 'documentation'
+      APPINFO = Name.get NS, 'appinfo'
+      COMPLEX_CONTENT = Name.get NS, 'complexContent'
+      SIMPLE_CONTENT = Name.get NS, 'simpleContent'
+      EXTENSION = Name.get NS, 'extension'
+      RESTRICTION = Name.get NS, 'restriction'
+      ENUMERATION = Name.get NS, 'enumeration'
+      ATTRIBUTE = Name.get NS, 'attribute'
+      ANY_ATTRIBUTE = Name.get NS, 'anyAttribute'
+      CHOICE = Name.get NS, 'choice'
+      UNIQUE = Name.get NS, 'unique'
+      ALL = Name.get NS, 'all'
+      PATTERN = Name.get NS, 'pattern'
+      MIN_INCLUSIVE = Name.get NS, 'minInclusive'
+      MIN_LENGTH = Name.get NS, 'minLength'
+      MAX_INCLUSIVE = Name.get NS, 'maxInclusive'
+      MAX_LENGTH = Name.get NS, 'maxLength'
+      TOTAL_DIGITS = Name.get NS, 'totalDigits'
+      FRACTION_DIGITS = Name.get NS, 'fractionDigits'
+
+      ELEMENT_FORM_DEFAULT = 'elementFormDefault'
+      ATTRIBUTE_FORM_DEFAULT = 'attributeFormDefault'
+
+      DEFAULT_BOUNDS = {
+        SEQUENCE  => Bounds.new(min: 1, max: 1),
+        ALL       => Bounds.new(min: 0, max: 1)
+      }
+    end
+  end
+end

data/lib/wsdl_mapper/generation/abstract_formatter.rb

@@ -0,0 +1,115 @@
+module WsdlMapper
+  module Generation
+    # @abstract
+    # noinspection RubyUnusedLocalVariable
+    class AbstractFormatter
+      def initialize(io)
+        @io = io
+      end
+
+      def in_class(name)
+        raise NotImplementedError
+      end
+
+      def in_sub_class(name)
+        raise NotImplementedError
+      end
+
+      def begin_modules(names)
+        raise NotImplementedError
+      end
+
+      def end_modules(names)
+        raise NotImplementedError
+      end
+
+      def in_modules(names)
+        raise NotImplementedError
+      end
+
+      def assignment(var_name, value)
+        raise NotImplementedError
+      end
+
+      def call(name, *args)
+        raise NotImplementedError
+      end
+
+      def next_statement
+        raise NotImplementedError
+      end
+
+      def blank_line
+        raise NotImplementedError
+      end
+
+      def blank_comment
+        raise NotImplementedError
+      end
+
+      def block(statement, block_args, &block)
+        raise NotImplementedError
+      end
+
+      def block_assignment(var_name, statement, block_args, &block)
+        raise NotImplementedError
+      end
+
+      def statements(*statements)
+        raise NotImplementedError
+      end
+
+      def after_requires
+        raise NotImplementedError
+      end
+
+      def after_constants
+        raise NotImplementedError
+      end
+
+      def statement(statement)
+        raise NotImplementedError
+      end
+
+      def requires(path)
+        raise NotImplementedError
+      end
+
+      def attr_accessors(*attrs)
+        raise NotImplementedError
+      end
+
+      def begin_module(name)
+        raise NotImplementedError
+      end
+
+      def begin_class(name)
+        raise NotImplementedError
+      end
+
+      def begin_sub_class(name, super_name)
+        raise NotImplementedError
+      end
+
+      def begin_def(name, *args)
+        raise NotImplementedError
+      end
+
+      def in_def(name, *args)
+        raise NotImplementedError
+      end
+
+      def literal_array(name, values)
+        raise NotImplementedError
+      end
+
+      def assignments(*assigns)
+        raise NotImplementedError
+      end
+
+      def end
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/generation/base.rb

@@ -0,0 +1,69 @@
+require 'logging'
+
+module WsdlMapper
+  module Generation
+    # @abstract
+    class Base
+      attr_reader :logger
+      protected :logger
+
+      def initialize(context)
+        @context = context
+        @logger = Logging.logger[self]
+      end
+
+      def generate_name(name, suffix = '')
+        return 'nil' if name.nil?
+
+        ns = name.ns.inspect
+        local_name = (name.name + suffix).inspect
+
+
+        "[#{ns}, #{local_name}]"
+      end
+
+      def get_type_name(type)
+        if type.name
+          type
+        elsif type.containing_element
+          @namer.get_inline_type type.containing_element
+        elsif type.containing_property
+          @namer.get_inline_type type.containing_property
+        end
+      end
+
+      def file_for(type_name, result, &block)
+        file_name = @context.path_for type_name
+        file file_name, result, &block
+      end
+
+      def append_file_for(type_name, result, &block)
+        file_name = @context.path_for type_name
+        file file_name, result, mode: 'a', &block
+      end
+
+      # @yieldparam [WsdlMapper::Generation::AbstractFormatter]
+      def type_file_for(type_name, result, &block)
+        file_for type_name, result, &block
+        result.add_type type_name
+      end
+
+      def file(file_name, result, mode: 'w')
+        File.open file_name, mode do |io|
+          f = get_formatter io
+          yield f
+        end
+
+        result.files << file_name
+      end
+
+      def get_formatter(io)
+        @formatter_factory.new io
+      end
+
+      def get_module_names(type)
+        type.parents.reverse.map(&:module_name)
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/generation/context.rb

@@ -0,0 +1,35 @@
+module WsdlMapper
+  module Generation
+    class Context
+      # @param [String] target_path Absolute root path
+      def initialize(target_path)
+        @target_path = target_path
+      end
+
+      # Returns the absolute path for a specified `type_name`. If the directories do not exist,
+      # it will create them before returning.
+      # @param [TypeName] type_name
+      # @return [String] The full absolute file path for the specified `type_name`
+      def path_for(type_name)
+        path = path_join type_name.file_path
+        ensure_path_exists path
+
+        File.join path, type_name.file_name
+      end
+
+      # Returns an absolute path for the specified `paths`.
+      # @param [Array<String>] paths An array of paths
+      # @return [String] An absolute path as string
+      def path_join(*paths)
+        path = File.join @target_path, *paths
+
+        path
+      end
+
+      private
+      def ensure_path_exists(path)
+        FileUtils.mkpath path
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/generation/default_formatter.rb

@@ -0,0 +1,237 @@
+module WsdlMapper
+  module Generation
+    # Default implementation for the ruby formatter interface. This class should be considered as a reference for
+    # custom implementations. All public methods are mandatory.
+    class DefaultFormatter
+      def initialize(io)
+        @io = io
+        @i = 0
+      end
+
+      def next_statement
+        append "\n"
+        @blank_line = false
+        self
+      end
+
+      def blank_line
+        # Prevent double blank lines
+        append "\n" unless @blank_line
+        @blank_line = true
+        self
+      end
+
+      def blank_comment
+        statement '#'
+        @blank_line = true
+        self
+      end
+
+      def attr_readers(*attrs)
+        return if attrs.empty?
+
+        attrs = attrs.map { |a| ":#{a}" }
+        attrs.each do |attr|
+          statement "attr_reader #{attr}"
+        end
+        blank_line
+      end
+
+      alias_method :after_requires, :blank_line
+      alias_method :after_constants, :blank_line
+
+      def statement(statement)
+        indent
+        @io << statement
+        next_statement
+      end
+
+      def statements(*statements)
+        statements.each do |s|
+          statement s
+        end
+        blank_line
+      end
+
+      def call(name, *args)
+        if args.empty?
+          statement name
+        else
+          statement "#{name}(#{args * ', '})"
+        end
+      end
+
+      def block(statement, block_args)
+        indent
+        buf = statement.dup
+        buf << ' do'
+        args = block_args.join ', '
+        buf << " |#{args}|" if block_args.any?
+        @io << buf
+        next_statement
+        inc_indent
+        yield
+        self.end
+      end
+
+      def block_assignment(var_name, statement, block_args, &block)
+        block "#{var_name} = #{statement}", block_args, &block
+      end
+
+      def require(path)
+        statement "require #{path.inspect}"
+      end
+
+      def requires(*paths)
+        return unless paths.any?
+        paths.each do |path|
+          require path
+        end
+        after_requires
+      end
+
+      def attr_accessors(*attrs)
+        return if attrs.empty?
+
+        attrs = attrs.map { |a| ":#{a}" }
+        attrs.each do |attr|
+          statement "attr_accessor #{attr}"
+        end
+        blank_line
+      end
+
+      def begin_module(name)
+        statement "module #{name}"
+        inc_indent
+      end
+
+      def begin_modules(names)
+        names.each do |name|
+          begin_module name
+        end
+      end
+
+      def end_modules(names)
+        names.each { self.end }
+      end
+
+      def in_modules(names)
+        begin_modules names
+        yield
+        end_modules names
+      end
+
+      def begin_class(name)
+        statement "class #{name}"
+        inc_indent
+      end
+
+      def begin_sub_class(name, super_name)
+        statement "class #{name} < #{super_name}"
+        inc_indent
+      end
+
+      def in_class(name)
+        begin_class name
+        yield
+        self.end
+      end
+
+      def in_sub_class(name, super_name)
+        begin_sub_class name, super_name
+        yield
+        self.end
+      end
+
+      def begin_def(name, *args)
+        blank_line
+        statement method_definition(name, args)
+        inc_indent
+      end
+
+      def in_def(name, *args)
+        begin_def name, *args
+        yield
+        self.end
+      end
+
+      def literal_array(name, values)
+        if values.empty?
+          statement "#{name} = []"
+          return
+        end
+
+        statement "#{name} = ["
+        inc_indent
+        values[0..-2].each do |value|
+          statement "#{value},"
+        end
+        statement values.last
+        dec_indent
+        statement ']'
+      end
+
+      def literal_hash(name, key_values)
+        if key_values.empty?
+          statement "#{name} = {}"
+          return
+        end
+
+        statement "#{name} = {"
+        inc_indent
+        key_values[0..-2].each do |value|
+          statement "#{value},"
+        end
+        statement key_values.last
+        dec_indent
+        statement '}'
+      end
+
+      def assignment(var_name, value)
+        statement "#{var_name} = #{value}"
+      end
+
+      def assignments(*assigns)
+        assigns.each do |(var_name, value)|
+          assignment var_name, value
+        end
+        blank_line
+      end
+
+      def end
+        dec_indent
+        if @blank_line
+          @io.seek -1, IO::SEEK_CUR
+        end
+        statement 'end'
+      end
+
+      private
+      def method_definition(name, args)
+        s = "def #{name}"
+        s << "(#{args * ', '})" unless args.empty?
+        s
+      end
+
+      def append(str)
+        @io << str
+        self
+      end
+
+      def indent
+        @io << '  ' * @i
+        self
+      end
+
+      def inc_indent(n = 1)
+        @i += n
+        self
+      end
+
+      def dec_indent(n = 1)
+        @i -= n
+        self
+      end
+    end
+  end
+end