scaffold_parser 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 017e23477330b9cf2841a422f3d2d60b71d4288c
-  data.tar.gz: 3698f8522b0687d180a01ee817e0da43d4cb5e8f
+  metadata.gz: a86da6f57bcf43be3e59f2a47531005113ada9ff
+  data.tar.gz: e29b1f9dbea6e921666a001bc51c9213db18e15d
 SHA512:
-  metadata.gz: 2d064e3292e12916fafcc8c307814b09f4cb38b0c4455471777ae8c1a5046166fa1a9962669393f1422cedb8bc327c863c7422e8f4e810b3418de1b7d07949f6
-  data.tar.gz: c5709d9484f8cb1de6d04eb02137712b576b9cf753228491297af1864331090deb3f0b9bcc34872a02153cfb5c4a382fbca65485c94dc4c858333e5feb509a2c
+  metadata.gz: 664fc7cc63285c13ba2b620bc13224f9752a1887ed33c1ac6ee7e20984aecee83b0fdf7b6f21a948b00162e7b47e7931f935f841accb529ed4c8057dcb33480f
+  data.tar.gz: 0d469c89f076255eefad50e3290ab8dc1b59cf11976f7ff25418e1957fda6a1306d3480e355fba259dab6a43b04e255a034d804af9a683b0e18b2376fb1fcba5

data/Gemfile

@@ -4,3 +4,5 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in scaffold_parser.gemspec
 gemspec
+
+gem 'xsd_model', path: '/home/masa331/code/ruby/xsd_model/'

data/lib/scaffold_parser.rb

@@ -1,31 +1,16 @@
-require 'nokogiri'
+require 'xsd_model'
 require 'active_support/all'
-require 'scaffold_parser/nokogiri_patches'
-require 'scaffold_parser/file_patches'
 require 'scaffold_parser/scaffolders/xsd'
 
-Nokogiri::XML::Element.include ScaffoldParser::NokogiriPatches::Element
-Nokogiri::XML::Document.include ScaffoldParser::NokogiriPatches::Document
-StringIO.include ScaffoldParser::FilePatches
-
 module ScaffoldParser
   def self.scaffold(path, options = {})
-    unless Dir.exists?('./tmp/')
-      Dir.mkdir('./tmp/')
-      puts './tmp/ directory created'
-    end
+    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')
 
-    unless Dir.exists?('./tmp/builders')
-      Dir.mkdir('./tmp/builders')
-      puts './tmp/builders directory created'
-    end
-
-    unless Dir.exists?('./tmp/parsers')
-      Dir.mkdir('./tmp/parsers')
-      puts './tmp/parsers directory created'
-    end
-
-    scaffold_to_string(path, options).each do |path, content|
+    scaffold_to_string(File.read(path), options).each do |path, content|
       complete_path = path.prepend('./tmp/')
 
       puts "Writing out #{complete_path}" if options[:verbose]
@@ -34,9 +19,28 @@ module ScaffoldParser
     end
   end
 
-  def self.scaffold_to_string(path, options = {})
-    doc = Nokogiri::XML(File.open(path))
+  def self.scaffold_to_string(schema, options = {})
+    parse_options = { collect_only: [:element,
+                                     :complex_type,
+                                     :sequence,
+                                     :all,
+                                     :choice,
+                                     :schema,
+                                     :include,
+                                     :import,
+                                     :group,
+                                     :extension] }
+    doc = XsdModel.parse(schema, parse_options)
+
+    Scaffolders::XSD.call(doc, options, parse_options)
+  end
+
+  private
 
-    Scaffolders::XSD.call(doc, options)
+  def self.ensure_dir_exists(path)
+    unless Dir.exists?(path)
+      Dir.mkdir(path)
+      puts "#{path} directory created"
+    end
   end
 end

data/lib/scaffold_parser/scaffolders/xsd.rb

@@ -1,57 +1,59 @@
 require 'scaffold_parser/scaffolders/xsd/parser'
-require 'scaffold_parser/scaffolders/xsd/builder'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/utils'
 
 module ScaffoldParser
   module Scaffolders
     class XSD
-      def self.call(doc, options)
-        self.new(doc, options).call
+      include Parser::Handlers::Utils
+
+      def self.call(doc, options, parse_options = {})
+        self.new(doc, options, parse_options).call
       end
 
-      def initialize(doc, options)
+      def initialize(doc, options, parse_options = {})
         @doc = doc
         @options = options
+        @parse_options = parse_options
       end
 
       def call
-        puts "Starting collectiong elements to scaffold" if @options[:verbose]
+        all = [@doc.schema] + @doc.schema.collect_included_schemas(@parse_options) + @doc.schema.collect_imported_schemas(@parse_options)
 
