scaffold_parser 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7899b91e50516ffec5a13ce5215f131b9f80c630
-  data.tar.gz: 3162f40dede2ddef1a450b742f0dd6caa536b8b3
+  metadata.gz: a9ecbc5c73c858c25d5f97806fb148720065dcae
+  data.tar.gz: ca3a1f63c84c8dc18c08f6d8099167eb884797fd
 SHA512:
-  metadata.gz: 0bb8061b4f380d647698737b2c41c468a183855e384e32e4724fc4b9cee7a72b753fb775b3d5e9ad0e2a9d4dc7ed09e21d852247637b7e1080bb8d489ec646ac
-  data.tar.gz: 1e65927bacc4af7a59cbf6f9af928f00bb24833abed33afbdb2e74a75adf7316f0550b584eb62c7e03ba78d371ce787942eb7189e0bfbb915a67a2e6b7ea23af
+  metadata.gz: a4490d4c87ef3d9512b6b69997705ca613b62f788ee77d95b7df721b97dab4e397f8995a7fced42aae3ffb58b2a02138df6e70591d70dd2b8e08f90b880fae9d
+  data.tar.gz: efdd40de39de53466c90a607b2d301b6aa4c1d9345478091440140d57391fbee9c712855c0c2c74e3946d2fa6639f90fc91460df349d1b9899d0dd6c25958445

data/bin/scaffold_parser

@@ -10,9 +10,13 @@ abort 'Path to schema file as a first argument is required' unless path
 OptionParser.new do |opts|
   opts.banner = 'Usage: scaffold_parser <path_to_schema> [options]'
 
-  opts.on("-nNAMESPACE", "--namespace=NAMESPACE") do |v|
+  opts.on('-nNAMESPACE', '--namespace=NAMESPACE', 'Output all classes in given namespace') do |v|
     options[:namespace] = v
   end
+
+  opts.on('-v', '--verbose', 'Run verbosely') do |v|
+    options[:verbose] = v
+  end
 end.parse!
 
 ScaffoldParser.scaffold(path, options)

data/lib/scaffold_parser/nokogiri_patches.rb

@@ -18,15 +18,15 @@ module ScaffoldParser
       end
 
       def submodel_nodes
-        attribute_elements.select(&:parent_type?) + extension.submodel_nodes
+        @submodel_nodes ||= attribute_elements.select(&:parent_type?) + extension.submodel_nodes
       end
 
       def value_nodes
-        attribute_elements.select(&:end_type?) + extension.value_nodes
+        @value_nodes ||= attribute_elements.select(&:end_type?) + extension.value_nodes
       end
 
       def array_nodes
-        attribute_elements.select(&:list_type?) + extension.array_nodes
+        @array_nodes ||= attribute_elements.select(&:list_type?) + extension.array_nodes
       end
 
       def end_type?
@@ -57,7 +57,7 @@ module ScaffoldParser
       end
 
       def named_list?
-        definition.list_element.present? && definition.list_element.max_occurs > 1
+        !simple_list? && definition.list_element.present? && definition.list_element.max_occurs > 1
       end
 
       def list_element
@@ -89,11 +89,12 @@ module ScaffoldParser
       end
 
       def definition
-        if self['type'].present? && !self['type'].start_with?('xs:')
-          find_type(self['type'])
-        else
-          self
-        end
+        @definition ||=
+          if self['type'].present? && !self['type'].start_with?('xs:')
+            find_type(self['type'])
+          else
+            self
+          end
       end
 
       def extension
@@ -184,6 +185,10 @@ module ScaffoldParser
       def array_nodes
         []
       end
+
+      def definition
+        self
+      end
     end
   end
 end

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

