kronk 1.5.4 → 1.6.0

data/lib/kronk/diff/ascii_format.rb

@@ -7,6 +7,17 @@ class Kronk
 
     class AsciiFormat
 
+
+      def self.head left, right
+        ["--- #{left}", "+++ #{right}"]
+      end
+
+
+      def self.context left, right, info=nil
+        "@@ -#{left} +#{right} @@ #{info}"
+      end
+
+
       def self.lines line_nums, col_width
         out =
           [*line_nums].map do |lnum|

data/lib/kronk/diff/color_format.rb

@@ -17,6 +17,18 @@ class Kronk
       end
 
 
+      def self.head left, right
+        ensure_color
+        ["\033[1;33m--- #{left}", "+++ #{right}\033[0m"]
+      end
+
+
+      def self.context left, right, info=nil
+        ensure_color
+        "\033[1;35m@@ -#{left} +#{right} @@\033[0m #{info}"
+      end
+
+
       def self.lines line_nums, col_width
         ensure_color
 
@@ -31,13 +43,13 @@ class Kronk
 
       def self.deleted str
         ensure_color
-        "\033[31m- #{str}\033[0m"
+        "\033[1;31m- #{str}\033[0m"
       end
 
 
       def self.added str
         ensure_color
-        "\033[32m+ #{str}\033[0m"
+        "\033[1;32m+ #{str}\033[0m"
       end
 
 

data/lib/kronk/diff/output.rb

@@ -0,0 +1,155 @@
+class Kronk::Diff
+
+  class Output
+
+    ##
+    # Returns a formatter from a symbol or string. Returns nil if not found.
+
+    def self.formatter name
+      return unless name
+
+      return name        if Class === name
+      return AsciiFormat if name == :ascii_diff
+      return ColorFormat if name == :color_diff
+      Kronk.find_const name rescue name
+    end
+
+
+    def self.attr_rm_cache *attrs # :nodoc:
+      self.send :attr_reader, *attrs
+
+      attrs.each do |attr|
+        define_method "#{attr}=" do |value|
+          if send(attr) != value
+            instance_variable_set("@#{attr}", value)
+            instance_variable_set("@cached", nil)
+          end
+        end
+      end
+    end
+
+
+    attr_rm_cache :labels, :show_lines, :join_ch, :context, :format, :diff_ary
+
+
+    def initialize diff, opts={}
+      @output     = []
+      @cached     = nil
+      @diff       = diff
+
+      @format =
+        self.class.formatter(opts[:format] || Kronk.config[:diff_format]) ||
+        AsciiFormat
+
+      @context = Kronk.config[:context]
+      @context = opts[:context] if opts[:context] || opts[:context] == false
+
+      @join_ch = opts[:join_char] || "\n"
+
+      @labels      = Array(opts[:labels])
+      @labels[0] ||= "left"
+      @labels[1] ||= "right"
+
+      @show_lines = opts[:show_lines] || Kronk.config[:show_lines]
+      @record     = false
+
+      lines1 = diff.str1.lines.count
+      lines2 = diff.str2.lines.count
+      @cwidth = (lines1 > lines2 ? lines1 : lines2).to_s.length
+    end
+
+
+    def record? i, line1, line2
+      if @context
+        clen = @context + 1
+        next_diff = @diff_ary[i,clen].to_a.find{|da| Array === da}
+      end
+
+      if !clen || next_diff
+        @record || [@output.length, line1+1, line2+1, 0, 0]
+
+      elsif @record && clen && !next_diff
+        scheck = @output.length - (clen - 1)
+        subary = @output[scheck..-1].to_a
+
+        if i == @diff_ary.length || !subary.find{|da| Array === da}
+          start  = @record[0]
+          cleft  = "#{@record[1]},#{@record[3]}"
+          cright = "#{@record[2]},#{@record[4]}"
+
+          str    = @output[start]
+          str    = str[0][0]   if Array === str
+          info   = str.meta[0] if str.respond_to?(:meta)
+
+          @output[start,0] = @format.context cleft, cright, info
+          false
+
+        else
+          @record
+        end
+
+      else
+        @record
+      end
+    end
+
+
+    def render force=false
+      self.diff_ary = @diff.diff_array
+
+      return @cached if !force && @cached
+      @output << @format.head(*@labels)
+
+      line1 = line2 = 0
+
+      0.upto(@diff_ary.length) do |i|
+        item = @diff_ary[i]
+        @record = record? i, line1, line2
+
+        case item
+        when String
+          line1 = line1.next
+          line2 = line2.next
+          @output << make_line(item, line1, line2) if @record
+
+        when Array
+          sides = [[],[]]
+
+          item[0].each do |ditem|
+            line1 = line1.next
+            sides[0] << make_line(ditem, line1, nil) if @record
+          end
+
+          item[1].each do |ditem|
+            line2 = line2.next
+            sides[0] << make_line(ditem, nil, line2) if @record
+          end
+
+          @output << sides if @record
+        end
+      end
+
+      @cached = @output.flatten.join(@join_ch)
+    end
+
+    alias to_s render
+
+
+    def make_line item, line1, line2
+      action = if line1 && !line2
+                 :deleted
+               elsif !line1 && line2
+                 :added
+               else
+                 :common
+               end
+
+      lines = @format.lines [line1, line2], @cwidth if @show_lines
+      line  = "#{lines}#{@format.send action, item}"
+      line  = Kronk::DataString.new line, item.meta[0] if item.respond_to? :meta
+      @record[3] += 1 if line1
+      @record[4] += 1 if line2
+      line
+    end
+  end
+end

