scaffold_parser 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a86da6f57bcf43be3e59f2a47531005113ada9ff
-  data.tar.gz: e29b1f9dbea6e921666a001bc51c9213db18e15d
+  metadata.gz: 5f042c0e917538cbf64c26da83731d871a9b024d
+  data.tar.gz: 74d9920de765dab0b8daa84774a740f8f9e0c4d7
 SHA512:
-  metadata.gz: 664fc7cc63285c13ba2b620bc13224f9752a1887ed33c1ac6ee7e20984aecee83b0fdf7b6f21a948b00162e7b47e7931f935f841accb529ed4c8057dcb33480f
-  data.tar.gz: 0d469c89f076255eefad50e3290ab8dc1b59cf11976f7ff25418e1957fda6a1306d3480e355fba259dab6a43b04e255a034d804af9a683b0e18b2376fb1fcba5
+  metadata.gz: 50d8898fce80d67adb3451646ac39e9ba46dcb669a36803e0d1550dc1f43a100443a290dfef9d8870cdb658bb190f60139b5559f7b2928cfd4b8914710662c0e
+  data.tar.gz: e753b2f92964c5efd0d566312f8599f24bb9a3475bef511267b9d45f99d3b0d0c131f0617dd9f7942fecf93dcdf9994b5a06c1120714a95b08908641e8399573

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/all.rb

@@ -10,13 +10,13 @@ module ScaffoldParser
               @elements = [*elements]
             end
 
-            def group(new_source)
-              STACK.push Module.new("Groups::#{new_source.name.camelize}", elements)
+            def group(source)
+              STACK.push Module.new(source, elements)
             end
 
             def complex_type(source)
               if source.has_name?
-                STACK.push Klass.new(source.name, elements)
+                STACK.push Klass.new(source, elements)
               end
 
               ComplexType.new elements

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/at_method.rb

@@ -8,15 +8,19 @@ module ScaffoldParser
             include Utils
 
             def method_body
-              "at '#{source.name}'"
+              "at '#{at}'"
+            end
+
+            def at
+              [source.xmlns_prefix, "#{source.name}"].compact.join(':')
             end
 
             def to_h_with_attrs_method
-              "hash[:#{method_name}] = #{method_name} if has? '#{source.name}'"
+              "hash[:#{method_name}] = #{method_name} if has? '#{at}'"
             end
 
             def to_builder
-              "root << build_element('#{source.name}', data[:#{source.name.underscore}]) if data.key? :#{source.name.underscore}"
+              "root << build_element('#{at}', data[:#{method_name}]) if data.key? :#{method_name}"
             end
 
             def sequence(_)

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/base_method.rb

@@ -11,7 +11,12 @@ module ScaffoldParser
             end
 
             def method_name
-              source.name.underscore
+              if source.name
+                source.name.underscore
+              elsif source.ref
+                prefix, name = source.ref.split(':')
+                name.underscore
+              end
             end
 
             def to_s

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/blank.rb

@@ -11,22 +11,24 @@ module ScaffoldParser
             def element(source)
               if source.multiple?
                 if elements.any?
-                  new_class = STACK.push Klass.new(source.name, elements)
+                  new_class = STACK.push Klass.new(source, elements)
 
                   ListMethod.new(source) do |template|
                     template.item_class = new_class.name.classify
                   end
                 else
                   ListMethod.new(source) do |template|
-                    template.item_class = source.has_custom_type? ? source&.type&.classify : 'String'
+                    template.item_class = source.has_custom_type? ? source.type.split(':').map(&:classify).join('::') : 'String'
                   end
                 end
               elsif source.has_custom_type?
                 SubmodelMethod.new(source)
+              elsif source.has_ref?
+                ElementRef.new(source)
               else
                 if elements.any?
-                  new_class = STACK.push Klass.new(source.name, elements)
-                  SubmodelMethod.new(source, new_class.name.camelize)
+                  new_class = STACK.push Klass.new(source, elements)
+                  SubmodelMethod.new(source, new_class.name_with_prefix)
                 else
                   AtMethod.new(source)
                 end
@@ -35,7 +37,7 @@ module ScaffoldParser
 
             def complex_type(source)
               if source.has_name?
-                STACK.push Klass.new(source.name)
+                STACK.push Klass.new(source)
               else
                 ComplexType.new
               end
@@ -47,7 +49,6 @@ module ScaffoldParser
               else # basic xsd extension
                 self
               end
-
             end
 
             def include(_)
@@ -63,7 +64,7 @@ module ScaffoldParser
             end
 
             def group(source)
