kronk 1.2.5 → 1.3.0

data/lib/kronk/data_set.rb

@@ -19,22 +19,6 @@ class Kronk
     end
 
 
-    ##
-    # Retrieves the data at the given path array.
-
-    def data_at_path path
-      self.class.data_at_path @data, path
-    end
-
-
-    ##
-    # Checks if data is available at the given path.
-
-    def data_at_path? path
-      self.class.data_at_path? @data, path
-    end
-
-
     ##
     # Modify the data object by passing inclusive or exclusive data paths.
     # Supports the following options:
@@ -85,6 +69,10 @@ class Kronk
               new_curr_data[key] = curr_data[key]
               break
 
+            elsif path.length == 1 && affect_parent
+              new_data = curr_data
+              break
+
             else
               new_curr_data[key] ||= curr_data[key].class.new
               new_curr_data        = new_curr_data[key]
@@ -106,6 +94,8 @@ class Kronk
         find_data data_path do |obj, k, path|
 
           if affect_parent && data_at_path?(path)
+            @data = @data.class.new and return if path.length == 1
+
             parent_data = data_at_path path[0..-3]
             del_method  = Array === parent_data ? :delete_at : :delete
 
@@ -140,23 +130,16 @@ class Kronk
     #   # Returns an Array of grand-children key/value pairs
     #   # where the value is 'invalid' or blank
 
-    def find_data data_path, curr_path=nil, &block
-      self.class.find_data @data, data_path, curr_path, &block
-    end
-
-
-    ##
-    # See DataSet#find_data
-
-    def self.find_data data, data_path, curr_path=nil, &block
+    def find_data data_path, curr_path=nil, data=nil, &block
       curr_path ||= []
+      data      ||= @data
 
       key, value, rec, data_path = parse_data_path data_path
 
       yield_data_points data, key, value, rec, curr_path do |d, k, p|
 
         if data_path
-          find_data d[k], data_path, p, &block
+          find_data data_path, p, d[k], &block
         else
           yield d, k, p
         end
@@ -167,8 +150,8 @@ class Kronk
     ##
     # Checks if data is available at the given path.
 
-    def self.data_at_path? data, path
-      data_at_path(data, path)
+    def data_at_path? path
+      data_at_path path
       true
 
     rescue NoMethodError, TypeError
@@ -179,8 +162,8 @@ class Kronk
     ##
     # Retrieve the data at the given path array location.
 
-    def self.data_at_path data, path
-      curr = data
+    def data_at_path path
+      curr = @data
       path.each do |p|
         raise TypeError, "Expected instance of Array or Hash" unless
           Array === curr || Hash === curr
@@ -198,7 +181,7 @@ class Kronk
     # - Recursive matching
     # - New data path value
 
-    def self.parse_data_path data_path
+    def parse_data_path data_path
       data_path  = data_path.dup
       key        = nil
       value      = nil
@@ -236,17 +219,22 @@ class Kronk
 
 
     ##
-    # Decide whether to make path item a regex or not.
+    # Decide whether to make path item a regex, range, array, or string.
 
-    def self.parse_path_item str
+    def parse_path_item str
       if str =~ /(^|[^\\])([\*\?\|])/
         str.gsub!(/(^|[^\\])(\*|\?)/, '\1.\2')
