scaffold_parser 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b4ffe5b906e5b2e028aa175ec02018bef03aee4
-  data.tar.gz: 60e240f28ca2ad99677c27e846468d54bea1dcc8
+  metadata.gz: 7899b91e50516ffec5a13ce5215f131b9f80c630
+  data.tar.gz: 3162f40dede2ddef1a450b742f0dd6caa536b8b3
 SHA512:
-  metadata.gz: 691f8d7819b3f41aa64aee39b49872e901a1b9ef4136b00fd8e9b6b927903eaa3c4f607bad91081da461c1de2b2baaf5bfa186c8ffd82615ae015f241beeb278
-  data.tar.gz: e834263aba43d562a45ae7a6ab5766c6d4d615b98b85fee16e3d5d1907af11b935cd20d06d875c7ddcf977fb8fda25560c21f4b363448d113644b0a022b3ab48
+  metadata.gz: 0bb8061b4f380d647698737b2c41c468a183855e384e32e4724fc4b9cee7a72b753fb775b3d5e9ad0e2a9d4dc7ed09e21d852247637b7e1080bb8d489ec646ac
+  data.tar.gz: 1e65927bacc4af7a59cbf6f9af928f00bb24833abed33afbdb2e74a75adf7316f0550b584eb62c7e03ba78d371ce787942eb7189e0bfbb915a67a2e6b7ea23af

data/lib/scaffold_parser.rb

@@ -1,8 +1,8 @@
-require 'scaffold_parser/builder'
 require 'nokogiri'
 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
@@ -12,6 +12,6 @@ module ScaffoldParser
   def self.scaffold(path, options = {})
     doc = Nokogiri::XML(File.open(path))
 
-    Builder.call(doc, options)
+    Scaffolders::XSD.call(doc, options)
   end
 end

data/lib/scaffold_parser/nokogiri_patches.rb

@@ -1,203 +1,175 @@
-require 'active_support/all'
-
 module ScaffoldParser
   module NokogiriPatches
+    class DefinitionNotFound < StandardError; end
+
     module Element
-      def attribute_elements
-        if name == 'complexType'
-          xpath('xs:sequence/xs:element|xs:sequence/xs:sequence/xs:element|xs:sequence/xs:choice/xs:sequence/xs:element|xs:sequence/xs:choice/xs:element')
-        elsif name == 'element'
-          xpath('xs:complexType/xs:sequence/xs:element')
-        else
-          fail 'whatever'
+      class BlankExtension
+        def submodel_nodes
+          []
         end
-      end
-
-      def parent_nodes
-        attribute_elements.select(&:parent_type?) + extension_parent_nodes
-      end
 
-      def end_nodes
-        attribute_elements.select(&:end_type?) + extension_end_nodes
-      end
+        def value_nodes
+          []
+        end
 
-      def list_nodes
-        attribute_elements.select(&:list_type?) + extension_list_nodes
+        def array_nodes
+          []
+        end
       end
 
-      def extension_end_nodes
-        extension ? extension.end_nodes : []
+      def submodel_nodes
+        attribute_elements.select(&:parent_type?) + extension.submodel_nodes
       end
 
-      def extension_parent_nodes
-        extension ? extension.parent_nodes : []
+      def value_nodes
+        attribute_elements.select(&:end_type?) + extension.value_nodes
       end
 
-      def extension_list_nodes
-        extension ? extension.list_nodes : []
+      def array_nodes
+        attribute_elements.select(&:list_type?) + extension.array_nodes
       end
 
       def end_type?
-        if custom_type?
-          type_def&.end_type?
-        else
-          xs_type? || (no_type? && complex_types.empty? && !complex_type? && !list_type?)
-        end
+        (xs_type? && !list_type?) || (no_type? && complex_types.empty? && !complex_type? && !list_type?)
       end
 
       def parent_type?
-        if custom_type?
-          type_def&.parent_type?
+        (complex_type? || complex_types.any?) && !list_type?
+      end
+
+      def max_occurs
+        case self['maxOccurs']
+        when 'unbounded'
+          Float::INFINITY
+        when String
+          self['maxOccurs'].to_i
         else
-          (complex_type? || complex_types.any?) && !list_type?
+          1
         end
       end
 
       def list_type?
