shale 0.3.1 → 0.6.0

data/exe/shaleb

@@ -1,14 +1,32 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'optparse'
 
-base_path = File.expand_path('../lib', __dir__)
+def require_local_or_global(path)
+  base_path = File.expand_path('../lib', __dir__)
 
-if File.exist?(base_path)
-  require_relative '../lib/shale/schema'
-else
-  require 'shale/schema'
+  if File.exist?(base_path)
+    require_relative "../lib/#{path}"
+  else
+    require path
+  end
+end
+
+require_local_or_global('shale/schema')
+
+def load_xml_parser
+  require_local_or_global('shale/adapter/nokogiri')
+  Shale.xml_adapter = Shale::Adapter::Nokogiri
+rescue LoadError
+  begin
+    require_local_or_global('shale/adapter/rexml')
+    Shale.xml_adapter = Shale::Adapter::REXML
+  rescue LoadError
+    puts "Can't load XML parser. Make sure Nokogiri or REXML is installed on your system!"
+    exit
+  end
 end
 
 params = {}
@@ -16,11 +34,17 @@ params = {}
 ARGV << '-h' if ARGV.empty?
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: shaleb [options]\nexample: shaleb -i data_model.rb -c MyRoot"
-
-  opts.on('-i INPUT', '--input', 'Input file')
-  opts.on('-o OUTPUT', '--output', 'Output file (defaults to STDOUT)')
-  opts.on('-c CLASS', '--class CLASS', 'Shale model class name')
+  opts.banner = <<~BANNER
+    Usage: shaleb [options]
+    example generate schema from Shale model: shaleb -g -i data_model.rb -c MyRoot
+    example generate Shale model from schema: shaleb -c -i schema1.json,schema2.json -c MyRoot
+  BANNER
+
+  opts.on('-g', '--generate', 'generate schema from Shale model')
+  opts.on('-c', '--compile', 'compile schema into Shale model')
+  opts.on('-i INPUT', '--input', Array, 'Input file')
+  opts.on('-o OUTPUT', '--output', 'Output (defaults to STDOUT)')
+  opts.on('-r ROOT', '--root ROOT', 'Shale model class name')
   opts.on('-f FORMAT', '--format FORMAT', 'Schema format: JSON (default), XML')
   opts.on('-p', '--pretty', 'Pretty print generated schema')
 
@@ -30,46 +54,94 @@ OptionParser.new do |opts|
   end
 end.parse!(into: params)
 
-input_path = File.expand_path(params[:input], Dir.pwd)
-
-unless File.exist?(input_path)
-  puts "File '#{input_path}' does not exist"
-  exit
-end
+if params[:compile]
+  unless params[:input]
+    puts 'Input file is required: shaleb -c -i schema1.json,schema2.json'
+    exit
+  end
 
-unless params[:class]
-  puts 'Model class is required'
-  exit
-end
+  schemas = params[:input].map do |file|
+    path = File.expand_path(file, Dir.pwd)
 
-require input_path
+    if File.exist?(path)
+      File.read(path)
+    else
+      puts "File '#{path}' does not exist"
+      exit
+    end
+  end
 
-klass = Object.const_get(params[:class])
+  if params[:format] == 'xml'
+    load_xml_parser
+    models = Shale::Schema.from_xml(schemas)
+  else
+    models = Shale::Schema.from_json(schemas, root_name: params[:root])
+  end
 
-if params[:format] == 'xml'
   if params[:output]
-    base_name = File.basename(params[:output], File.extname(params[:output]))
-    schemas = Shale::Schema.to_xml(klass, base_name, pretty: params[:pretty])
+    dir = File.expand_path(params[:output], Dir.pwd)
+    FileUtils.mkdir_p(dir) unless File.directory?(dir)
 
-    schemas.map do |name, xml|
-      File.write(File.expand_path(name, Dir.pwd), xml)
+    models.each do |name, model|
+      output_path = File.join(dir, "#{name}.rb")
+      File.write(output_path, model)
     end
   else
-    schemas = Shale::Schema.to_xml(klass, pretty: params[:pretty])
-
-    output = schemas.map do |name, xml|
-      "<!-- #{name} -->\n#{xml}\n"
+    output = models.map do |name, model|
+      "# --- #{name}.rb ---\n#{model}\n"
     end.join("\n")
 
     puts output
   end
 else