-        str = /^(#{str})$/
+        /^(#{str})$/i
+
+      elsif str =~ %r{^(\-?\d+)(\.{2,3})(\-?\d+)$}
+        Range.new $1.to_i, $3.to_i, ($2 == "...")
+
+      elsif str =~ %r{^(\-?\d+),(\-?\d+)$}
+        Range.new $1.to_i, ($1.to_i + $2.to_i), true
+
       else
-        str.gsub! "\\", ""
+        str.gsub "\\", ""
       end
-
-      str
     end
 
 
@@ -254,7 +242,7 @@ class Kronk
     # Yield data object and key, if a specific key or value matches
     # the given data.
 
-    def self.yield_data_points data, mkey, mvalue=nil,
+    def yield_data_points data, mkey, mvalue=nil,
                                recursive=false, path=nil, &block
 
       return unless Hash === data || Array === data
@@ -266,8 +254,6 @@ class Kronk
         found = match_data_item(mkey, key) &&
                 match_data_item(mvalue, value)
 
-        #puts "Found: #{data.inspect} #{mkey.inspect} -> #{key.inspect}" if found
-
         yield data, key, curr_path if found
         yield_data_points data[key], mkey, mvalue, true, curr_path, &block if
           recursive
@@ -278,15 +264,23 @@ class Kronk
     ##
     # Check if data key or value is a match for nested data searches.
 
-    def self.match_data_item item1, item2
+    def match_data_item item1, item2
       return if !item1.nil? && (Array === item2 || Hash === item2)
 
-      if Regexp === item1
+      if item1.class == item2.class
+        item1 == item2
+
+      elsif Regexp === item1
         item2.to_s =~ item1
+
+      elsif Range === item1
+        item1.include? item2.to_i
+
       elsif item1.nil?
         true
+
       else
-        item2.to_s == item1.to_s
+        item2.to_s.downcase == item1.to_s.downcase
       end
     end
 
@@ -294,7 +288,7 @@ class Kronk
     ##
     # Universal iterator for Hash and Array objects.
 
-    def self.each_data_item data, &block
+    def each_data_item data, &block
       case data
 
       when Hash

data/lib/kronk/diff.rb

@@ -1,87 +1,11 @@
 class Kronk
 
-
   ##
   # Creates simple diffs as formatted strings or arrays, from two strings or
   # data objects.
 
   class Diff
 
-    ##
-    # Format diff with ascii
-
-    class AsciiFormat
-
-      def self.lines line_nums, col_width
-        out =
-          [*line_nums].map do |lnum|
-            lnum.to_s.rjust col_width
-          end.join "|"
-
-        "#{out} "
-      end
-
-
-      def self.deleted str
-        "- #{str}"
-      end
-
-
-      def self.added str
-        "+ #{str}"
-      end
-
-
-      def self.common str
-        "  #{str}"
-      end
-    end
-
-
-    ##
-    # Format diff with ascii
-
-    class ColorFormat
-
-      def self.require_win_color
-        begin
-          require 'Win32/Console/ANSI'
-        rescue LoadError
-          puts "Warning: You must gem install win32console to use color"
-        end
-      end
-
-
-      def self.lines line_nums, col_width
-        require_win_color if Kronk.windows?
-
-        out =
-          [*line_nums].map do |lnum|
-            lnum.to_s.rjust col_width
-          end.join "\033[32m"
-
-        "\033[7;31m#{out}\033[0m "
-      end
-
-
-      def self.deleted str
-        require_win_color if Kronk.windows?
-        "\033[31m#{str}\033[0m"
-      end
-
-
-      def self.added str
-        require_win_color if Kronk.windows?
-        "\033[32m#{str}\033[0m"
-      end
-
-
-      def self.common str
-        str
-      end
-    end
-
-
     ##
     # Creates a new diff from two data objects.
 
@@ -184,69 +108,127 @@ class Kronk
 
     def create_diff
       diff_ary = []
-      sub_diff = nil
 
       arr1 = @str1.split @char
       arr2 = @str2.split @char
 
-      until arr1.empty? && arr2.empty?
-        item1, item2 = arr1.shift, arr2.shift
+      common_list = find_common arr1, arr2
 
-        if item1 == item2
-          if sub_diff
-            diff_ary << sub_diff
-            sub_diff = nil
-          end
+      return [[arr1, arr2]] if common_list.empty?
 
-          diff_ary << item1
-          next
-        end
+      last_i1 = 0
+      last_i2 = 0
 
-        match1 = arr1.index item2
-        match2 = arr2.index item1
+      common_list.each do |c|
+        next unless c
 
+        left  = arr1[last_i1...c[1]]
+        right = arr2[last_i2...c[2]]
 
-        if use_left?(match1, match2)
-          diff_ary.concat diff_match(item1, match1, arr1, 0, sub_diff)
-          sub_diff = nil
+        # add diffs
+        diff_ary << [left, right] unless left.empty? && right.empty?
 
-        elsif match2
-          diff_ary.concat diff_match(item2, match2, arr2, 1, sub_diff)
-          sub_diff = nil
+        # add common
+        diff_ary.concat arr1[c[1], c[0]]
 
-        elsif !item1.nil? || !item2.nil?
-          sub_diff ||= [[],[]]
-          sub_diff[0] << item1 if item1
-          sub_diff[1] << item2 if item2
-        end
+        last_i1 = c[1] + c[0]
+        last_i2 = c[2] + c[0]
       end
 
-      diff_ary << sub_diff if sub_diff
+      left  = arr1[last_i1..-1]
+      right = arr2[last_i2..-1]
+
+      diff_ary << [left, right] unless left.empty? && right.empty?
 
       diff_ary
     end
 
 
     ##
-    # Check if the index on the left should be used.
+    # Recursively finds common sequences between two arrays and returns
+    # them in the order they occur as an array of arrays:
+    #   find_common arr1, arr2
+    #   #=> [[size, arr1_index, arr2_index], [size, arr1_index, arr2_index],...]
+
+    def find_common arr1, arr2
+      used1 = []
+      used2 = []
+
+      common = []
 
-    def use_left? index1, index2
-      index1 && (index2.nil? || index1 < index2)
+      common_sequences(arr1, arr2) do |seq|
+        next if used1[seq[1]] || used2[seq[2]]
+
+        next if used1[seq[1], seq[0]].to_a.index(true) ||
+                used2[seq[2], seq[0]].to_a.index(true)
+
+        next if used1[seq[1]+seq[0]..-1].to_a.nitems !=
+                  used2[seq[2]+seq[0]..-1].to_a.nitems
+
+
+        used1.fill(true, seq[1], seq[0])
+        used2.fill(true, seq[2], seq[0])
+
+        common[seq[1]] = seq
+      end
+
+      common
     end
 
 
     ##
-    # Create a diff from a match.
+    # Returns all common sequences between to arrays ordered by sequence length
+    # according to the following format:
+    #   [[[len1, ix, iy], [len1, ix, iy]],[[len2, ix, iy]]]
+    #   # e.g.
+    #   [nil,[[1,2,3],[1,2,5]],nil,[[3,4,5],[3,6,9]]
+
+    def common_sequences arr1, arr2, &block
+      sequences = []
+
+      arr2_map = {}
+      arr2.each_with_index do |line, j|
+        arr2_map[line] ||= []
+        arr2_map[line] << j
+      end
+
+      arr1.each_with_index do |line, i|
+        next unless arr2_map[line]
 
-    def diff_match item, match, arr, side, sub_diff
-      sub_diff ||= [[],[]]
+        arr2_map[line].each do |j|
+          line1 = line
+          line2 = arr2[j]
 
-      index = match - 1
-      added = [item]
-      added.concat arr.slice!(0..index) if index >= 0
+          k = i
+          start_j = j
 
-      sub_diff[side].concat(added)
-      [sub_diff, arr.shift]
+          while line1 && line1 == line2 && k < arr1.length
+            k += 1
+            j += 1
+
+            line1 = arr1[k]
+            line2 = arr2[j]
+          end
+
+          len = j - start_j
+
+          sequences[len] ||= []
+          sequences[len] << [len, i, start_j]
+        end
+      end
+
+      yield_sequences sequences, &block if block_given?
+
+      sequences
+    end
+
+
+    def yield_sequences sequences, dist=0, &block
+      while sequences.length > dist
+        item = sequences.pop
+        next unless item
+        item.each &block
+      end
     end
 
 
@@ -329,3 +311,14 @@ class Kronk
     end
   end
 end
+
+
+# For Ruby 1.9
+
+unless [].respond_to? :nitems
+class Array
+  def nitems
+    self.compact.length
+  end
+end
+end

data/lib/kronk/diff/ascii_format.rb

@@ -0,0 +1,35 @@
+class Kronk
+
+  class Diff
+
+    ##
+    # Format diff with ascii
+
+    class AsciiFormat
+
+      def self.lines line_nums, col_width
+        out =
+          [*line_nums].map do |lnum|
+            lnum.to_s.rjust col_width
+          end.join "|"
+
+        "#{out} "
+      end
+
+
+      def self.deleted str
+        "- #{str}"
+      end
+
+
+      def self.added str
+        "+ #{str}"
+      end
+
+
+      def self.common str
+        "  #{str}"
+      end
+    end
+  end
+end