-        if list_element
-          max_occure = list_element['maxOccurs']
-
-          max_occure == 'unbounded' || max_occure.to_i > 1
-        end
+        simple_list? || named_list?
       end
 
-      def list_element_klass
-        if list_element
-          if list_element['type']
-            list_element['type'].camelize
-          else
-            list_element['name'].camelize
-          end
-        end
+      def simple_list?
+        max_occurs > 1
       end
 
-      def list_element_at
-        if list_element
-          [at_xpath('xs:complexType').to_location, list_element.to_location]
-        end
+      def named_list?
+        definition.list_element.present? && definition.list_element.max_occurs > 1
       end
 
-      def to_class_name
-        if self['type']
-          self['type'].camelize
+      def list_element
+        if simple_list?
+          self
         else
-          to_name.camelize
+          xpath('xs:complexType/xs:sequence/xs:element').first
         end
       end
 
-      def to_file_name
-        to_class_name.underscore
-      end
-
-      def to_require
-        if parent_type?
-          to_class_name.underscore
-        elsif list_type?
-          if list_element
-            list_element.to_class_name.underscore
-          end
+      def list_element_klass
+        if simple_list?
+          definition.to_name.camelize
+        elsif named_list?
+          list_element.definition.to_name.camelize
         end
       end
 
-      def to_method_name
-        to_name.underscore
-      end
-
-      def to_location
-        to_name
+      def list_element_at
+        if simple_list?
+          [to_name]
+        elsif named_list?
+          [at_xpath('xs:complexType').to_name, list_element.to_name]
+        end
       end
 
-      def custom_type?
-        self['type'].present? && !xs_type?
+      def to_class_name
+        definition.to_name.camelize
       end
 
-      def type_def
-        find_type(self['type'])
+      def definition
+        if self['type'].present? && !self['type'].start_with?('xs:')
+          find_type(self['type'])
+        else
+          self
+        end
       end
 
-      def list_element
-        eles = xpath('xs:complexType/xs:sequence/xs:element')
+      def extension
+        complex_ext = at_xpath('xs:complexType/xs:complexContent/xs:extension')
+        # Can be also simple extension but i don't have to do anything with these:
+        # simple_ext = at_xpath('xs:complexType/xs:simpleContent/xs:extension')
 
-        if eles.size == 1
-          eles.first
-        end
+        complex_ext ? find_type(complex_ext['base']) : BlankExtension.new
       end
 
-      def extension
-        elem = at_xpath('xs:complexType/xs:complexContent/xs:extension')
+      def extended_simple_type?
+        simple_ext = at_xpath('xs:complexType/xs:simpleContent/xs:extension')
 
-        if elem
-          find_type(elem['base'])
-        end
+        simple_ext.present?
       end
 
       def xs_type?
-        self['type'].present? && self['type'].start_with?('xs:')
+        (definition['type'].present? && definition['type'].start_with?('xs:')) || extended_simple_type?
       end
 
-      private
-
-      def to_name
-        if self['name']
-          self['name']
-        else
-          at_xpath('..')['name']
-        end
+      def complex_type?
+        definition.name == 'complexType'
       end
 
       def complex_types
-        xpath('xs:complexType')
+        definition.xpath('xs:complexType[not(xs:simpleContent)]')
       end
 
       def no_type?
-        self['type'].blank?
+        definition['type'].blank?
       end
 
-      def complex_type?
-        name == 'complexType'
+      def to_name
+        self['name'] || at_xpath('..')['name']
       end
 
-      def simple_type?
-        name == 'simpleType'
+      private
+
+      def attribute_elements
+        xpath('xs:sequence/xs:element',
+              'xs:sequence/xs:sequence/xs:element',
+              'xs:sequence/xs:choice/xs:sequence/xs:element',
+              'xs:sequence/xs:choice/xs:element',
+              'xs:complexType/xs:sequence/xs:element',
+              'xs:complexType/xs:choice/xs:element',
+              'xs:complexType/xs:complexContent/xs:extension/xs:sequence/xs:element',
+              'xs:complexContent/xs:extension/xs:sequence/xs:element'
+             )
       end
 
       def find_type(name)