@@ -0,0 +1,106 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Builder
+        attr_reader :node
+
+        def self.call(node, options)
+          self.new(node, options).call
+        end
+
+        def initialize(node, options)
+          @node = node
+          @options = options
+        end
+
+        def call
+          puts "Scaffolding builder for #{node.to_name}" if @options[:verbose]
+
+          f = StringIO.new
+          f.indent = true if @options[:namespace]
+
+          f.puts "require '#{namespaced('builders/base_builder')}'"
+          requires = node.submodel_nodes.map { |n| n.to_class_name.underscore }.uniq
+          requires.each { |r| f.puts "require '#{namespaced(r.prepend('builders/'))}'" }
+          requires = node.array_nodes.reject { |l| l.list_element.xs_type? }.uniq
+          requires.each { |n| f.puts "require '#{namespaced(n.list_element.to_class_name.underscore.prepend('builders/'))}'" }
+          f.puts
+
+          f.puts "module #{@options[:namespace]}" if @options[:namespace]
+          f.putsi "module Builders"
+          f.putsi "  class #{node.to_class_name}"
+          f.putsi "    include BaseBuilder"
+          f.puts
+
+          f.putsi "    def builder"
+          f.putsi "      root = Ox::Element.new(element_name)"
+
+          node.value_nodes.each do |node|
+            f.puts
+            f.putsi "      if attributes.key? :#{node.to_name.underscore}"
+            f.putsi "        element = Ox::Element.new('#{node.to_name}')"
+            f.putsi "        element << attributes[:#{node.to_name.underscore}] if attributes[:#{node.to_name.underscore}]"
+            f.putsi "        root << element"
+            f.putsi "      end"
+          end
+
+          node.submodel_nodes.each do |node|
+            f.puts
+            f.putsi "      if attributes.key? :#{node.to_name.underscore}"
+            f.putsi "        root << #{node.to_class_name}.new(attributes[:#{node.to_name.underscore}], '#{node.to_name}').builder"
+            f.putsi "      end"
+          end
+
+          node.array_nodes.reject { |l| l.list_element.xs_type? }.each do |node|
+            if node.named_list?
+              f.puts
+              f.putsi "      if attributes.key? :#{node.to_name.underscore}"
+              f.putsi "        element = Ox::Element.new('#{node.to_name}')"
+              f.putsi "        attributes[:#{node.to_name.underscore}].each { |i| element << #{node.list_element.to_class_name}.new(i, '#{node.list_element.to_name}').builder }"
+              f.putsi "        root << element"
+              f.putsi "      end"
+            else # simple_list
+              f.puts
+              f.putsi "      if attributes.key? :#{node.to_name.underscore}"
+              f.putsi "        attributes[:#{node.to_name.underscore}].each { |i| root << #{node.list_element.to_class_name}.new(i, '#{node.list_element.to_name}').builder }"
+              f.putsi "      end"
+            end
+          end
+
+          node.array_nodes.select { |l| l.list_element.xs_type? }.each do |node|
+            f.puts
+
+            if node.named_list?
+              f.putsi "      if attributes.key? :#{node.to_name.underscore}"
+              f.putsi "        element = Ox::Element.new('#{node.to_name}')"
+              f.putsi "        attributes[:#{node.to_name.underscore}].map { |i| Ox::Element.new('#{node.list_element.to_name}') << i }.each { |i| element << i }"
+              f.putsi "        root << element"
+              f.putsi "      end"
+            else #simple_list
+              f.putsi "      if attributes.key? :#{node.to_name.underscore}"
+              f.putsi "        attributes[:#{node.to_name.underscore}].map { |i| Ox::Element.new('#{node.to_name}') << i }.each { |i| root << i }"
+              f.putsi "      end"
+            end
+          end
+
+          f.puts
+          f.putsi "      root"
+          f.putsi "    end"
+
+
+          f.putsi "  end"
+          f.putsi "end"
+          f.puts "end" if @options[:namespace]
+
+          ["builders/#{node.to_class_name.underscore}.rb", f.string.strip]
+        end
+
+        private
+
+        def namespaced(path)
+          [@options[:namespace]&.underscore, path].compact.join('/')
+        end
+      end
+    end
+  end
+end

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

@@ -14,97 +14,105 @@ module ScaffoldParser
         end
 
         def call
-          path = "./tmp/#{node.to_class_name.underscore}.rb"
+          puts "Scaffolding parser for #{node.to_name}" if @options[:verbose]
 
-          File.open(path, 'wb') do |f|
-            f.indent = true if @options[:namespace]
+          f = StringIO.new
+          f.indent = true if @options[:namespace]
 
-            f.puts "require '#{namespaced('base_element')}'"
-            node.submodel_nodes.map { |n| namespaced(n.to_class_name.underscore) }.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)}'" }
+          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
 
-            f.puts "module #{@options[:namespace]}" if @options[:namespace]
-            f.putsi "class #{node.to_class_name}"
-            f.putsi "  include BaseElement"
+            method_name = method.to_name.underscore
+            at = method.to_name
 
-            node.value_nodes.each do |method|
-              f.puts
+            f.putsi "    def #{method_name}"
+            f.putsi "      at :#{at}"
+            f.putsi "    end"
+          end
 
-              method_name = method.to_name.underscore
-              at = method.to_name
+          node.submodel_nodes.each do |method|
+            f.puts
 
-              f.putsi "  def #{method_name}"
-              f.putsi "    at :#{at}"
-              f.putsi "  end"
-            end
+            klass = method.to_class_name
+            method_name = method.to_name.underscore
+            at = method.to_name
 
-            node.submodel_nodes.each do |method|
-              f.puts
+            f.putsi "    def #{method_name}"
+            f.putsi "      submodel_at(#{klass}, :#{at})"
+            f.putsi "    end"
+          end
 
