yadtfp 1.0.2

data/lib/yadtfp/configuration.rb

@@ -0,0 +1,82 @@
+require 'singleton'
+
+
+module Yadtfp
+
+  class Configuration
+    include Singleton
+
+
+    attr_accessor :filter
+    attr_reader :parser, :outputter
+
+
+
+    # Initializes `@filter`, `@parser`, and `@outputter` to their defaults based on the following table:
+    #
+    # filter      = '*'
+    # parser      = :ox
+    # outputter   = :pretty
+    def initialize
+      # Path to begin traversing the input XML from
+      @filter         = '*'
+
+
+
+      # Parser
+      @parser         = :ox
+
+
+
+      # Diff result output formatter
+      @outputter      = :pretty
+    end
+
+
+
+
+
+    # Assigns supplied parser after converting it to symbol
+    #
+    # Raises `ArgumentError` if supplied `parser` does not `respond_to` to `to_sym`
+    def parser=(parser)
+      raise ArgumentError, "Invalid parser `#{parser}`" if !parser.respond_to?(:to_sym)
+
+      @parser = parser.to_sym
+    end
+
+
+
+
+
+    # Assigns supplied outputter after converting it to symbol
+    #
+    # Raises `ArgumentError` if supplied `outputter` does not `respond_to` to `to_sym`
+    def outputter=(outputter)
+      raise ArgumentError, "Invalid outputter `#{outputter}`" if !outputter.respond_to?(:to_sym)
+
+      @outputter = outputter.to_sym
+    end
+
+
+
+
+
+    # Parses options, prepares this configuration instance and return the same.
+    #
+    # Assigns default values to each configuration attributes as defined in the `initialize` method.
+    #
+    # Raises `ArugmentError` if `options` is not a hash
+    def self.parse_options(options = {})
+      raise ArgumentError, "Invalid options hash" if !options.is_a?(::Hash)
+
+      config = self.instance
+      config.filter = options[:filter] || '*'
+      config.parser = options[:parser] || :ox
+      config.outputter = options[:outputter] || :pretty
+
+      config
+    end
+
+  end
+end

data/lib/yadtfp/outputters.rb

@@ -0,0 +1,3 @@
+require 'yadtfp/outputters_factory'
+require 'yadtfp/outputters/diffable'
+require 'yadtfp/outputters/pretty'

data/lib/yadtfp/outputters/diffable.rb

@@ -0,0 +1,74 @@
+module Yadtfp::Outputters
+
+
+  # Module exists to extract out the common methods in outputters.
+  #
+  # Include this module `Diffable` in each outputters defined.
+  module Diffable
+
+
+
+    attr_reader :diff
+
+
+
+    # Saves supplied difference array.
+    #
+    # Parameter `arr` must be an array of difference hashes.
+    #
+    # Raises `ArgumentError` if supplied `arr` is not an `Array` type.
+    def initialize(arr = [])
+      throw ArgumentError, "`arr` must be an array" if !arr.is_a?(::Array)
+
+      @diff = arr
+    end
+
+
+
+
+
+    # Returns an array containing all the changes.
+    def changes
+      by_type('c')
+    end
+
+
+
+
+
+    # Returns an array containing all the appends.
+    def appends
+      by_type('a')
+    end
+
+
+
+
+
+    # Returns an array containing all the deletes.
+    def deletes
+      by_type('d')
+    end
+
+
+
+
+
+    private
+
+
+
+
+    # Filters and returns the subset of difference by type
+    #
+    # `type` can be one of:
+    #   `c` - Change
+    #   `a` - Append
+    #   `d` - Delete
+    def by_type(type)
+      @diff.select { |d| d[:type] == type }
+    end
+
+  end
+
+end

data/lib/yadtfp/outputters/pretty.rb