-        doc = includes.find do |doc|
-          doc.at_xpath("//*[@name='#{name}']").present?
-        end
-
-        if doc.blank?
-          fail "Cant find element definition for '#{name}'. Might be not enough includes?"
-        end
-
-        doc.at_xpath("//*[@name='#{name}']")
-      end
+        if element = document.at_xpath("//*[@name='#{name}']")
+          return element
+        else
+          definition_schema = collect_includes.find do |doc|
+            doc.at_xpath("//*[@name='#{name}']").present?
+          end
 
-      def includes
-        original_path = ENV['XSD_PATH'] || './'
+          if definition_schema.blank?
+            fail DefinitionNotFound.new("Couldn't find type definiton for '#{name}' in any included schema.")
+          end
 
-        collect_includes([], [], self) + [self]
+          definition_schema.at_xpath("//*[@name='#{name}']")
+        end
       end
 
-      def collect_includes(collection, names, doc)
-        original_path = ENV['XSD_PATH'] || './'
-
+      def collect_includes(doc = self, collection = [], names = [])
         new_names = doc.xpath('//xs:include').map { |incl| incl['schemaLocation'] }
 
         (new_names - names).each do |name|
-          if names.include? name
-            next
-          else
-            dir = original_path.split('/')
-            include_path = (dir + [name]).join('/')
-
-            new_doc = Nokogiri::XML(File.open(include_path))
+          new_doc = Nokogiri::XML(File.open(name))
 
-            collection << new_doc
-            names << name
+          collection << new_doc
+          names << name
 
-            collect_includes(collection, names, new_doc)
-          end
+          collect_includes(new_doc, collection, names)
         end
 
         collection
@@ -205,11 +177,11 @@ module ScaffoldParser
     end
 
     module Document
-      def parent_nodes
+      def submodel_nodes
         xpath('xs:schema/xs:complexType|xs:schema/xs:element')
       end
 
-      def list_nodes
+      def array_nodes
         []
       end
     end

data/lib/scaffold_parser/scaffolders/xsd.rb

@@ -0,0 +1,41 @@
+require 'scaffold_parser/scaffolders/xsd/parser'
+
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      def self.call(doc, options, already_scaffolded_subelements = [])
+        self.new(doc, options, already_scaffolded_subelements).call
+      end
+
+      def initialize(doc, options, already_scaffolded_subelements)
+        @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
+
+        unscaffolded_subelements.each do |subelement|
+          @already_scaffolded_subelements << subelement.to_class_name
+
+          Parser.call(subelement.definition, @options)
+          self.class.call(subelement.definition, @options, @already_scaffolded_subelements)
+        end
+      end
+
+      private
+
+      def unscaffolded_subelements
+        all = @doc.submodel_nodes.to_a + @doc.array_nodes.map(&:list_element)
+
+        all
+          .reject(&:xs_type?)
+          .reject { |node| @already_scaffolded_subelements.include?(node.to_class_name) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+module ScaffoldParser
+  module Scaffolders
+    class XSD
+      class Parser
+        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
+          path = "./tmp/#{node.to_class_name.underscore}.rb"
+
+          File.open(path, 'wb') do |f|
+            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
+
+            f.puts "module #{@options[:namespace]}" if @options[:namespace]
+            f.putsi "class #{node.to_class_name}"
+            f.putsi "  include BaseElement"
+
+            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(', ')
+
+              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 << "#{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"
+            end
+            f.putsi "end"
+            f.puts "end" if @options[:namespace]
+          end
+        end
+
+        private
+
+        def namespaced(path)
+          [@options[:namespace]&.underscore, path].compact.join('/')
+        end
+      end
+    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.1.0'
+  spec.version       = '0.2.0'
   spec.authors       = ['Premysl Donat']
   spec.email         = ['pdonat@seznam.cz']
 
@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r{^(test|spec|features)/}) || f.end_with?('.xsd')
   end
   spec.bindir        = 'bin'
   spec.executables   = ['scaffold_parser']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scaffold_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Premysl Donat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-18 00:00:00.000000000 Z
+date: 2018-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,9 +113,10 @@ files:
 - bin/scaffold_parser
 - bin/setup
 - lib/scaffold_parser.rb
-- lib/scaffold_parser/builder.rb
 - lib/scaffold_parser/file_patches.rb
 - lib/scaffold_parser/nokogiri_patches.rb