-              klass = method.to_class_name
-              method_name = method.to_name.underscore
-              at = method.to_name
+          node.array_nodes.reject { |l| l.list_element.xs_type? }.each do |method|
+            f.puts
 
-              f.putsi "  def #{method_name}"
-              f.putsi "    submodel_at(#{klass}, :#{at})"
-              f.putsi "  end"
-            end
+            list_element_klass = method.list_element_klass
+            method_name = method.to_name.underscore
+            list_element_at = method.list_element_at.map { |e| ":#{e}" }.join(', ')
 
-            node.array_nodes.reject { |l| l.list_element.xs_type? }.each do |method|
-              f.puts
+            f.putsi "    def #{method_name}"
+            f.putsi "      array_of_at(#{list_element_klass}, [#{list_element_at}])"
+            f.putsi "    end"
+          end
 
-              list_element_klass = method.list_element_klass
-              method_name = method.to_name.underscore
-              list_element_at = method.list_element_at.map { |e| ":#{e}" }.join(', ')
+          node.array_nodes.select { |l| l.list_element.xs_type? }.each do |method|
+            f.puts
 
-              f.putsi "  def #{method_name}"
-              f.putsi "    array_of_at(#{list_element_klass}, [#{list_element_at}])"
-              f.putsi "  end"
-            end
+            list_element_klass = method.list_element_klass
+            method_name = method.to_name.underscore
+            list_element_at = method.list_element_at.map { |e| ":#{e}" }.join(', ')
 
-            node.array_nodes.select { |l| l.list_element.xs_type? }.each do |method|
-              f.puts
+            f.putsi "    def #{method_name}"
+            f.putsi "      array_of_at(String, [#{list_element_at}])"
+            f.putsi "    end"
+          end
 
-              list_element_klass = method.list_element_klass
-              method_name = method.to_name.underscore
-              list_element_at = method.list_element_at.map { |e| ":#{e}" }.join(', ')
+          ### to_h method
+          lines = []
+          node.value_nodes.each do |node|
+            lines << "hash[:#{node.to_name.underscore}] = #{node.to_name.underscore} if raw.key? :#{node.to_name}"
+          end
 
-              f.putsi "  def #{method_name}"
-              f.putsi "    array_of_at(String, [#{list_element_at}])"
-              f.putsi "  end"
-            end
+          node.submodel_nodes.each do |node|
+            lines << "hash[:#{node.to_name.underscore}] = #{node.to_name.underscore}.to_h if raw.key? :#{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) if raw.key? :#{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 raw.key? :#{node.to_name}"
+          end
+          if lines.any?
+            f.puts
+            # lines.last.chop!
+            # first_line = lines.shift
 
-            ### to_h method
-            lines = []
-            node.value_nodes.each do |node|
-              lines << "#{node.to_name.underscore}: #{node.to_name.underscore},"
-            end
-            node.submodel_nodes.each do |node|
-              lines << "#{node.to_name.underscore}: #{node.to_name.underscore}.to_h,"
-            end
-            node.array_nodes.reject { |l| l.list_element.xs_type? }.each do |node|
-              lines << "#{node.to_name.underscore}: #{node.to_name.underscore}.map(&:to_h),"
-            end
-            node.array_nodes.select { |l| l.list_element.xs_type? }.each do |node|
-              lines << "#{node.to_name.underscore}: #{node.to_name.underscore},"
-            end
-            if lines.any?
-              f.puts
-              lines.last.chop!
-              first_line = lines.shift
-
-              f.putsi "  def to_h"
-              f.putsi "    { #{first_line}"
-              lines.each do |line|
-                f.putsi "      #{line}"
-              end
-              f.putsi "    }.delete_if { |k, v| v.nil? || v.empty? }"
-              f.putsi "  end"
+            f.putsi "    def to_h"
+            f.putsi "      hash = {}"
+            f.puts
+
+            lines.each do |line|
+              f.putsi "      #{line}"
             end
-            f.putsi "end"
-            f.puts "end" if @options[:namespace]
+            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

data/lib/scaffold_parser/scaffolders/xsd.rb

@@ -1,40 +1,130 @@
 require 'scaffold_parser/scaffolders/xsd/parser'
+require 'scaffold_parser/scaffolders/xsd/builder'
 
 module ScaffoldParser
   module Scaffolders
     class XSD
-      def self.call(doc, options, already_scaffolded_subelements = [])
-        self.new(doc, options, already_scaffolded_subelements).call
+      def self.call(doc, options)
+        self.new(doc, options).call
       end
 
-      def initialize(doc, options, already_scaffolded_subelements)
+      def initialize(doc, options)
         @doc = doc
         @options = options
-        @already_scaffolded_subelements = already_scaffolded_subelements
       end
 
       def call
