scaffold_parser 0.5.0 → 0.6.0

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

@@ -0,0 +1,86 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class ListMethod
+            include BaseMethod
+            include Utils
+
+            attr_accessor :at, :item_class
+
+            def initialize(source)
+              @source = source
+              @at = [source.name]
+
+              yield self if block_given?
+            end
+
+            def method_body
+              "array_of_at(#{item_class}, #{single_quote(at)})"
+            end
+
+            def to_h_with_attrs_method
+              if item_class == 'String'
+                "hash[:#{method_name}] = #{method_name} if has? '#{source.name}'"
+              else
+                "hash[:#{method_name}] = #{method_name}.map(&:to_h_with_attrs) if has? '#{source.name}'"
+              end
+            end
+
+            def to_builder
+              f = StringIO.new
+
+              f.puts "if data.key? :#{method_name}"
+              if item_class == 'String'
+                f.puts "  data[:#{method_name}].map { |i| Ox::Element.new('#{at.first}') << i }.each { |i| root << i }"
+              else
+                f.puts "  data[:#{method_name}].each { |i| root << #{item_class}.new('#{at.first}', i).builder }"
+              end
+              f.puts 'end'
+
+              f.string.strip
+            end
+
+            def to_proxy_list(source, path)
+              ProxyListMethod.new(source) do |m|
+                m.at = [path] + @at
+                m.item_class = @item_class
+              end
+            end
+
+            def sequence(_)
+              self
+            end
+
+            def choice(_)
+              self
+            end
+
+            def all(_)
+              self
+            end
+
+            def complex_type(source)
+              if source.has_name?
+                STACK.push Klass.new(source.name, [self])
+              else
+                self
+              end
+            end
+
+            def element(source)
+              if source.has_name?
+                to_proxy_list(source, source.name)
+              end
+            end
+
+            def extension(source)
+              Extension.new(self, source.attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'scaffold_parser/scaffolders/xsd/parser/module_template'
+
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Module
+            include Utils
+
+            attr_accessor :name, :namespace, :methods, :includes
+
+            def initialize(name = nil, methods = [])
+              @name = name&.camelize
+              @methods = methods
+
+              yield self if block_given?
+            end
+
+            def schema(_)
+              STACK
+            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
+            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
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class ModuleInclude
+            attr_reader :ref
+
+            def initialize(ref)
+              @ref = ref&.camelize
+            end
+
+            def sequence(_)
+              Sequence.new self
+            end
+
+            def complex_type(new_source)
+              if new_source.has_name?
+                STACK.push Klass.new(new_source.name.camelize, self)
+              else
+                self
+              end
+            end
+
+            def element(new_source)
+              if new_source.has_name?
+                new_class = STACK.push Klass.new(new_source.name.camelize, self)
+
+                SubmodelMethod.new(new_source, new_class.name.camelize)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class ProxyListMethod
+            include BaseMethod
+            include Utils
+
+            attr_accessor :at, :item_class
+
+            def initialize(source)
+              @source = source
+              yield self if block_given?
+            end
+
+            def method_body
+              "array_of_at(#{item_class}, #{single_quote(at)})"
+            end
+
+            def to_h_with_attrs_method
+              if item_class == 'String'
+                "hash[:#{method_name}] = #{method_name} if has? '#{source.name}'"
+              else
+                "hash[:#{method_name}] = #{method_name}.map(&:to_h_with_attrs) if has? '#{source.name}'"
+              end
+            end
+
+            def to_builder
+              f = StringIO.new
+
+              f.puts "if data.key? :#{method_name}"
+              f.puts "  element = Ox::Element.new('#{at.first}')"
+              if item_class == 'String'
+                f.puts "  data[:#{method_name}].map { |i| Ox::Element.new('#{at.last}') << i }.each { |i| element << i }"
+              else
+                f.puts "  data[:#{method_name}].each { |i| element << #{item_class}.new('#{at.last}', i).builder }"
+              end
+              f.puts '  root << element'
+              f.puts 'end'
+
+              f.string.strip
+            end
+
+            def sequence(_)
+              Sequence.new self
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+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'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/sequence'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/all'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/choice'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/include'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/import'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/utils'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/base_method'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/module_include'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/class_inherit'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/at_method'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/klass'
+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/extension'

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

@@ -0,0 +1,50 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class Sequence
+            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)
+              end
+
+              ComplexType.new elements
+            end
+
+            def group(source)
+              STACK.push Module.new("Groups::#{source.name.camelize}", elements)
+            end
+
+            def choice(_)
+              self
+            end
+
+            def extension(source)
+              Extension.new elements, source.attributes
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          class SubmodelMethod
+            include BaseMethod
+            include Utils
+
+            attr_accessor :submodel_class
+
+            def initialize(source, submodel_class = nil)
+              @source = source
+              @submodel_class = submodel_class || source.type.camelize
+            end
+
+            def method_body
+              "submodel_at(#{submodel_class}, '#{source.name}')"
+            end
+
+            def to_h_with_attrs_method
+              "hash[:#{method_name}] = #{method_name}.to_h_with_attrs if has? '#{source.name}'"
+            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 'end'
+
+              f.string.strip
+            end
+
+            def sequence(_)
+              Sequence.new self
+            end
+
+            def choice(_)
+              Choice.new self
+            end
+
+            def all(_)
+              All.new self
+            end
+
+            def schema(_)
+              STACK
+            end
+
+            def to_at_method
+              AtMethod.new(source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        module Handlers
+          module Utils
+            def indent(lines_or_string)
+              if lines_or_string.is_a? Array
+                lines_or_string.map { |line| indent_string(line) }
+              else
+                indent_string(lines_or_string)
+              end
+            end
+
+            def indent_string(string)
+              string == "\n" ? string : string.prepend('  ')
+            end
+
+            def single_quote(string)
+              string.to_s.gsub('"', '\'')
+            end
+
+            def wrap_in_namespace(klass, namespace)
+              return klass unless namespace
+
+              lines = klass.lines
+              indented = indent(lines)
+
+              indented.unshift "module #{namespace}\n"
+              indented << "\nend"
+
+              indented.join
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/utils'
+
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        class ModuleTemplate
+          include Handlers::Utils
+
+          attr_accessor :name, :methods, :namespaces
+
+          def initialize(name = nil)
+            @name = name
+            @methods = []
+            @namespaces = []
+
+            yield self if block_given?
+          end
+
+          def to_s
+            f = StringIO.new
+
+            f.puts "module #{name}"
+            f.puts methods.join("\n\n")
+
+            f.puts "end"
+            string = f.string.strip
+
+            namespaces.inject(string) { |string, n| wrap_in_namespace(string, n) }
+          end
+        end
+      end
+    end
+  end
+end