@@ -0,0 +1,128 @@
+module Yadtfp::Outputters
+
+  class TypeValuesMismatchError < StandardError; end
+
+
+  class Pretty
+
+    include Yadtfp::Outputters::Diffable
+
+
+    TYPES = [ 'c', 'a', 'd' ]
+
+
+    DiffValue = ->(value) do
+      value.is_a?(::Array) ? value.to_enum.with_index(1).map { |v, i| "\xA#{"\x20" * 5}#{i}.\x20#{v}" }.join : value
+    end
+
+
+
+
+
+    def print
+      content = TYPES.map { |type| header(type) + body(type) }.join ''
+
+      $stdout.print "#{content}#{repeatc("\xA", 1)}#{summary}"
+    end
+
+
+
+
+
+    # Returns header information for given type
+    #
+    # Type can be one of either Change `c`, Append `a` or Delete `d`:
+    #
+    # Returns empty string if type is not one of TYPES ('c', 'a' or 'd')
+    def header(type)
+      return '' if !TYPES.include?(type)
+
+      header = "Changes (Replace left value with right value)"  if type === 'c'
+      header = "Appends (Add values to left)"                   if type === 'a'
+      header = "Deletes (Remove values from left)"              if type === 'd'
+
+      header << "\xA#{ "-" * header.length }\xA"
+      header
+    end
+
+
+
+
+
+    # Returns body for given type
+    #
+    # Type can be one of either Change `c`, Append `a` or Delete `d`:
+    #
+    # Returns empty string if type is not one of `TYPES ('c', 'a' or 'd')
+    #
+    # Raises TypeValuesMismatchError if type is 'd' but diff contains `nil` left
+    # Raises TypeValuesMismatchError if type is 'a' but diff contains `nil` right
+    def body(type)
+      return '' if !TYPES.include?(type)
+
+      diffs = case type
+              when 'c'
+                changes
+              when 'a'
+                appends
+              when 'd'
+                deletes
+              end
+
+
+      if diffs.any? { |d| d[:lvalue].nil? } && type == 'd'
+        raise Yadtfp::Outputters::TypeValuesMismatchError, "Unexpected Left value"
+      end
+
+
+      if diffs.any? { |d| d[:rvalue].nil? } && type == 'a'
+        raise Yadtfp::Outputters::TypeValuesMismatchError, "Unexpected Right value"
+      end
+
+
+      body = diffs.to_enum.with_index(1).inject("") do |body, (diff, index)|
+        body << "\xA#{index}.\x20Path:\x20#{diff[:path]}"
+        body << "\xA#{repeatc("\x20", 3)}Left:\x20#{DiffValue.call(diff[:lvalue])}" if diff.key?(:lvalue)
+        body << "\xA#{repeatc("\x20", 3)}Right:\x20#{DiffValue.call(diff[:rvalue])}" if diff.key?(:rvalue)
+        body << "\xA"
+      end
+
+      body << "\xA"
+    end
+
+
+
+
+
+    # Returns summary of diff
+    #
+    # Prints total number of differences altogether including changes, appends and deletes.
+    def summary
+      summary = "Summary of differences"
+      summary << "\xA#{ "-" * summary.length }\xA"
+
+      summary << "Number of differences: #{@diff.length}"
+      summary << "\xA Changes 'c': #{changes.length}" if changes.length > 0
+      summary << "\xA Appends 'a': #{appends.length}" if appends.length > 0
+      summary << "\xA Deletes 'd': #{deletes.length}" if deletes.length > 0
+      summary << "\xA"
+
+      summary
+    end
+
+
+
+
+    private
+
+
+
+
+    # Repeats character `char` for `length` number of times
+    def repeatc(char, length)
+      char * length
+    end
+
+  end
+
+end

data/lib/yadtfp/outputters_factory.rb

@@ -0,0 +1,26 @@
+module Yadtfp
+
+  class OutputtersFactory
+
+    # Creates and returns one of outputters
+    #
+    # Note that parameter `outputter` needs to be a symbol, and diff needs to be an array.
+    # The allowed values for `outputter` are:
+    #   :pretty
+    #
+    # Raises `ArgumentError` if `outputter` is not one of the values specified above.
+    def self.create(outputter, diff)
+
+      case outputter
+      when :pretty
+        return Outputters::Pretty.new(diff)
+
+      end
+
+      raise ArgumentError, "Invalid outputter `#{outputter}`"
+    end
+
+
+  end
+
+end

data/lib/yadtfp/parsers.rb

@@ -0,0 +1 @@
+require 'yadtfp/parsers_factory'

data/lib/yadtfp/parsers/ox.rb