-        unless Dir.exists?('./tmp/')
-          Dir.mkdir('./tmp/')
-          puts './tmp/ directory created'
-        end
+        puts "Starting collectiong elements to scaffold" if @options[:verbose]
+
+        unscaffolded_elements = collect_unscaffolded_subelements(@doc) + @doc.submodel_nodes
 
-        unscaffolded_subelements.each do |subelement|
-          @already_scaffolded_subelements << subelement.to_class_name
+        puts "Collected #{unscaffolded_elements.size} elements to scaffold" if @options[:verbose]
 
-          Parser.call(subelement.definition, @options)
-          self.class.call(subelement.definition, @options, @already_scaffolded_subelements)
+        code = unscaffolded_elements.flat_map do |element|
+          [Parser.call(element.definition, @options), Builder.call(element.definition, @options)]
         end
+
+        code.push ['parsers/base_parser.rb', base_element_template]
+        code.push ['builders/base_builder.rb', base_builder_template]
       end
 
       private
 
-      def unscaffolded_subelements
-        all = @doc.submodel_nodes.to_a + @doc.array_nodes.map(&:list_element)
-
-        all
+      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| @already_scaffolded_subelements.include?(node.to_class_name) }
+          .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_element_template
+        <<~TEMPLATE
+          module Parsers
+            module BaseParser
+              EMPTY_ARRAY = []
+
+              attr_accessor :raw
+
+              def initialize(raw)
+                @raw = raw
+              end
+
+              private
+
+              def at(locator)
+                return nil if raw.nil?
+
+                raw[locator]
+              end
+
+              def submodel_at(klass, locator)
+                element_xml = at locator
+
+                klass.new(element_xml) if element_xml
+              end
+
+              def array_of_at(klass, locator)
+                return EMPTY_ARRAY if raw.nil?
+
+                elements = raw.dig(*locator) || EMPTY_ARRAY
+                if elements.is_a?(Hash) || elements.is_a?(String)
+                  elements = [elements]
+                end
+
+                elements.map do |raw|
+                  klass.new(raw)
+                end
+              end
+
+              def all(locator)
+                return EMPTY_ARRAY if raw.nil?
+
+                result = raw[locator]
+
+                if result.is_a? Hash
+                  [result]
+                elsif result.is_a? Array
+                  result
+                else
+                  EMPTY_ARRAY
+                end
+              end
+            end
+          end
+        TEMPLATE
+      end
+
+      def base_builder_template
+        <<~TEMPLATE
+          module Builders
+            module BaseBuilder
+              attr_accessor :attributes, :element_name
+
+              def initialize(attributes = {}, element_name)
+                @element_name = element_name
+                @attributes = attributes || {}
+              end
+
+              def to_xml
+                doc = Ox::Document.new(version: '1.0')
+                doc << builder
+
+                Ox.dump(doc, with_xml: true)
+              end
+            end
+          end
+        TEMPLATE
       end
     end
   end

data/lib/scaffold_parser.rb

@@ -6,10 +6,35 @@ require 'scaffold_parser/scaffolders/xsd'
 
 Nokogiri::XML::Element.include ScaffoldParser::NokogiriPatches::Element
 Nokogiri::XML::Document.include ScaffoldParser::NokogiriPatches::Document
-File.include ScaffoldParser::FilePatches
+StringIO.include ScaffoldParser::FilePatches
 
 module ScaffoldParser
   def self.scaffold(path, options = {})
+    unless Dir.exists?('./tmp/')
+      Dir.mkdir('./tmp/')
+      puts './tmp/ directory created'
+    end
+
+    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|
+      complete_path = path.prepend('./tmp/')
+
+      puts "Writing out #{complete_path}" if options[:verbose]
+
+      File.open(complete_path, 'wb') { |f| f.write content }
+    end
+  end
+
+  def self.scaffold_to_string(path, options = {})
     doc = Nokogiri::XML(File.open(path))
 
     Scaffolders::XSD.call(doc, options)

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.2.0'
+  spec.version       = '0.3.0'
   spec.authors       = ['Premysl Donat']
   spec.email         = ['pdonat@seznam.cz']
 
@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'nokogiri'
   spec.add_development_dependency 'activesupport'
+  spec.add_development_dependency 'saharspec'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scaffold_parser
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Premysl Donat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-25 00:00:00.000000000 Z
+date: 2018-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: saharspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ''
 email:
 - pdonat@seznam.cz
@@ -116,6 +130,7 @@ files:
 - lib/scaffold_parser/file_patches.rb
 - lib/scaffold_parser/nokogiri_patches.rb
 - lib/scaffold_parser/scaffolders/xsd.rb
+- lib/scaffold_parser/scaffolders/xsd/builder.rb
 - lib/scaffold_parser/scaffolders/xsd/parser.rb
 - scaffold_parser.gemspec
 homepage: https://github.com/Masa331/scaffold_parser