-  schema = Shale::Schema.to_json(klass, pretty: params[:pretty])
+  unless params[:input]
+    puts 'Input file is required: shaleb -i model.rb -r MyClass'
+    exit
+  end
 
-  if params[:output]
-    output_path = File.expand_path(params[:output], Dir.pwd)
-    File.write(output_path, schema)
+  input_path = File.expand_path(params[:input][0], Dir.pwd)
+
+  unless File.exist?(input_path)
+    puts "File '#{input_path}' does not exist"
+    exit
+  end
+
+  unless params[:root]
+    puts 'Model class is required: shaleb -i model.rb -r MyClass'
+    exit
+  end
+
+  require input_path
+
+  klass = Object.const_get(params[:root])
+
+  if params[:format] == 'xml'
+    load_xml_parser
+
+    if params[:output]
+      base_name = File.basename(params[:output], File.extname(params[:output]))
+      schemas = Shale::Schema.to_xml(klass, base_name, pretty: params[:pretty])
+
+      schemas.map do |name, xml|
+        File.write(File.expand_path(name, Dir.pwd), xml)
+      end
+    else
+      schemas = Shale::Schema.to_xml(klass, pretty: params[:pretty])
+
+      output = schemas.map do |name, xml|
+        "<!-- #{name} -->\n#{xml}\n"
+      end.join("\n")
+
+      puts output
+    end
   else
-    puts schema
+    schema = Shale::Schema.to_json(klass, pretty: params[:pretty])
+
+    if params[:output]
+      output_path = File.expand_path(params[:output], Dir.pwd)
+      File.write(output_path, schema)
+    else
+      puts schema
+    end
   end
 end

data/lib/shale/adapter/nokogiri/document.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Shale
+  module Adapter
+    module Nokogiri
+      # Wrapper around Nokogiri API
+      #
+      # @api private
+      class Document
+        # Initialize object
+        #
+        # @api private
+        def initialize
+          @doc = ::Nokogiri::XML::Document.new
+          @namespaces = {}
+        end
+
+        # Return Nokogiri document
+        #
+        # @return [::Nokogiri::XML::Document]
+        #
+        # @api private
+        def doc
+          if @doc.root
+            @namespaces.each do |prefix, namespace|
+              @doc.root.add_namespace(prefix, namespace)
+            end
+          end
+
+          @doc
+        end
+
+        # Create Nokogiri element
+        #
+        # @param [String] name Name of the XML element
+        #
+        # @return [::Nokogiri::XML::Element]
+        #
+        # @api private
+        def create_element(name)
+          ::Nokogiri::XML::Element.new(name, @doc)
+        end
+
+        # Create CDATA node and add it to parent
+        #
+        # @param [String] text
+        # @param [::Nokogiri::XML::Element] parent
+        #
+        # @api private
+        def create_cdata(text, parent)
+          parent.add_child(::Nokogiri::XML::CDATA.new(@doc, text))
+        end
+
+        # Add XML namespace to document
+        #
+        # @param [String] prefix
+        # @param [String] namespace
+        #
+        # @api private
+        def add_namespace(prefix, namespace)
+          @namespaces[prefix] = namespace if prefix && namespace
+        end
+
+        # Add attribute to Nokogiri element
+        #
+        # @param [::Nokogiri::XML::Element] element Nokogiri element
+        # @param [String] name Name of the XML attribute
+        # @param [String] value Value of the XML attribute
+        #
+        # @api private
+        def add_attribute(element, name, value)
+          element[name] = value
+        end
+
+        # Add child element to Nokogiri element
+        #
+        # @param [::Nokogiri::XML::Element] element Nokogiri parent element
+        # @param [::Nokogiri::XML::Element] child Nokogiri child element
+        #
+        # @api private
+        def add_element(element, child)
+          element.add_child(child)
+        end
+
+        # Add text node to Nokogiri element
+        #
+        # @param [::Nokogiri::XML::Element] element Nokogiri element
+        # @param [String] text Text to add
+        #
+        # @api private
+        def add_text(element, text)
+          element.content = text
+        end
+      end
+    end
+  end
+end