-              ModuleInclude.new(source.ref)
+              ModuleInclude.new(source)
             end
           end
         end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/choice.rb

@@ -4,6 +4,8 @@ module ScaffoldParser
       class Parser
         module Handlers
           class Choice
+            include OrderElements
+
             attr_accessor :elements
 
             def initialize(elements = [])
@@ -12,23 +14,14 @@ module ScaffoldParser
 
             def complex_type(source)
               if source.has_name?
-                STACK.push Klass.new(source.name, elements)
+                STACK.push Klass.new(source, elements)
               else
                 ComplexType.new(elements)
               end
             end
 
-            def sequence(_)
-              flattened = elements.flat_map do |element|
-                case element
-                when Sequence, Choice, All
-                  then element.elements
-                else
-                  element
-                end
-              end
-
-              Sequence.new flattened
+            def extension(source)
+              Extension.new elements, source.attributes
             end
           end
         end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/complex_type.rb

@@ -17,22 +17,22 @@ module ScaffoldParser
             def element(source)
               if source.multiple?
                 if elements.any?
-                  new_class = STACK.push Klass.new(source.name, elements)
+                  new_class = STACK.push Klass.new(source, elements)
 
                   ListMethod.new(source) do |template|
                     template.item_class = new_class.name.camelize
                   end
                 else
                   ListMethod.new(source) do |template|
-                    template.item_class = source.has_custom_type? ? source&.type&.classify : 'String'
+                    template.item_class = source.has_custom_type? ? source.type.split(':').map(&:classify).join('::') : 'String'
                   end
                 end
               elsif source.has_custom_type?
                 SubmodelMethod.new(source)
               else
                 if elements.any?
-                  new_class = STACK.push Klass.new(source.name, elements)
-                  SubmodelMethod.new(source, new_class.name.camelize)
+                  new_class = STACK.push Klass.new(source, elements)
+                  SubmodelMethod.new(source, new_class.name_with_prefix)
                 else
                   AtMethod.new(source)
                 end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/element_ref.rb