-        unscaffolded_elements = collect_unscaffolded_subelements(@doc) + @doc.submodel_nodes
+        classes = Parser.call(all, @options)
 
-        puts "Collected #{unscaffolded_elements.size} elements to scaffold" if @options[:verbose]
+        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
+          end
+        end
 
-        code = unscaffolded_elements.flat_map do |element|
-          [Parser.call(element.definition, @options), Builder.call(element.definition, @options)]
+        classes.each do |klass|
+          klass.namespace = @options[:namespace]
         end
 
-        code.push ['parsers/base_parser.rb', base_parser_template]
-        code.push ['builders/base_builder.rb', base_builder_template]
+        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])]
+          ]
+        end
       end
 
       private
 
-      def collect_unscaffolded_subelements(node, collected = [])
-        subelements = node.definition.submodel_nodes.to_a + node.definition.array_nodes.map(&:list_element)
-          .reject(&:xs_type?)
-          .reject { |node| collected.include?(node.to_class_name) }
-
-        subelements.each do |element|
-          if collected.none? { |c| c.to_class_name == element.to_class_name }
-            collected << element
-
-            puts "Collected #{element.to_name} element" if @options[:verbose]
-
-            collect_unscaffolded_subelements(element, collected)
-          end
-        end
-
-        collected
-      end
-
       def base_parser_template
         <<~TEMPLATE
           module Parsers
             module BaseParser
+              include Mega
               EMPTY_ARRAY = []
 
               attr_accessor :raw
@@ -95,6 +97,12 @@ module ScaffoldParser
                   klass.new(element)
                 end
               end
+
+              def to_h_with_attrs
+                hash = HashWithAttributes.new({}, attributes)
+
+                hash
+              end
             end
           end
         TEMPLATE
@@ -104,18 +112,25 @@ module ScaffoldParser
         <<~TEMPLATE
           module Builders
             module BaseBuilder
-              attr_accessor :name, :data
+              attr_accessor :name, :data, :options
 
-              def initialize(name, data = {})
+              def initialize(name, data = {}, options = {})
                 @name = name
                 @data = data || {}
+                @options = options || {}
               end
 
               def to_xml
-                doc = Ox::Document.new(version: '1.0')
+                encoding = options[:encoding]
+
+                doc_options = { version: '1.0' }
+                doc_options[:encoding] = encoding if encoding
+                doc = Ox::Document.new(doc_options)
                 doc << builder
 
-                Ox.dump(doc, with_xml: true)
+                dump_options = { with_xml: true }
+                dump_options[:encoding] = encoding if encoding
+                Ox.dump(doc, dump_options)
               end
 
               def build_element(name, content)
@@ -135,6 +150,98 @@ module ScaffoldParser
           end
         TEMPLATE
       end
+
+      def hash_with_attrs_template
+        <<~TEMPLATE
+          class HashWithAttributes
+            def initialize(hash, attributes = nil)
+              @hash = hash
+              @attributes = attributes if attributes
+            end
+
+            def value
+              @hash
+            end
+
+            def attributes
+              @attributes ||= {}
+            end
+
+            def attributes=(attributes)
+              @attributes = attributes
+            end
+
+            def ==(other)
+              if other.respond_to?(:value) && other.respond_to?(:attributes)
+                value == other.value && other.attributes == attributes
+              else
+                value == other
+              end
+            end
+
+            def merge(other)
+              merged_hash = value.merge other.value
+              merged_attrs = attributes.merge other.attributes
+
+              self.class.new(merged_hash, merged_attrs)
+            end
+
+            def key?(key)
+              value.key? key
+            end
+
+            def [](key)
+              value[key]
+            end
+
+            def []=(key, key_value)
+              value[key] = key_value
+            end
+
+            def dig(*attrs)
+              value.dig(*attrs)
+            end
+          end
+        TEMPLATE
+      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
+      end
+
+      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']
+        modules.each do |klass|
+          requires << "parsers/#{klass.name.underscore}"
+          requires << "builders/#{klass.name.underscore}"
+        end
+        others.each do |klass|
+          requires << "parsers/#{klass.name.underscore}"
+          requires << "builders/#{klass.name.underscore}"
+        end
+        with_inheritance.each do |klass|
+          requires << "parsers/#{klass.name.underscore}"
+          requires << "builders/#{klass.name.underscore}"
+        end
+
+        if @options[:namespace]
+          requires = requires.map { |r| r.prepend("#{@options[:namespace].underscore}/") }
+        end
+
+        requires.map { |r| "require '#{r}'" }.join("\n")
+      end
     end
   end
 end

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