data/lib/shale/adapter/nokogiri/node.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Shale
+  module Adapter
+    module Nokogiri
+      # Wrapper around Nokogiri::XML::Node API
+      #
+      # @api private
+      class Node
+        # Initialize object with Nokogiri node
+        #
+        # @param [::Nokogiri::XML::Node] node Nokogiri node
+        #
+        # @api private
+        def initialize(node)
+          @node = node
+        end
+
+        # Return namespaces defined on document
+        #
+        # @return [Hash<String, String>]
+        #
+        # @example
+        #   node.namespaces # => { 'foo' => 'http://foo.com', 'bar' => 'http://bar.com' }
+        #
+        # @api private
+        def namespaces
+          @node.namespaces.transform_keys { |e| e.sub('xmlns:', '') }
+        end
+
+        # Return name of the node in the format of
+        # namespace:name when the node is namespaced or just name when it's not
+        #
+        # @return [String]
+        #
+        # @example without namespace
+        #   node.name # => Bar
+        #
+        # @example with namespace
+        #   node.name # => http://foo:Bar
+        #
+        # @api private
+        def name
+          [@node.namespace&.href, @node.name].compact.join(':')
+        end
+
+        # Return all attributes associated with the node
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def attributes
+          @node.attribute_nodes.each_with_object({}) do |node, hash|
+            name = [node.namespace&.href, node.name].compact.join(':')
+            hash[name] = node.value
+          end
+        end
+
+        # Return node's parent
+        #
+        # @return [Shale::Adapter::Nokogiri::Node, nil]
+        #
+        # @api private
+        def parent
+          if @node.respond_to?(:parent) && @node.parent && @node.parent.name != 'document'
+            self.class.new(@node.parent)
+          end
+        end
+
+        # Return node's element children
+        #
+        # @return [Array<Shale::Adapter::Nokogiri::Node>]
+        #
+        # @api private
+        def children
+          @node
+            .children
+            .to_a
+            .filter(&:element?)
+            .map { |e| self.class.new(e) }
+        end
+
+        # Return first text child of a node
+        #
+        # @return [String]
+        #
+        # @api private
+        def text
+          first = @node
+            .children
+            .to_a
+            .filter { |e| e.text? || e.cdata? }
+            .first
+
+          first&.text
+        end
+      end
+    end
+  end
+end

data/lib/shale/adapter/nokogiri.rb

@@ -2,6 +2,10 @@
 
 require 'nokogiri'
 
+require_relative '../error'
+require_relative 'nokogiri/document'
+require_relative 'nokogiri/node'
+
 module Shale
   module Adapter
     # Nokogiri adapter
@@ -12,7 +16,9 @@ module Shale
       #
       # @param [String] xml XML document
       #
-      # @return [::Nokogiri::XML::Document]
+      # @raise [ParseError] when XML document has errors
+      #
+      # @return [Shale::Adapter::Nokogiri::Node]
       #
       # @api private
       def self.load(xml)
@@ -20,6 +26,10 @@ module Shale
           config.noblanks
         end
 
+        unless doc.errors.empty?
+          raise ParseError, "Document is invalid: #{doc.errors}"
+        end
+
         Node.new(doc.root)
       end
 
@@ -57,156 +67,6 @@ module Shale
       def self.create_document
         Document.new
       end