@@ -0,0 +1,328 @@
+require 'ox'
+require 'pathname'
+
+module Yadtfp::Parsers
+
+
+  class UnsupportedError < StandardError; end
+
+
+  class Ox
+
+
+    # Parses `xml` into a `::Ox::Document` and returns the same `::Ox::Document`
+    #
+    # Parameter `xml` is either a file path or a xml string.
+    # Method adds `xml` processing instruction with `version: '1.0'` and `encoding: 'UTF-8'`
+    #
+    # Method returns empty document `::Ox::Document` with processing instruction if supplied `xml` is nil or empty.
+    def parse(xml)
+      doc = ::Ox::Document.new(version: '1.0', encoding: 'UTF-8')
+      return doc if xml.nil? || xml.empty?
+
+
+      file = ::Pathname.new(xml).absolute? ? xml : File.expand_path(xml)
+      if File.exists?(file)
+        parsed = ::Ox.load_file(file, node: :generic)
+      else
+        parsed = ::Ox.parse(xml)
+      end
+      parsed_doc = doc.dup << parsed if parsed.is_a?(::Ox::Element)
+
+
+      # Apply filter
+      filtered = filter(parsed_doc) if parsed_doc.is_a?(::Ox::Element)
+      filtered.each { |f| doc << f } if filtered.is_a?(::Array)
+
+      doc
+    end
+
+
+
+
+
+    def filter(doc, path = Yadtfp::Configuration.instance.filter)
+      raise ArgumentError, "Document cannot be nil" if doc.nil?
+
+      doc.locate(path)
+    end
+
+
+
+
+
+
+    # Generates array of difference hashes between left and right.
+    #
+    # The difference hash contains the following keys:
+    #   type:   Type of difference.  Either `c` for change, `a` for append or `d` for delete.
+    #   path:   Path needs to be in the format described in the documentation of
+    #           [`::Ox::Element#locate`](http://www.ohler.com/ox/Ox/Element.html#locate-instance_method).
+    #   lvalue: Left value
+    #   rvalue: Right value
+    #
+    # Method loads xml document from `left` and `right`.
+    # Method parameters `left` and `right` both must be a `::Ox::Document`, each of which can be result of `parse`
+    # method.
+    #
+    # Method returns `[]` if both `left` or `right` are `nil` or both are equal.
+    # Method returns `right` translated into difference hash if `left` is `nil`.
+    # Method returns `left` translated into difference hash if `right` is `nil`.
+    def diff(left, right)
+      return [] if left == right || (left.nil? && right.nil?)
+
+
+      left = flat_h(left)
+      right = flat_h(right)
+
+
+      return right.values if left.nil? && right.is_a?(::Hash)
+      return left.values if right.nil? && left.is_a?(::Hash)
+
+
+      return flat_h_diff(left, right)
+    end
+
+
+
+
+
+
+
+    # `flat_h`: Flat hash
+    #
+    # Returns hash of xml document.  Traverses xml document recursively and generates a flat hash.
+    #
+    # Each element is converted to a hash where `key` is path to the node, attribute, comment or CDATA and value is the
+    # string or nil value held by the node, attribute, comment or CDATA
+    #
+    # Example:
+    #
+    #   <xml id='root', name='Foo'>Bar</xml>
+    #   # => { '/xml/id' => 'root', '/xml/@name' => 'Foo', '/xml' => 'Bar' }
+    def flat_h(element)
+      raise UnsupportedError, "Multiple root elements are not allowed" if element.is_a?(::Array)
+
+
+      # Nothing to process
+      return nil if element.nil?
+
+
+      # Result hash
+      result = {}
+
+
+
+      # Attributes
+      attrs = process_attributes(element) || {}
+
+      attrs.map do |key, value|
+        path = element.value.to_s != '' ? "/#{element.value}/#{key}" : "/#{key}"
+        result[path] = value
+      end
+
+
+
+
+
+      # Nodes
+      if !element.is_a?(::Ox::Comment)
+
+        if element.nodes.length.zero?
+          path = "/#{element.value}"
+          result[path] = nil if attrs.length.zero?
+        end
+
+
+
+
+        element.nodes.each do |node|
+
+          if node.is_a?(::String)
+
+            path = "/#{element.value}"
+
+            if result.key?(path)
+              result[path] = [ result[path] ] if !result[path].is_a?(::Array)
+              result[path] << node
+            else
+              result[path] = node
+            end
+
+          elsif node.is_a?(::Ox::Comment)
+
+            path = element.value.to_s != '' ? "/#{element.value}/comment()" : '/comment()'
+            result[path] = process_comments(element)
+
+          elsif node.is_a?(::Ox::CData)
+
+            path = element.value.to_s != '' ? "/#{element.value}/cdata()" : '/cdata()'
+            result[path] = process_cdata(element)
+
+          else
+
+            n = flat_h(node)
+
+
+            n.each do |key, value|
+
+              path = element.value.to_s == '' ? "#{key}" : "/#{element.value}#{key}"
+
+              if result.key?(path)
+
+                result[path] = [ result[path] ] if !result[path].is_a?(::Array)
+                result[path] = [ result[path] ] if key.end_with?('comment()') || key.end_with?('cdata()')
+                result[path] << value
+
+              else
+
+                result[path] = value
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+      result
+
+    end
+
+
+
+
+
+
+
+    # Returns array of difference hashes for left and right flat hashes.
+    #
+    # The resultant array consists of difference hashes in the form of:
+    #
+    #   { type: type, path: path, lvalue: lvalue, rvalue: rvalue }
+    #
+    # where:
+    #
+    #   `type`    - Type of difference, either `c`, `a` or `d`
+    #   `path`    - Path to the node, attribute, cdata, comment.
+    #   `lvalue`  - Value at path in left
+    #   `rvalue`  - Value at path in right
+    #
+    #
+    # Three possible `types` of differences are:
+    #   `c` - When both left and right contain different values for same path
+    #   `a` - Append values to left at the specified path.  Occurs when path is not present in left.
+    #   `d` - Delete values from left at the specified path.  Occurs when path is not present in right.
+    #
+    # Returns nil if left and right are equal.
+    def flat_h_diff(left, right)
+      return nil if left == right
+
+      diff_hash = ( left.keys | right.keys ).inject({}) do |hash, key|
+        type = 'c'
+        type = 'd' if !right.key?(key) && left.key?(key)
+        type = 'a' if !left.key?(key) && right.key?(key)
+
+        if left[key] != right[key]
+
+          if left[key].is_a?(::Array) && right[key].is_a?(::Array)
+
+            type = 'd' if left[key].length > right[key].length
+            type = 'a' if left[key].length < right[key].length
+            type = 'c' if (left[key] - right[key]).length >= 1 && (right[key] - left[key]).length >= 1
+
+
+            if (left[key] - right[key]).empty? && (right[key] - left[key]).empty?
+              hash[key] = { type: type, path: key, lvalue: left[key].uniq, rvalue: nil } if type == 'd'
+              hash[key] = { type: type, path: key, lvalue: nil, rvalue: right[key].uniq } if type == 'a'
+
+            else
+
+              hash[key] = { type: type, path: key, lvalue: left[key] - right[key], rvalue: nil } if type == 'd'
+              hash[key] = { type: type, path: key, lvalue: nil, rvalue: right[key] - left[key] } if type == 'a'
+              hash[key] = { type: type, path: key, lvalue: (left[key] - right[key]), rvalue: (right[key] - left[key]) } if type == 'c'
+            end
+
+          else
+
+            hash[key] = { type: type, path: key, lvalue: left[key], rvalue: right[key] }
+
+          end
+
+        end
+
+        hash
+      end
+
+      diff_hash.values
+    end
+
+
+
+
+
+
+    # Process element comments
+    #
+    # Returns array of comments
+    # Returns nil if element does not contain any comment nodes.
+    def process_comments(element)
+      return if !element.respond_to?(:nodes)
+
+      comments = element.nodes.dup.inject([]) do |result, element|
+        result << element.value if element.is_a?(::Ox::Comment) && !element.value.empty?
+        result
+      end
+
+      return comments if comments.length >= 1
+      nil
+    end
+
+
+
+
+
+
+    # Process element cdata
+    #
+    # Returns array of cdata
+    # Returns nil if element does not contain any cdata markup.
+    def process_cdata(element)
+      return if !element.respond_to?(:nodes)
+
+      cdata = element.nodes.dup.inject([]) do |result, element|
+        result << element.value if element.is_a?(::Ox::CData) && !element.value.empty?
+        result
+      end
+
+      return cdata if cdata.length >= 1
+      nil
+    end
+
+
+
+
+
+
+    # Process node attributes
+    # Returns hash of node attributes applying `@` prefix to every attribute name
+    #
+    # Returns nil if node does not contain any attributes
+    def process_attributes(node)
+      return nil if !node.respond_to?(:attributes)
+
+      attributes = node.attributes.dup.inject({}) do |hash, (key, value)|
+        hash["@#{key}"] = value
+        hash
+      end
+
+      return attributes if attributes.length >= 1
+      nil
+    end
+
+  end
+
+end