@@ -0,0 +1,21 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class ElementRef
+            def initialize(source)
+              @source = source
+            end
+
+            def to_submodel_method(ref_map)
+              name = ref_map[@source.ref].split(':').map(&:classify).join('::')
+
+              SubmodelMethod.new(@source, name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/elements.rb

@@ -4,54 +4,17 @@ module ScaffoldParser
       class Parser
         module Handlers
           class Elements
+            include OrderElements
+
             attr_accessor :elements
 
             def initialize(elements = [])
               @elements = elements
             end
 
-            def sequence(_)
-              flattened = elements.flat_map do |element|
-                case element
-                when Sequence, Choice, All
-                  then element.elements
-                else
-                  element
-                end
-              end
-
-              Sequence.new flattened
-            end
-
-            def all(_)
-              flattened = elements.flat_map do |element|
-                case element
-                when Sequence, Choice, All
-                  then element.elements
-                else
-                  element
-                end
-              end
-
-              All.new flattened
-            end
-
             def schema(_)
               STACK
             end
-
-            def choice(_)
-              flattened = elements.flat_map do |element|
-                case element
-                when Sequence, Choice, All
-                  then element.elements
-                else
-                  element
-                end
-              end
-
-              Choice.new flattened
-            end
           end
         end
       end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/extension.rb

@@ -13,7 +13,7 @@ module ScaffoldParser
 
             def complex_type(source)
               if source.has_name?
-                template = Klass.new(source.name.camelize, elements) do |template|
+                template = Klass.new(source, elements) do |template|
                   template.inherit_from = attributes['base'].camelize
                 end
 

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/klass.rb

@@ -8,8 +8,9 @@ module ScaffoldParser
 
             attr_accessor :name, :namespace, :methods, :inherit_from, :includes
 
-            def initialize(name = nil, elements = [])
-              @name = name&.camelize
+            def initialize(source = nil, elements = [])
+              @name = source&.name&.camelize
+              @namespace = source.xmlns_prefix&.camelize
 
               includes, methods = [*elements].partition do |e|
                 e.is_a? ModuleInclude
@@ -25,6 +26,10 @@ module ScaffoldParser
               yield self if block_given?
             end
 
+            def name_with_prefix
+              [namespace, name].compact.map(&:camelize).join('::')
+            end
+
             def schema(_)
               STACK
             end
@@ -40,18 +45,19 @@ module ScaffoldParser
               f = StringIO.new
 
               if inherit_from
-                f.puts "class #{name} < #{inherit_from}"
+                i = inherit_from.split(':').compact.map(&:camelize).join('::')
+                f.puts "class #{name} < #{i}"
               else
                 f.puts "class #{name}"
               end
-              f.puts "  include BaseParser"
-              includes.each { |incl| f.puts "  include Groups::#{incl.ref}" }
+              f.puts "  include ParserCore::BaseParser"
+              includes.each { |incl| f.puts "  include #{incl.full_ref}" }
               if methods.any? || includes.any?
                 f.puts if methods.any?
                 f.puts methods.map { |method| indent(method.to_s.lines).join  }.join("\n\n")
                 f.puts if methods.any?
                 f.puts "  def to_h_with_attrs"
-                f.puts "    hash = HashWithAttributes.new({}, attributes)"
+                f.puts "    hash = ParserCore::HashWithAttributes.new({}, attributes)"
                 f.puts
                 methods.each { |method| f.puts "    #{method.to_h_with_attrs_method}" }
                 f.puts if methods.any?
@@ -70,7 +76,7 @@ module ScaffoldParser
 
               string = f.string.strip
 
-              wrapped = wrap_in_namespace(string, 'Parsers')
+              wrapped = string
               wrapped = wrap_in_namespace(wrapped, namespace) if namespace
 
               wrapped
@@ -80,11 +86,13 @@ module ScaffoldParser
               f = StringIO.new
 
               if inherit_from
-                f.puts "class #{name} < #{inherit_from}"
+                i = inherit_from.split(':').compact.map(&:camelize).join('::')
+                f.puts "class #{name} < #{i}"
               else
                 f.puts "class #{name}"
               end
-              f.puts "  include BaseBuilder"
+              f.puts "  include ParserCore::BaseBuilder"
+              includes.each { |incl| f.puts "  include #{incl.full_ref}" }
               f.puts
               f.puts "  def builder"
               f.puts "    root = Ox::Element.new(name)"
@@ -99,8 +107,16 @@ module ScaffoldParser
                 f.puts
               end
 
-              f.puts methods.map { |method| indent(indent(method.to_builder.lines)).join  }.join("\n")
-              f.puts
+              if methods.any?
+                f.puts methods.map { |method| indent(indent(method.to_builder.lines)).join  }.join("\n")
+                f.puts
+              end
+              if includes.any?
+                f.puts "    mega.each do |r|"
+                f.puts "      r.nodes.each { |n| root << n }"
+                f.puts "    end"
+                f.puts
+              end
               f.puts "    root"
               f.puts "  end"
 
@@ -108,7 +124,7 @@ module ScaffoldParser
 
               string = f.string.strip
 
-              wrapped = wrap_in_namespace(string, 'Builders')
+              wrapped = string
               wrapped = wrap_in_namespace(wrapped, namespace) if namespace
 
               wrapped

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/list_method.rb

@@ -11,7 +11,7 @@ module ScaffoldParser
 
             def initialize(source)
               @source = source
-              @at = [source.name]
+              @at = [[source.xmlns_prefix, "#{source.name}"].compact.join(':')]
 
               yield self if block_given?
             end
@@ -20,11 +20,15 @@ module ScaffoldParser
               "array_of_at(#{item_class}, #{single_quote(at)})"
             end
 
+            def name_with_prefix
+              [source.xmlns_prefix, "#{source.name}"].compact.join(':')
+            end
+
             def to_h_with_attrs_method
               if item_class == 'String'
-                "hash[:#{method_name}] = #{method_name} if has? '#{source.name}'"
+                "hash[:#{method_name}] = #{method_name} if has? '#{name_with_prefix}'"
               else
-                "hash[:#{method_name}] = #{method_name}.map(&:to_h_with_attrs) if has? '#{source.name}'"
+                "hash[:#{method_name}] = #{method_name}.map(&:to_h_with_attrs) if has? '#{name_with_prefix}'"
               end
             end
 
@@ -44,7 +48,9 @@ module ScaffoldParser
 
             def to_proxy_list(source, path)
               ProxyListMethod.new(source) do |m|
-                m.at = [path] + @at
+                prefixed_path = [source.xmlns_prefix, "#{source.name}"].compact.join(':')
+
+                m.at = [prefixed_path] + @at
                 m.item_class = @item_class
               end
             end
@@ -63,7 +69,7 @@ module ScaffoldParser
 
             def complex_type(source)
               if source.has_name?
-                STACK.push Klass.new(source.name, [self])
+                STACK.push Klass.new(source, [self])
               else
                 self
               end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/module.rb

@@ -8,12 +8,14 @@ module ScaffoldParser
           class Module
             include Utils
 
-            attr_accessor :name, :namespace, :methods, :includes
+            attr_accessor :name, :namespace, :methods, :includes, :inherit_from
 
-            def initialize(name = nil, methods = [])
-              @name = name&.camelize
+            def initialize(source = nil, methods = [])
+              @name = "Groups::#{source.name.camelize}"
               @methods = methods
 
+              @namespace = source.xmlns_prefix&.camelize
+
               yield self if block_given?
             end
 
@@ -21,43 +23,59 @@ module ScaffoldParser
               STACK
             end
 
+            def name_with_prefix
+              [namespace, name].compact.map(&:camelize).join('::')
+            end
+
             def to_s
-              ModuleTemplate.new(name.demodulize) do |template|
-                template.namespaces = ['Groups', 'Parsers', namespace].compact
-
-                methods.each { |method| template.methods << indent(method.to_s.lines).join  }
-
-                meth = StringIO.new
-                meth.puts "  def to_h_with_attrs"
-                meth.puts "    hash = HashWithAttributes.new({}, attributes)"
-                meth.puts
-                methods.each { |method| meth.puts "    #{method.to_h_with_attrs_method}" }
-                meth.puts
-                meth.puts "    hash"
-                meth.puts "  end"
-
-                template.methods << meth.string
-              end.to_s
+              string =
+                ModuleTemplate.new(name.demodulize) do |template|
+                  template.namespaces = ['Groups'].compact
+
+                  methods.each { |method| template.methods << indent(method.to_s.lines).join  }
+
+                  meth = StringIO.new
+                  meth.puts "  def to_h_with_attrs"
+                  meth.puts "    hash = ParserCore::HashWithAttributes.new({}, attributes)"
+                  meth.puts
+                  methods.each { |method| meth.puts "    #{method.to_h_with_attrs_method}" }
+                  meth.puts
+                  meth.puts "    hash"
+                  meth.puts "  end"
+
+                  template.methods << meth.string
+                end.to_s
+
+              wrapped = string
+              wrapped = wrap_in_namespace(wrapped, namespace) if namespace
+
+              wrapped
             end
 
             def to_builder_s
-              ModuleTemplate.new(name.demodulize) do |template|
-                template.namespaces = ['Groups', 'Builders', namespace].compact
-
-                meth = StringIO.new
-                meth.puts "  def builder"
-                meth.puts "    root = Ox::Element.new(name)"
-                meth.puts "    if data.respond_to? :attributes"
-                meth.puts "      data.attributes.each { |k, v| root[k] = v }"
-                meth.puts "    end"
-                meth.puts
-                meth.puts methods.map { |method| indent(indent(method.to_builder.lines)).join  }.join("\n")
-                meth.puts
-                meth.puts "    root"
-                meth.puts "  end"
-
-                template.methods = [meth.string]
-              end.to_s
+              string =
+                ModuleTemplate.new(name.demodulize) do |template|
+                  template.namespaces = ['Groups'].compact
+
+                  meth = StringIO.new
+                  meth.puts "  def builder"
+                  meth.puts "    root = Ox::Element.new(name)"
+                  meth.puts "    if data.respond_to? :attributes"
+                  meth.puts "      data.attributes.each { |k, v| root[k] = v }"
+                  meth.puts "    end"
+                  meth.puts
+                  meth.puts methods.map { |method| indent(indent(method.to_builder.lines)).join  }.join("\n")
+                  meth.puts
+                  meth.puts "    root"
+                  meth.puts "  end"
+
+                  template.methods = [meth.string]
+                end.to_s
+
+              wrapped = string
+              wrapped = wrap_in_namespace(wrapped, namespace) if namespace
+
+              wrapped
             end
           end
         end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/module_include.rb

@@ -4,10 +4,19 @@ module ScaffoldParser
       class Parser
         module Handlers
           class ModuleInclude
-            attr_reader :ref
+            attr_reader :ref, :source
 
-            def initialize(ref)
-              @ref = ref&.camelize
+            def initialize(source)
+              @source = source
+              @ref = @source.ref&.camelize
+            end
+
+            def full_ref
+              if ref.include? ':'
+                [ref.split(':')[0], 'groups', ref.split(':')[1]].compact.map(&:camelize).join('::')
+              else
+                [source.xmlns_prefix, 'groups', ref].compact.map(&:camelize).join('::')
+              end
             end
 
             def sequence(_)
@@ -16,7 +25,7 @@ module ScaffoldParser
 
             def complex_type(new_source)
               if new_source.has_name?
-                STACK.push Klass.new(new_source.name.camelize, self)
+                STACK.push Klass.new(new_source, self)
               else
                 self
               end
@@ -24,9 +33,9 @@ module ScaffoldParser
 
             def element(new_source)
               if new_source.has_name?
-                new_class = STACK.push Klass.new(new_source.name.camelize, self)
+                new_class = STACK.push Klass.new(new_source, self)
 
-                SubmodelMethod.new(new_source, new_class.name.camelize)
+                SubmodelMethod.new(new_source, new_class.name_with_prefix)
               end
             end
           end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/order_elements.rb

@@ -0,0 +1,50 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          module OrderElements
+            def sequence(_)
+              flattened = elements.flat_map do |element|
+                case element
+                when Sequence, Choice, All
+                  element.elements
+                else
+                  element
+                end
+              end
+
+              Sequence.new flattened
+            end
+
+            def all(_)
+              flattened = elements.flat_map do |element|
+                case element
+                when Sequence, Choice, All
+                  element.elements
+                else
+                  element
+                end
+              end
+
+              All.new flattened
+            end
+
+            def choice(_)
+              flattened = elements.flat_map do |element|
+                case element
+                when Sequence, Choice, All
+                  element.elements
+                else
+                  element
+                end
+              end
+
+              Choice.new flattened
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/proxy_list_method.rb

@@ -18,11 +18,15 @@ module ScaffoldParser
               "array_of_at(#{item_class}, #{single_quote(at)})"
             end
 
+            def name_with_prefix
+              [source.xmlns_prefix, "#{source.name}"].compact.join(':')
+            end
+
             def to_h_with_attrs_method
               if item_class == 'String'
-                "hash[:#{method_name}] = #{method_name} if has? '#{source.name}'"
+                "hash[:#{method_name}] = #{method_name} if has? '#{name_with_prefix}'"
               else
-                "hash[:#{method_name}] = #{method_name}.map(&:to_h_with_attrs) if has? '#{source.name}'"
+                "hash[:#{method_name}] = #{method_name}.map(&:to_h_with_attrs) if has? '#{name_with_prefix}'"
               end
             end
 

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/requires.rb

@@ -1,3 +1,4 @@
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/order_elements'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/blank'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/complex_type'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/elements'
@@ -16,4 +17,5 @@ require 'scaffold_parser/scaffolders/xsd/parser/handlers/list_method'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/module'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/proxy_list_method'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/submodel_method'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/element_ref'
 require 'scaffold_parser/scaffolders/xsd/parser/handlers/extension'

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/sequence.rb

@@ -4,39 +4,23 @@ module ScaffoldParser
       class Parser
         module Handlers
           class Sequence
+            include OrderElements
             attr_accessor :elements
 
             def initialize(elements = [])
               @elements = [*elements]
             end
 
-            def sequence(_)
-              flattened = elements.flat_map do |element|
-                case element
-                when Sequence, Choice, All
-                  then element.elements
-                else
-                  element
-                end
-              end
-
-              Sequence.new flattened
-            end
-
             def complex_type(source)
               if source.has_name?
-                STACK.push Klass.new(source.name, elements)
+                STACK.push Klass.new(source, elements)
               end
 
               ComplexType.new elements
             end
 
             def group(source)
-              STACK.push Module.new("Groups::#{source.name.camelize}", elements)
-            end
-
-            def choice(_)
-              self
+              STACK.push Module.new(source, elements)
             end
 
             def extension(source)

data/lib/scaffold_parser/scaffolders/xsd/parser/handlers/submodel_method.rb

@@ -11,22 +11,36 @@ module ScaffoldParser
 
             def initialize(source, submodel_class = nil)
               @source = source
-              @submodel_class = submodel_class || source.type.camelize
+              @submodel_class =
+                submodel_class ||
+                source.type&.split(':')&.map(&:camelize)&.join('::')
+            end
+
+            def at
+              if source.name
+                [source.xmlns_prefix, "#{source.name}"].compact.join(':')
+              elsif source.ref
+                source.ref
+              end
             end
 
             def method_body
-              "submodel_at(#{submodel_class}, '#{source.name}')"
+              "submodel_at(#{submodel_class}, '#{at}')"
+            end
+
+            def name_with_prefix
+              [source.xmlns_prefix, "#{method_name}"].compact.join(':')
             end
 
             def to_h_with_attrs_method
-              "hash[:#{method_name}] = #{method_name}.to_h_with_attrs if has? '#{source.name}'"
+              "hash[:#{method_name}] = #{method_name}.to_h_with_attrs if has? '#{at}'"
             end
 
             def to_builder
               f = StringIO.new
 
               f.puts "if data.key? :#{method_name}"
-              f.puts "  root << #{submodel_class}.new('#{source.name}', data[:#{source.name.underscore}]).builder"
+              f.puts "  root << #{submodel_class}.new('#{at}', data[:#{method_name}]).builder"
               f.puts 'end'
 
               f.string.strip

data/lib/scaffold_parser/scaffolders/xsd/parser.rb

@@ -21,33 +21,22 @@ module ScaffoldParser
         def call
           STACK.clear
 
-          classes =
-            xsds.map do |xsd|
-              if @options[:verbose]
-                puts "\n\nScaffolding schema which defines:\n#{xsd.children.map { |c| c.name }.compact}\n"
-              end
-
-              xsd.reverse_traverse do |element, children_result|
-                handler =
-                  if children_result.empty?
-                    Handlers::Blank.new
-                  elsif children_result.one?
-                    children_result.first
-                  else
-                    Handlers::Elements.new(children_result)
-                  end
-
-                if @options[:verbose]
-                  current_handler = handler.class.to_s.demodulize
-                  childrens = (handler.instance_variable_get('@elements') || []).map { |child| child.class.to_s.demodulize }
-                  puts "#{current_handler}#{childrens}##{element.element_name}"
+          xsds.each do |xsd|
+            xsd.reverse_traverse do |element, children_result|
+              handler =
+                if children_result.empty?
+                  Handlers::Blank.new
+                elsif children_result.one?
+                  children_result.first
+                else
+                  Handlers::Elements.new(children_result)
                 end
 
-                handler.send(element.element_name, element)
-              end
+              handler.send(element.element_name, element)
             end
+          end
 
-          classes = STACK.to_a
+          STACK.to_a
         end
       end
     end

data/lib/scaffold_parser/scaffolders/xsd.rb

@@ -20,220 +20,115 @@ module ScaffoldParser
         all = [@doc.schema] + @doc.schema.collect_included_schemas(@parse_options) + @doc.schema.collect_imported_schemas(@parse_options)
 
         classes = Parser.call(all, @options)
+        top_level_elements = all.flat_map(&:elements)
+        ref_map = top_level_elements.map { |e| [e.name_with_prefix, e.type_with_prefix]}.to_h
 
-        classes.each do |klass|
-          klass.methods = klass.methods.map do |meth|
-            if meth.is_a?(Parser::Handlers::SubmodelMethod) && !classes.map(&:name).include?(meth.submodel_class)
-              meth.to_at_method
-            else
-              meth
-            end
+        # reject dumb classes which are just extension proxies to simple types :D
+        classes = classes.reject do |klass|
+          inherit_from = classes.find do |cl|
+            cl.name_with_prefix == klass&.inherit_from&.split(':')&.map(&:camelize)&.join('::')
           end
-        end
-
-        classes.each do |klass|
-          klass.namespace = @options[:namespace]
-        end
 
-        classes.flat_map do |class_template|
-          [["parsers/#{class_template.name.underscore}.rb", class_template.to_s],
-           ["builders/#{class_template.name.underscore}.rb", class_template.to_builder_s],
-           ["parsers/base_parser.rb", wrap_in_namespace(base_parser_template, @options[:namespace])],
-           ["builders/base_builder.rb", wrap_in_namespace(base_builder_template, @options[:namespace])],
-           ["requires.rb", create_requires_template(classes)],
-           ["hash_with_attrs.rb", wrap_in_namespace(hash_with_attrs_template, @options[:namespace])],
-           ["mega.rb", wrap_in_namespace(mega_template, @options[:namespace])]
-          ]
+          klass.methods.empty? && klass.includes.empty? && inherit_from.nil?
         end
-      end
-
-      private
-
-      def base_parser_template
-        <<~TEMPLATE
-          module Parsers
-            module BaseParser
-              include Mega
-              EMPTY_ARRAY = []
-
-              attr_accessor :raw
-
-              def initialize(raw)
-                @raw = raw
-              end
-
-              def attributes
-                raw.attributes
-              end
-
-              private
 
-              def at(locator)
-                return nil if raw.nil?
-
-                element = raw.locate(locator.to_s).first
-
-                if element
-                  StringWithAttributes.new(element.text, element.attributes)
-                end
-              end
-
-              def has?(locator)
-                raw.locate(locator).any?
-              end
-
-              def submodel_at(klass, locator)
-                element_xml = raw.locate(locator).first
-
-                klass.new(element_xml) if element_xml
-              end
-
-              def array_of_at(klass, locator)
-                return EMPTY_ARRAY if raw.nil?
-
-                elements = raw.locate([*locator].join('/'))
-
-                elements.map do |element|
-                  klass.new(element)
-                end
-              end
-
-              def to_h_with_attrs
-                hash = HashWithAttributes.new({}, attributes)
-
-                hash
-              end
-            end
+        # remove dumb classes inheritance
+        classes = classes.map do |klass|
+          inherit_from = classes.find do |cl|
+            cl.name_with_prefix == klass&.inherit_from&.split(':')&.map(&:camelize)&.join('::')
           end
-        TEMPLATE
-      end
-
-      def base_builder_template
-        <<~TEMPLATE
-          module Builders
-            module BaseBuilder
-              attr_accessor :name, :data, :options
-
-              def initialize(name, data = {}, options = {})
-                @name = name
-                @data = data || {}
-                @options = options || {}
-              end
 
-              def to_xml
-                encoding = options[:encoding]
-
-                doc_options = { version: '1.0' }
-                doc_options[:encoding] = encoding if encoding
-                doc = Ox::Document.new(doc_options)
-                doc << builder
-
-                dump_options = { with_xml: true }
-                dump_options[:encoding] = encoding if encoding
-                Ox.dump(doc, dump_options)
-              end
-
-              def build_element(name, content)
-                element = Ox::Element.new(name)
-                if content.respond_to? :attributes
-                  content.attributes.each { |k, v| element[k] = v }
-                end
-
-                if content.respond_to? :value
-                  element << content.value if content.value
-                else
-                  element << content if content
-                end
-                element
-              end
-            end
+          if inherit_from.nil?
+            klass.inherit_from = nil
           end
-        TEMPLATE
-      end
+          klass
+        end
 
-      def hash_with_attrs_template
-        <<~TEMPLATE
-          class HashWithAttributes
-            def initialize(hash, attributes = nil)
-              @hash = hash
-              @attributes = attributes if attributes
-            end
+        # remove dumb classes includes
+        classes = classes.map do |klass|
+          existing_includes = (klass.includes || []).select do |incl|
+            classes.map(&:name_with_prefix).include? incl.full_ref
+          end
 
-            def value
-              @hash
-            end
+          klass.includes = existing_includes
 
-            def attributes
-              @attributes ||= {}
-            end
+          klass
+        end
 
-            def attributes=(attributes)
-              @attributes = attributes
-            end
+        # remove proxy lists through named complex types
+        # #TODO: could i somehow remove proxy complex types so they are not outputted into class files?
+        #   ... they are not used anyhow.. probably not used..? Can't they be inherited from or something?
+        classes = classes.map do |klass|
+          klass.methods = klass.methods.map do |meth|
+            if meth.is_a?(Parser::Handlers::SubmodelMethod)
+              submodel_class = classes.find { |cl| cl.name_with_prefix == meth.submodel_class }
 
-            def ==(other)
-              if other.respond_to?(:value) && other.respond_to?(:attributes)
-                value == other.value && other.attributes == attributes
+              if (submodel_class.methods.size == 1) && submodel_class.methods.first.is_a?(Parser::Handlers::ListMethod) && submodel_class.inherit_from.nil? && submodel_class.includes.empty?
+                submodel_class.methods.first.to_proxy_list(meth.source, meth.at)
               else
-                value == other
+                meth
               end
+            else
+              meth
             end
+          end
 
-            def merge(other)
-              merged_hash = value.merge other.value
-              merged_attrs = attributes.merge other.attributes
+          klass
+        end
 
-              self.class.new(merged_hash, merged_attrs)
+        classes.each do |klass|
+          klass.methods = klass.methods.map do |meth|
+            if meth.is_a?(Parser::Handlers::SubmodelMethod) && !classes.map(&:name_with_prefix).include?(meth.submodel_class)
+              meth.to_at_method
+            elsif  meth.is_a?(Parser::Handlers::ElementRef)
+              meth.to_submodel_method(ref_map)
+            else
+              meth
             end
+          end
+        end
 
-            def key?(key)
-              value.key? key
-            end
+        requires = create_requires_template(classes)
+        parsers = classes.map do |klass|
+          path = ["parsers", klass.namespace&.underscore, "#{klass.name.underscore}.rb"].compact.join('/')
+          string = wrap_in_namespace(klass.to_s, 'Parsers')
 
-            def [](key)
-              value[key]
-            end
+          [path, string]
+        end
+        builders = classes.map do |klass|
+          path = ["builders", klass.namespace&.underscore, "#{klass.name.underscore}.rb"].compact.join('/')
+          string = wrap_in_namespace(klass.to_builder_s, 'Builders')
 
-            def []=(key, key_value)
-              value[key] = key_value
-            end
+          [path, string]
+        end
 
-            def dig(*attrs)
-              value.dig(*attrs)
-            end
-          end
-        TEMPLATE
-      end
+        all = parsers + builders
+        result = all.map do |path, string|
+          [path, wrap_in_namespace(string, @options[:namespace])]
+        end
 
-      def mega_template
-        <<~TEMPLATE
-          module Mega
-            def mega
-              called_from = caller_locations[0].label
-              included_modules = (self.class.included_modules - Class.included_modules - [Mega])
-              included_modules.map { |m| m.instance_method(called_from).bind(self).call }
-            end
-          end
-        TEMPLATE
+        result + [['requires.rb', requires]]
       end
 
+      private
+
       def create_requires_template(classes)
         modules = classes.select { |cl| cl.is_a? Parser::Handlers::Module }
         classes = classes.select { |cl| cl.is_a? Parser::Handlers::Klass }
         with_inheritance, others = classes.partition { |klass| klass.inherit_from }
 
-        requires = ['parsers/base_parser', 'builders/base_builder']
+        requires = []
         modules.each do |klass|
-          requires << "parsers/#{klass.name.underscore}"
-          requires << "builders/#{klass.name.underscore}"
+          requires << ["parsers", klass.namespace&.underscore, klass.name.underscore].compact.join('/')
+          requires << ["builders", klass.namespace&.underscore, klass.name.underscore].compact.join('/')
         end
         others.each do |klass|
-          requires << "parsers/#{klass.name.underscore}"
-          requires << "builders/#{klass.name.underscore}"
+          requires << ["parsers", klass.namespace&.underscore, klass.name.underscore].compact.join('/')
+          requires << ["builders", klass.namespace&.underscore, klass.name.underscore].compact.join('/')
         end
         with_inheritance.each do |klass|
-          requires << "parsers/#{klass.name.underscore}"
-          requires << "builders/#{klass.name.underscore}"
+          requires << ["parsers", klass.namespace&.underscore, klass.name.underscore].compact.join('/')
+          requires << ["builders", klass.namespace&.underscore, klass.name.underscore].compact.join('/')
         end
 
         if @options[:namespace]

data/lib/scaffold_parser.rb

@@ -1,17 +1,13 @@
 require 'xsd_model'
+require 'fileutils'
 require 'active_support/all'
 require 'scaffold_parser/scaffolders/xsd'
 
 module ScaffoldParser
   def self.scaffold(path, options = {})
-    ensure_dir_exists('./tmp/')
-    ensure_dir_exists('./tmp/builders')
-    ensure_dir_exists('./tmp/builders/groups')
-    ensure_dir_exists('./tmp/parsers')
-    ensure_dir_exists('./tmp/parsers/groups')
-
     scaffold_to_string(File.read(path), options).each do |path, content|
       complete_path = path.prepend('./tmp/')
+      ensure_dir_exists(complete_path, options)
 
       puts "Writing out #{complete_path}" if options[:verbose]
 
@@ -37,10 +33,13 @@ module ScaffoldParser
 
   private
 
-  def self.ensure_dir_exists(path)
-    unless Dir.exists?(path)
-      Dir.mkdir(path)
-      puts "#{path} directory created"
+  def self.ensure_dir_exists(path, options)
+    dir = path.split('/')[0..-2].join('/')
+
+    unless Dir.exists?(dir)
+      FileUtils.mkdir_p(dir)
+
+      puts "#{dir} directory created" if options[:verbose]
     end
   end
 end

data/scaffold_parser.gemspec

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'scaffold_parser'
-  spec.version       = '0.6.0'
+  spec.version       = '0.7.0'
   spec.authors       = ['Premysl Donat']
   spec.email         = ['pdonat@seznam.cz']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scaffold_parser
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Premysl Donat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-04 00:00:00.000000000 Z
+date: 2018-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,6 +150,7 @@ files:
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/choice.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/class_inherit.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/complex_type.rb
+- lib/scaffold_parser/scaffolders/xsd/parser/handlers/element_ref.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/elements.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/extension.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/import.rb
@@ -158,6 +159,7 @@ files:
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/list_method.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/module.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/module_include.rb
+- lib/scaffold_parser/scaffolders/xsd/parser/handlers/order_elements.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/proxy_list_method.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/requires.rb
 - lib/scaffold_parser/scaffolders/xsd/parser/handlers/sequence.rb