@@ -1,122 +1,53 @@
+require 'scaffold_parser/scaffolders/xsd/parser/stack'
+require 'scaffold_parser/scaffolders/xsd/parser/handlers/requires'
+
 module ScaffoldParser
   module Scaffolders
     class XSD
       class Parser
-        attr_reader :node
+        attr_reader :xsds
 
-        def self.call(node, options)
-          self.new(node, options).call
+        def self.call(xsds, options)
+          self.new(xsds, options).call
         end
 
-        def initialize(node, options)
-          @node = node
+        def initialize(xsds, options)
+          @xsds = xsds
           @options = options
         end
 
-        def call
-          puts "Scaffolding parser for #{node.to_name}" if @options[:verbose]
-
-          f = StringIO.new
-          f.indent = true if @options[:namespace]
-
-          f.puts "require '#{namespaced('parsers/base_parser')}'"
-          node.submodel_nodes.map { |n| namespaced(n.to_class_name.underscore.prepend('parsers/')) }.uniq.each { |n| f.puts "require '#{n}'" }
-          node.array_nodes.reject { |l| l.list_element.xs_type? }.each { |n| f.puts "require '#{namespaced(n.list_element.to_class_name.underscore.prepend('parsers/'))}'" }
-          f.puts
-
-          f.puts "module #{@options[:namespace]}" if @options[:namespace]
-          f.putsi "module Parsers"
-          f.putsi "  class #{node.to_class_name}"
-          f.putsi "    include BaseParser"
-
-          node.value_nodes.each do |method|
-            f.puts
-
-            method_name = method.to_name.underscore
-            at = method.to_name
-
-            f.putsi "    def #{method_name}"
-            f.putsi "      at '#{at}'"
-            f.putsi "    end"
-          end
-
-          node.submodel_nodes.each do |method|
-            f.puts
-
-            klass = method.to_class_name
-            method_name = method.to_name.underscore
-            at = method.to_name
-
-            f.putsi "    def #{method_name}"
-            f.putsi "      submodel_at(#{klass}, '#{at}')"
-            f.putsi "    end"
-          end
-
-          node.array_nodes.reject { |l| l.list_element.xs_type? }.each do |method|
-            f.puts
-
-            list_element_klass = method.list_element_klass
-            method_name = method.to_name.underscore
-            list_element_at = method.list_element_at.map { |e| "'#{e}'" }.join(', ')
+        STACK = Stack.instance
 
-            f.putsi "    def #{method_name}"
-            f.putsi "      array_of_at(#{list_element_klass}, [#{list_element_at}])"
-            f.putsi "    end"
-          end
-
-          node.array_nodes.select { |l| l.list_element.xs_type? }.each do |method|
-            f.puts
-
-            list_element_klass = method.list_element_klass
-            method_name = method.to_name.underscore
-            list_element_at = method.list_element_at.map { |e| "'#{e}'" }.join(', ')
-
-            f.putsi "    def #{method_name}"
-            f.putsi "      array_of_at(String, [#{list_element_at}])"
-            f.putsi "    end"
-          end
-
-          ### to_h method
-          lines = []
-          node.value_nodes.each do |node|
-            lines << "hash[:#{node.to_name.underscore}] = #{node.to_name.underscore} if has? '#{node.to_name}'"
-          end
-
-          node.submodel_nodes.each do |node|
-            lines << "hash[:#{node.to_name.underscore}] = #{node.to_name.underscore}.to_h_with_attrs if has? '#{node.to_name}'"
-          end
-          node.array_nodes.reject { |l| l.list_element.xs_type? }.each do |node|
-            lines << "hash[:#{node.to_name.underscore}] = #{node.to_name.underscore}.map(&:to_h_with_attrs) if has? '#{node.to_name}'"
-          end
-          node.array_nodes.select { |l| l.list_element.xs_type? }.each do |node|
-            lines << "hash[:#{node.to_name.underscore}] = #{node.to_name.underscore} if has? '#{node.to_name}'"
-          end
-          if lines.any?
-            f.puts
-
-            f.putsi "    def to_h_with_attrs"
-            f.putsi "      hash = HashWithAttributes.new({}, attributes)"
-            f.puts
-
-            lines.each do |line|
-              f.putsi "      #{line}"
+        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}"
+                end
+
+                handler.send(element.element_name, element)
+              end
             end
-            f.puts
-
-            f.putsi "      hash"
-            f.putsi "    end"
-          end
-          f.putsi "  end"
-          f.putsi "end"
-          f.puts "end" if @options[:namespace]
-
-          ["parsers/#{node.to_class_name.underscore}.rb", f.string.strip]
-        end
-
-        private
 
-        def namespaced(path)
-          [@options[:namespace]&.underscore, path].compact.join('/')
+          classes = STACK.to_a
         end
       end
     end