scaffold_parser 0.5.0 → 0.6.0

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

@@ -0,0 +1,29 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class All
+            attr_accessor :elements
+
+            def initialize(elements = [])
+              @elements = [*elements]
+            end
+
+            def group(new_source)
+              STACK.push Module.new("Groups::#{new_source.name.camelize}", elements)
+            end
+
+            def complex_type(source)
+              if source.has_name?
+                STACK.push Klass.new(source.name, elements)
+              end
+
+              ComplexType.new elements
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class AtMethod
+            include BaseMethod
+            include Utils
+
+            def method_body
+              "at '#{source.name}'"
+            end
+
+            def to_h_with_attrs_method
+              "hash[:#{method_name}] = #{method_name} if has? '#{source.name}'"
+            end
+
+            def to_builder
+              "root << build_element('#{source.name}', data[:#{source.name.underscore}]) if data.key? :#{source.name.underscore}"
+            end
+
+            def sequence(_)
+              Sequence.new self
+            end
+
+            def choice(_)
+              Choice.new self
+            end
+
+            def all(_)
+              All.new self
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          module BaseMethod
+            attr_accessor :source
+
+            def initialize(source)
+              @source = source
+            end
+
+            def method_name
+              source.name.underscore
+            end
+
+            def to_s
+              f = StringIO.new
+
+              f.puts "def #{method_name}"
+              f.puts indent(method_body.lines).join
+              f.puts "end"
+
+              f.string.strip
+            end
+
+            def ==(other)
+              method_name == other.method_name &&
+                method_body == other.method_body
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Blank
+            def elements
+              []
+            end
+
+            def element(source)
+              if source.multiple?
+                if elements.any?
+                  new_class = STACK.push Klass.new(source.name, 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'
+                  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)
+                else
+                  AtMethod.new(source)
+                end
+              end
+            end
+
+            def complex_type(source)
+              if source.has_name?
+                STACK.push Klass.new(source.name)
+              else
+                ComplexType.new
+              end
+            end
+
+            def extension(source)
+              if source.custom_extension?
+                Extension.new(elements, source.attributes)
+              else # basic xsd extension
+                self
+              end
+
+            end
+
+            def include(_)
+              Include.new
+            end
+
+            def import(_)
+              Import.new
+            end
+
+            def schema(_)
+              STACK
+            end
+
+            def group(source)
+              ModuleInclude.new(source.ref)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Choice
+            attr_accessor :elements
+
+            def initialize(elements = [])
+              @elements = [*elements]
+            end
+
+            def complex_type(source)
+              if source.has_name?
+                STACK.push Klass.new(source.name, 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
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class ClassInherit
+            attr_reader :base
+
+            def initialize(base)
+              @base = base&.camelize
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class ComplexType
+            attr_accessor :elements
+
+            def initialize(elements = [])
+              @elements = elements
+            end
+
+            def schema(_)
+              STACK
+            end
+
+            def element(source)
+              if source.multiple?
+                if elements.any?
+                  new_class = STACK.push Klass.new(source.name, 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'
+                  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)
+                else
+                  AtMethod.new(source)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Elements
+            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
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Extension
+            attr_accessor :elements, :attributes
+
+            def initialize(elements = [], attributes)
+              @elements = [*elements]
+              @attributes = attributes
+            end
+
+            def complex_type(source)
+              if source.has_name?
+                template = Klass.new(source.name.camelize, elements) do |template|
+                  template.inherit_from = attributes['base'].camelize
+                end
+
+                STACK.push template
+              else
+                ComplexType.new elements + [ClassInherit.new(attributes['base'])]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Import
+            def schema(_)
+              STACK
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Include
+            def schema(_)
+              STACK
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Klass
+            include Utils
+
+            attr_accessor :name, :namespace, :methods, :inherit_from, :includes
+
+            def initialize(name = nil, elements = [])
+              @name = name&.camelize
+
+              includes, methods = [*elements].partition do |e|
+                e.is_a? ModuleInclude
+              end
+              inherits, methods = methods.partition do |e|
+                e.is_a? ClassInherit
+              end
+
+              @methods = methods
+              @includes = includes
+              @inherit_from = inherits.first.base if inherits.any?
+
+              yield self if block_given?
+            end
+
+            def schema(_)
+              STACK
+            end
+
+            def ==(other)
+              name == other.name &&
+                namespace == other.namespace &&
+                methods == other.methods &&
+                inherit_from == other.inherit_from
+            end
+
+            def to_s
+              f = StringIO.new
+
+              if inherit_from
+                f.puts "class #{name} < #{inherit_from}"
+              else
+                f.puts "class #{name}"
+              end
+              f.puts "  include BaseParser"
+              includes.each { |incl| f.puts "  include Groups::#{incl.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
+                methods.each { |method| f.puts "    #{method.to_h_with_attrs_method}" }
+                f.puts if methods.any?
+                if includes.any?
+                  f.puts "    mega.inject(hash) { |memo, r| memo.merge r }"
+                else
+                  f.puts "    hash"
+                end
+                if inherit_from
+                  f.puts "    super.merge(hash)"
+                end
+                f.puts "  end"
+              end
+
+              f.puts "end"
+
+              string = f.string.strip
+
+              wrapped = wrap_in_namespace(string, 'Parsers')
+              wrapped = wrap_in_namespace(wrapped, namespace) if namespace
+
+              wrapped
+            end
+
+            def to_builder_s
+              f = StringIO.new
+
+              if inherit_from
+                f.puts "class #{name} < #{inherit_from}"
+              else
+                f.puts "class #{name}"
+              end
+              f.puts "  include BaseBuilder"
+              f.puts
+              f.puts "  def builder"
+              f.puts "    root = Ox::Element.new(name)"
+              f.puts "    if data.respond_to? :attributes"
+              f.puts "      data.attributes.each { |k, v| root[k] = v }"
+              f.puts "    end"
+              f.puts
+              if inherit_from
+                f.puts "    super.nodes.each do |n|"
+                f.puts "      root << n"
+                f.puts "    end"
+                f.puts
+              end
+
+              f.puts methods.map { |method| indent(indent(method.to_builder.lines)).join  }.join("\n")
+              f.puts
+              f.puts "    root"
+              f.puts "  end"
+
+              f.puts "end"
+
+              string = f.string.strip
+
+              wrapped = wrap_in_namespace(string, 'Builders')
+              wrapped = wrap_in_namespace(wrapped, namespace) if namespace
+
+              wrapped
+            end
+          end
+        end
+      end
+    end
+  end
+end