+- lib/scaffold_parser/scaffolders/xsd.rb
+- lib/scaffold_parser/scaffolders/xsd/parser.rb
 - scaffold_parser.gemspec
 homepage: https://github.com/Masa331/scaffold_parser
 licenses:

data/lib/scaffold_parser/builder.rb

@@ -1,129 +0,0 @@
-module ScaffoldParser
-  class Builder
-    def self.call(doc, options, already_scaffolded_classes = [])
-      self.new(doc, options, already_scaffolded_classes).call
-    end
-
-    def initialize(doc, options, already_scaffolded_classes)
-      @doc = doc
-      @options = options
-      @already_scaffolded_classes = already_scaffolded_classes
-    end
-
-    def call
-      unless Dir.exists?('./tmp/')
-        Dir.mkdir('./tmp/')
-        puts './tmp/ directory created'
-      end
-
-      parent_nodes = @doc.parent_nodes.select do |node|
-        !@already_scaffolded_classes.include? node.to_class_name
-      end
-
-      parent_nodes.each do |parent|
-        @already_scaffolded_classes << parent.to_class_name
-
-        if parent.custom_type?
-          type_def = parent.type_def
-
-          scaffold_class(type_def)
-          self.class.call(type_def, @options, @already_scaffolded_classes)
-        else
-          scaffold_class(parent)
-          self.class.call(parent, @options, @already_scaffolded_classes)
-        end
-      end
-
-      list_nodes = @doc.list_nodes.select do |node|
-        !@already_scaffolded_classes.include? node.list_element.to_class_name
-      end
-
-      list_nodes.each do |list|
-        @already_scaffolded_classes << list.list_element.to_class_name
-
-        if list.list_element.custom_type?
-          type_def = list.list_element.type_def
-
-          scaffold_class(type_def)
-          self.class.call(type_def, @options, @already_scaffolded_classes)
-        elsif !list.list_element.xs_type?
-          scaffold_class(list.list_element)
-          self.class.call(list.list_element, @options, @already_scaffolded_classes)
-        end
-      end
-    end
-
-    private
-
-    def namespaced(path)
-      [@options[:namespace]&.underscore, path].compact.join('/')
-    end
-
-    def scaffold_class(node)
-      path = "./tmp/#{node.to_file_name}.rb"
-
-      File.open(path, 'wb') do |f|
-        f.indent = true if @options[:namespace]
-
-        f.puts "require '#{namespaced('base_element')}'"
-        node.parent_nodes.each { |n| f.puts "require '#{namespaced(n.to_require)}'" }
-        node.list_nodes.reject { |l| l.list_element.xs_type? }.each { |n| f.puts "require '#{namespaced(n.to_require)}'" }
-        f.puts
-
-        f.puts "module #{@options[:namespace]}" if @options[:namespace]
-        f.putsi "class #{node.to_class_name}"
-        f.putsi "  include BaseElement"
-
-        node.end_nodes.each do |method|
-          f.puts
-
-          method_name = method.to_method_name
-          at = method.to_location
-
-          f.putsi "  def #{method_name}"
-          f.putsi "    at :#{at}"
-          f.putsi "  end"
-        end
-
-        node.parent_nodes.each do |method|
-          f.puts
-
-          klass = method.to_class_name
-          method_name = method.to_method_name
-          at = method.to_location
-
-          f.putsi "  def #{method_name}"
-          f.putsi "    submodel_at(#{klass}, :#{at})"
-          f.putsi "  end"
-        end
-
-        node.list_nodes.reject { |l| l.list_element.xs_type? }.each do |method|
-          f.puts
-
-          list_element_klass = method.list_element_klass
-          method_name = method.to_method_name
-          list_element_at = method.list_element_at.map { |e| ":#{e}" }.join(', ')
-
-          f.putsi "  def #{method_name}"
-          f.putsi "    array_of_at(#{list_element_klass}, [#{list_element_at}])"
-          f.putsi "  end"
-        end
-
-        node.list_nodes.select { |l| l.list_element.xs_type? }.each do |method|
-          f.puts
-
-          list_element_klass = method.list_element_klass
-          method_name = method.to_method_name
-          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
-
-        f.putsi "end"
-        f.puts "end" if @options[:namespace]
-      end
-    end
-  end
-end