data/lib/kronk/path.rb

@@ -38,9 +38,6 @@ class Kronk
     # Used as path instruction to go up one path level.
     module PARENT; end
 
-    # Used as path item value to match any key or value.
-    module ANY_VALUE; end
-
     # Mapping of letters to Regexp options.
     REGEX_OPTS = {
       "i" => Regexp::IGNORECASE,
@@ -49,19 +46,12 @@ class Kronk
       "x" => Regexp::EXTENDED
     }
 
-    # Shortcut characters that require modification before being turned into
-    # a matcher.
-    SUFF_CHARS = Regexp.escape "*?"
-
-    # All special path characters.
-    PATH_CHARS = Regexp.escape("()|") << SUFF_CHARS
-
-    # Path chars that get regexp escaped.
-    RESC_CHARS = "*?()|/"
-
     # The path item delimiter character "/"
     DCH = "/"
 
+    # The replacement character "%" for path mapping
+    RCH = "%"
+
     # The path character to assign value "="
     VCH = "="
 
@@ -80,26 +70,14 @@ class Kronk
     # The key string that indicates recursive lookup.
     RECUR_KEY = "**"
 
-    # Matcher for Range path item.
-    RANGE_MATCHER  = %r{^(\-?\d+)(\.{2,3})(\-?\d+)$}
-
-    # Matcher for index,length path item.
-    ILEN_MATCHER   = %r{^(\-?\d+),(\-?\d+)$}
-
-    # Matcher allowing any value to be matched.
-    ANYVAL_MATCHER = /^(\?*\*+\?*)*$/
-
-    # Matcher to assert if any unescaped special chars are in a path item.
-    PATH_CHAR_MATCHER = /(^|[^#{RECH}])([#{PATH_CHARS}])/
-
 
     ##
     # Instantiate a Path object with a String data path.
     #   Path.new "/path/**/to/*=bar/../../**/last"
 
-    def initialize path_str, regex_opts=nil
+    def initialize path_str, regex_opts=nil, &block
       path_str = path_str.dup
-      @path = self.class.parse_path_str path_str, regex_opts
+      @path = self.class.parse_path_str path_str, regex_opts, &block
     end
 
 
@@ -129,11 +107,10 @@ class Kronk
     def find_in data
       matches = {[] => data}
 
-      @path.each_with_index do |(mkey, mvalue, recur), i|
-        args      = [matches, data, mkey, mvalue, recur]
+      @path.each_with_index do |matcher, i|
         last_item = i == @path.length - 1
 
-        self.class.assign_find(*args) do |sdata, key, spath|
+        self.class.assign_find(matches, data, matcher) do |sdata, key, spath|
           yield sdata, key, spath if last_item && block_given?
         end
       end
@@ -142,6 +119,36 @@ class Kronk
     end
 
 
+    ##
+    # Returns a path-keyed data hash. Be careful of mixed key types in hashes
+    # as Symbols and Strings both use #to_s.
+
+    def self.pathed data, escape=true
+      new_data = {}
+
+      find "**", data do |subdata, key, path|
+        next if Array === subdata[key] || Hash === subdata[key]
+        path_str = "#{DCH}#{join(path, escape)}"
+        new_data[path_str] = subdata[key]
+      end
+
+      new_data
+    end
+
+
+    ##
+    # Joins an Array into a path String.
+
+    def self.join path_arr, escape=true
+      path_esc = "*?()|/."
+      path_arr.map! do |k|
+        k.to_s.gsub(/([#{path_esc}])/){|m| "\\#{m}"}
+      end if escape
+
+      path_arr.join(DCH)
+    end
+
+
     ##
     # Fully streamed version of:
     #   Path.new(str_path).find_in data
@@ -151,8 +158,8 @@ class Kronk
     def self.find path_str, data, regex_opts=nil, &block
       matches = {[] => data}
 
-      parse_path_str path_str, regex_opts do |mkey, mvalue, recur, last_item|
-        assign_find matches, data, mkey, mvalue, recur do |sdata, key, spath|
+      parse_path_str path_str, regex_opts do |matcher, last_item|
+        assign_find matches, data, matcher do |sdata, key, spath|
           yield sdata, key, spath if last_item && block_given?
         end
       end
@@ -164,11 +171,11 @@ class Kronk
     ##
     # Common find functionality that assigns to the matches hash.
 
-    def self.assign_find matches, data, mkey, mvalue, recur
+    def self.assign_find matches, data, matcher
       matches.keys.each do |path|
         pdata = matches.delete path
 
-        if mkey == PARENT
+        if matcher.key == PARENT
           path    = path[0..-2]
           subdata = data_at_path path[0..-2], data
 
@@ -180,7 +187,7 @@ class Kronk
           next
         end
 
-        find_match pdata, mkey, mvalue, recur, path do |sdata, key, spath|
+        matcher.find_in pdata, path do |sdata, key, spath|
           yield sdata, key, spath if block_given?
           matches[spath] = sdata[key]
         end
@@ -206,118 +213,6 @@ class Kronk
     end
 
 
-    ##
-    # Universal iterator for Hash and Array like objects.
-    # The data argument must either respond to both :each_with_index
-    # and :length, or respond to :each yielding a key/value pair.
-
-    def self.each_data_item data, &block
-      if data.respond_to?(:has_key?) && data.respond_to?(:each)
-        data.each(&block)
-
-      elsif data.respond_to?(:each_with_index) && data.respond_to?(:length)
-        # We need to iterate through the array this way
-        # in case items in it get deleted.
-        (data.length - 1).downto(0) do |i|
-          block.call i, data[i]
-        end
-      end
-    end
-
-
-    ##
-    # Finds data with the given key and value matcher, optionally recursive.
-    # Yields data, key and path Array when block is given.
-    # Returns an Array of path arrays.
-
-    def self.find_match data, mkey, mvalue=ANY_VALUE,
-                        recur=false, path=nil, &block
-
-      return [] unless Array === data || Hash === data
-
-      paths  = []
-      path ||= []
-
-      each_data_item data do |key, value|
-        c_path = path.dup << key
-
-        if match_data_item(mkey, key) && match_data_item(mvalue, value)
-          yield data, key, c_path if block_given?
-          paths << c_path
-        end
-
-        paths.concat \
-          find_match(data[key], mkey, mvalue, true, c_path, &block) if recur
-      end
-
-      paths
-    end
-
-
-    ##
-    # Check if data key or value is a match for nested data searches.
-
-    def self.match_data_item item1, item2
-      return if ANY_VALUE != item1 && (Array === item2 || Hash === item2)
-
-      if item1.class == item2.class
-        item1 == item2
-
-      elsif Regexp === item1
-        item2.to_s =~ item1
-
-      elsif Range === item1
-        item1.include? item2.to_i
-
-      elsif ANY_VALUE == item1
-        true
-
-      else
-        item2.to_s.downcase == item1.to_s.downcase
-      end
-    end
-
-
-    ##
-    # Decide whether to make path item matcher a regex, range, array, or string.
-
-    def self.parse_path_item str, regex_opts=nil
-      case str
-      when nil, ANYVAL_MATCHER
-        ANY_VALUE
-
-      when RANGE_MATCHER
-        Range.new $1.to_i, $3.to_i, ($2 == "...")
-
-      when ILEN_MATCHER
-        Range.new $1.to_i, ($1.to_i + $2.to_i), true
-
-      else
-        if String === str && (regex_opts || str =~ PATH_CHAR_MATCHER)
-
-          # Remove extra suffix characters
-          str.gsub! %r{(^|[^#{RECH}])(\*+\?+|\?+\*+)}, '\1*'
-          str.gsub! %r{(^|[^#{RECH}])\*+}, '\1*'
-
-          str = Regexp.escape str
-
-          # Remove escaping from special path characters
-          str.gsub! %r{#{RECH}([#{PATH_CHARS}])}, '\1'
-          str.gsub! %r{#{RECH}([#{RESC_CHARS}])}, '\1'
-          str.gsub! %r{(^|[^#{RECH}])([#{SUFF_CHARS}])}, '\1.\2'
-
-          Regexp.new "\\A(#{str})\\Z", regex_opts
-
-        elsif String === str
-          str.gsub %r{#{RECH}([^#{RECH}]|$)}, '\1'
-
-        else
-          str
-        end
-      end
-    end
-
-
     ##
     # Parses a path String into an Array of arrays containing
     # matchers for key, value, and any special modifiers
@@ -388,13 +283,13 @@ class Kronk
           end
 
           unless key =~ /^\.?$/ && !value
-            parsed << [ parse_path_item(key, regex_opts),
-                        parse_path_item(value, regex_opts),
-                        recur ]
-
-            yield_args = (parsed.last.dup << path.empty?)
+            matcher = Matcher.new :key        => key,
+                                  :value      => value,
+                                  :recursive  => recur,
+                                  :regex_opts => regex_opts
 
-            yield(*yield_args) if block_given?
+            parsed << matcher
+            yield matcher, path.empty? if block_given?
           end
 
           key   = ""