-
-      # Wrapper around Nokogiri API
-      #
-      # @api private
-      class Document
-        # Initialize object
-        #
-        # @api private
-        def initialize
-          @doc = ::Nokogiri::XML::Document.new
-          @namespaces = {}
-        end
-
-        # Return Nokogiri document
-        #
-        # @return [::Nokogiri::XML::Document]
-        #
-        # @api private
-        def doc
-          if @doc.root
-            @namespaces.each do |prefix, namespace|
-              @doc.root.add_namespace(prefix, namespace)
-            end
-          end
-
-          @doc
-        end
-
-        # Create Nokogiri element
-        #
-        # @param [String] name Name of the XML element
-        #
-        # @return [::Nokogiri::XML::Element]
-        #
-        # @api private
-        def create_element(name)
-          ::Nokogiri::XML::Element.new(name, @doc)
-        end
-
-        # Add XML namespace to document
-        #
-        # @param [String] prefix
-        # @param [String] namespace
-        #
-        # @api private
-        def add_namespace(prefix, namespace)
-          @namespaces[prefix] = namespace if prefix && namespace
-        end
-
-        # Add attribute to Nokogiri element
-        #
-        # @param [::Nokogiri::XML::Element] element Nokogiri element
-        # @param [String] name Name of the XML attribute
-        # @param [String] value Value of the XML attribute
-        #
-        # @api private
-        def add_attribute(element, name, value)
-          element[name] = value
-        end
-
-        # Add child element to Nokogiri element
-        #
-        # @param [::Nokogiri::XML::Element] element Nokogiri parent element
-        # @param [::Nokogiri::XML::Element] child Nokogiri child element
-        #
-        # @api private
-        def add_element(element, child)
-          element.add_child(child)
-        end
-
-        # Add text node to Nokogiri element
-        #
-        # @param [::Nokogiri::XML::Element] element Nokogiri element
-        # @param [String] text Text to add
-        #
-        # @api private
-        def add_text(element, text)
-          element.content = text
-        end
-      end
-
-      # Wrapper around Nokogiri::XML::Node API
-      #
-      # @api private
-      class Node
-        # Initialize object with Nokogiri node
-        #
-        # @param [::Nokogiri::XML::Node] node Nokogiri node
-        #
-        # @api private
-        def initialize(node)
-          @node = node
-        end
-
-        # Return name of the node in the format of
-        # namespace:name when the node is namespaced or just name when it's not
-        #
-        # @return [String]
-        #
-        # @example without namespace
-        #   node.name # => Bar
-        #
-        # @example with namespace
-        #   node.name # => http://foo:Bar
-        #
-        # @api private
-        def name
-          [@node.namespace&.href, @node.name].compact.join(':')
-        end
-
-        # Return all attributes associated with the node
-        #
-        # @return [Hash]
-        #
-        # @api private
-        def attributes
-          @node.attribute_nodes.each_with_object({}) do |node, hash|
-            name = [node.namespace&.href, node.name].compact.join(':')
-            hash[name] = node.value
-          end
-        end
-
-        # Return node's element children
-        #
-        # @return [Array<Shale::Adapter::Nokogiri::Node>]
-        #
-        # @api private
-        def children
-          @node
-            .children
-            .to_a
-            .filter(&:element?)
-            .map { |e| self.class.new(e) }
-        end
-
-        # Return first text child of a node
-        #
-        # @return [String]
-        #
-        # @api private
-        def text
-          first = @node
-            .children
-            .to_a
-            .filter(&:text?)
-            .first
-
-          first&.text
-        end
-      end
     end
   end
 end

data/lib/shale/adapter/ox/document.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Shale
+  module Adapter
+    module Ox
+      # Wrapper around Ox API
+      #
+      # @api private
+      class Document
+        # Return Ox document
+        #
+        # @return [::Ox::Document]
+        #
+        # @api private
+        attr_reader :doc
+
+        # Initialize object
+        #
+        # @api private
+        def initialize
+          @doc = ::Ox::Document.new
+        end
+
+        # Create Ox element
+        #
+        # @param [String] name Name of the XML element
+        #
+        # @return [::Ox::Element]
+        #
+        # @api private
+        def create_element(name)
+          ::Ox::Element.new(name)
+        end
+
+        # Create CDATA node and add it to parent
+        #
+        # @param [String] text
+        # @param [::Ox::Element] parent
+        #
+        # @api private
+        def create_cdata(text, parent)
+          parent << ::Ox::CData.new(text)
+        end
+
+        # Add XML namespace to document
+        #
+        # Ox doesn't support XML namespaces so this method does nothing.
+        #
+        # @param [String] prefix
+        # @param [String] namespace
+        #
+        # @api private
+        def add_namespace(prefix, namespace)
+          # :noop:
+        end
+
+        # Add attribute to Ox element
+        #
+        # @param [::Ox::Element] element Ox element
+        # @param [String] name Name of the XML attribute
+        # @param [String] value Value of the XML attribute
+        #
+        # @api private
+        def add_attribute(element, name, value)
+          element[name] = value
+        end
+
+        # Add child element to Ox element
+        #
+        # @param [::Ox::Element] element Ox parent element
+        # @param [::Ox::Element] child Ox child element
+        #
+        # @api private
+        def add_element(element, child)
+          element << child
+        end
+
+        # Add text node to Ox element
+        #
+        # @param [::Ox::Element] element Ox element
+        # @param [String] text Text to add
+        #
+        # @api private
+        def add_text(element, text)
+          element << text
+        end
+      end
+    end
+  end
+end