kronk 1.6.2 → 1.7.0

data/lib/kronk/diff/output.rb

@@ -1,41 +1,129 @@
 class Kronk::Diff
 
+  ##
+  # Renders diff outputs.
+
   class Output
 
     ##
-    # Returns a formatter from a symbol or string. Returns nil if not found.
+    # Represents one diff section to render
+    # (starts with @@-line,len +line,len@@)
+
+    class Section
+      attr_accessor :context, :format, :lindex, :rindex, :llen, :rlen,
+                    :lmeta, :rmeta
+
+      def initialize format, line_num_width=nil, lindex=0, rindex=0
+        @format  = format
+        @cwidth  = line_num_width
+        @lindex  = lindex
+        @rindex  = rindex
+        @llen    = 0
+        @rlen    = 0
+        @lmeta   = nil
+        @rmeta   = nil
+        @lines   = []
+        @context = 0
+      end
 
-    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 add obj, meta=nil
+        @lmeta, @rmeta = meta if meta && !@lmeta && !@rmeta
+        @lmeta = ary_to_path @lmeta if Array === @rmeta
+        @rmeta = ary_to_path @rmeta if Array === @rmeta
+
+        if String === obj
+          add_common obj
+
+        elsif Array === obj
+          left, right = obj
+          left.each{|o| add_left o }
+          right.each{|o| add_right o }
+        end
+      end
+
+
+      def add_common obj
+        @llen    += 1
+        @rlen    += 1
+        @context += 1
+
+        line_nums =
+          @format.lines [@llen+@lindex, @rlen+@rindex], @cwidth if @cwidth
+
+        @lines << "#{line_nums}#{@format.common obj}"
+      end
+
+
+      def add_left obj
+        @llen   += 1
+        @context = 0
+
+        line_nums = @format.lines [@llen+@lindex, nil], @cwidth if @cwidth
+        @lines << "#{line_nums}#{@format.deleted obj}"
+      end
+
 
+      def add_right obj
+        @rlen   += 1
+        @context = 0
+
+        line_nums = @format.lines [nil, @rlen+@rindex], @cwidth if @cwidth
+        @lines << "#{line_nums}#{@format.added obj}"
+      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
+      def ary_to_path ary
+        "#{Kronk::Path::DCH}#{Kronk::Path.join ary}"
+      end
+
+
+      def render
+        cleft  = "#{@lindex+1},#{@llen}"
+        cright = "#{@rindex+1},#{@rlen}"
+
+        if @lmeta != @rmeta && @lmeta && @rmeta
+          cleft  << " " << @lmeta
+          cright << " " << @rmeta
+        else
+          info = @lmeta || @rmeta
         end
+
+        [@format.context(cleft, cright, info), *@lines]
       end
     end
 
 
-    attr_rm_cache :labels, :show_lines, :join_ch, :context, :format, :diff_ary
+    ##
+    # 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.to_s =~ /^ascii(_diff)?$/
+      return ColorFormat if name.to_s =~ /^color(_diff)?$/
+      Kronk.find_const name
+
+    rescue NameError => e
+      raise Kronk::Exception, "No such formatter: #{name.inspect}"
+    end
 
 
+    attr_accessor :labels, :show_lines, :join_ch, :context, :format
+
+
+    ##
+    # Create a new Kronk::Diff::Output instance.
+    # Options supported are:
+    # :context:: Integer - Number of context lines around diffs; default 3
+    # :diff_format:: String/Object - Formatter for the diff; default AsciiFormat
+    # :join_char:: String - Vharacter to join diff sections with; default \n
+    # :labels:: Array - Left and right names to display; default %w{left right}
+    # :show_lines:: Boolean - Show lines in diff; default false
+
     def initialize diff, opts={}
-      @output     = []
-      @cached     = nil
-      @diff       = diff
+      @diff = diff
 
       @format =
         self.class.formatter(opts[:format] || Kronk.config[:diff_format]) ||
@@ -51,7 +139,7 @@ class Kronk::Diff
       @labels[1] ||= "right"
 
       @show_lines = opts[:show_lines] || Kronk.config[:show_lines]
-      @record     = false
+      @section    = false
 
       lines1 = diff.str1.lines.count
       lines2 = diff.str2.lines.count
@@ -59,103 +147,47 @@ class Kronk::Diff
     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]}"
+    def continue_section? i
+       !@context ||
+        !!@diff.diff_array[i,@context+1].to_a.find{|da| Array === da}
+    end
 
-          str    = @output[start]
-          str    = str[0][0]   if Array === str
-          info   = str.meta[0] if str.respond_to?(:meta)
 
-          if Array === info && !info.empty?
-            cleft  << " " << info[0]
-            cright << " " << info[1]
-            info = nil
-          end
+    def start_section? i
+      !@section && continue_section?(i)
+    end
 
-          @output[start,0] = @format.context cleft, cright, info
-          false
 
-        else
-          @record
-        end
-
-      else
-        @record
-      end
+    def end_section? i
+      @section &&
+        (i >= @diff.diff_array.length ||
+         !continue_section?(i) && @context && @section.context >= @context)
     end
 
 
     def render force=false
-      self.diff_ary = @diff.diff_array
-
-      return @cached if !force && @cached
-      @output << @format.head(*@labels)
+      output = []
+      output << @format.head(*@labels)
 
       line1 = line2 = 0
+      lwidth = @show_lines && @cwidth
 
-      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
+      @diff.diff_array.each_with_index do |item, i|
+        @section = Section.new @format, lwidth, line1, line2 if start_section? i
+        @section.add item, @diff.meta[i] if @section
 
-          item[1].each do |ditem|
-            line2 = line2.next
-            sides[0] << make_line(ditem, nil, line2) if @record
-          end
+        line1 += Array === item ? item[0].length : 1
+        line2 += Array === item ? item[1].length : 1
 
-          @output << sides if @record
+        if end_section?(i+1)
+          output.concat @section.render
+          @section = false
         end
       end
 
-      @cached = @output.flatten.join(@join_ch)
+      output.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/diff.rb

@@ -10,23 +10,8 @@ class Kronk
     # Creates a new diff from two data objects.
 
     def self.new_from_data data1, data2, opts={}
-      new ordered_data_string(data1, opts[:struct]),
-          ordered_data_string(data2, opts[:struct]), opts
-    end
-
-
-    ##
-    # Returns a data string that is diff-able, meaning sorted by
-    # Hash keys when available.
-
-    def self.ordered_data_string data, struct_only=false
-      data = Kronk::Path.pathed(data) if Kronk.config[:render_paths]
-
-      case Kronk.config[:render_lang].to_s
-      when 'ruby' then DataRenderer.ruby(data, struct_only)
-      else
-        DataRenderer.json(data, struct_only)
-      end
+      new DataString.new(data1, opts),
+          DataString.new(data2, opts), opts
     end
 
 
@@ -47,13 +32,19 @@ class Kronk
     end
 
 
-    attr_accessor :str1, :str2, :char, :output
+    attr_accessor :str1, :str2, :char, :output, :meta
+
+    ##
+    # Create a new Diff instance from two strings.
+    # Options supported are those of Kronk::Diff::Output, plus:
+    # :char:: String/Regex - The char to split on for comparisons.
 
     def initialize str1, str2, opts={}
       @str1       = str1
       @str2       = str2
       @diff_ary   = nil
       @char       = opts[:char] || /\r?\n/
+      @meta       = []
       @output     = Output.new self, opts
     end
 
@@ -71,7 +62,7 @@ class Kronk
 
     def create_diff
       diff_ary = []
-      return diff_ary if @str1.empty? && @str2.empty?
+      return @str1.split @char if @str1 == @str2
 
       arr1 = @str1.split @char
       arr2 = @str2.split @char
@@ -90,15 +81,20 @@ class Kronk
         right = arr2[last_i2...c[2]]
 
         # add diffs
-        diff_ary << [left, right] unless left.empty? && right.empty?
+        unless left.empty? && right.empty?
+          @meta << []
+          @meta.last[0] = left[0].meta[0]  if left[0].respond_to?(:meta)
+          @meta.last[1] = right[0].meta[0] if right[0].respond_to?(:meta)
+
+          diff_ary << [left, right]
+        end
 
         # add common
         arr1[c[1], c[0]].each_with_index do |str1, i|
           str2 = arr2[c[2]+i]
-          next unless str1.respond_to?(:meta) && str2.respond_to?(:meta) &&
-                      str1.meta.first != str2.meta.first
-
-          str1.meta[0] = [str1.meta[0], str2.meta[0]]
+          @meta << []
+          @meta.last[0] = str1.meta[0] if str1.respond_to?(:meta)
+          @meta.last[1] = str2.meta[0] if str2.respond_to?(:meta)
         end
         diff_ary.concat arr1[c[1], c[0]]
 

data/lib/kronk/path/matcher.rb

@@ -91,16 +91,20 @@ class Kronk::Path::Matcher
       found, kmatch = match_node(@key, key)     if @key
       found, vmatch = match_node(@value, value) if @value && (!@key || found)
 
+      c_path.append_splat self, key if @recursive
+
       if found
         c_path.matches.concat kmatch.to_a
         c_path.matches.concat vmatch.to_a
 
-        yield data, key, c_path if block_given?
-        paths << c_path
+        f_path = c_path.dup
+        f_path.splat[-1][-1].pop if @key && !f_path.splat.empty?
+
+        yield data, key, f_path if block_given?
+        paths << f_path
       end
 
-      paths.concat \
-        find_in(data[key], c_path, &block) if @recursive
+      paths.concat find_in(data[key], c_path, &block) if @recursive
     end
 
     paths

data/lib/kronk/path/path_match.rb

@@ -1,19 +1,30 @@
 ##
-# Represents a single match of a relative path against a data set.
+# Represents the single match of a relative path against a data set.
 
 class Kronk::Path::PathMatch < Array
 
-  attr_accessor :matches
+  attr_accessor :matches, :splat
 
   def initialize *args
     @matches = []
+    @splat   = []
     super
   end
 
 
+  def append_splat id, key # :nodoc:
+    if @splat[-1] && @splat[-1][0] == id
+      @splat[-1][1] << key
+    else
+      @splat << [id, [key]]
+    end
+  end
+
+
   def dup # :nodoc:
     path_match = super
     path_match.matches = @matches.dup
+    path_match.splat   = @splat.map{|key, sp| [key, sp.dup]}
     path_match
   end
 
@@ -29,9 +40,22 @@ class Kronk::Path::PathMatch < Array
 
 
   ##
-  # Builds a path array by replacing %n values with matches.
+  # Builds a path array by replacing %n and %% values with matches and splat.
+  #
+  #   matches = Path.find_in "**/foo=bar", data
+  #   # [["path", "to", "foo"]]
+  #
+  #   matches.first.make_path "root/%%/foo"
+  #   # ["root", "path", "to", "foo"]
+  #
+  #   matches = Path.find_in "path/*/(foo)=bar", data
+  #   # [["path", "to", "foo"]]
+  #
+  #   matches.first.make_path "root/%1/%2"
+  #   # ["root", "to", "foo"]
 
   def make_path path_map, regex_opts=nil, &block
+    tmpsplat = @splat.dup
     path     = []
     escape   = false
     replace  = false
@@ -47,7 +71,27 @@ class Kronk::Path::PathMatch < Array
         new_item = true
 
       when Kronk::Path::RCH
-        replace = true
+        if replace
+          if rindex.empty?
+            unless tmpsplat.empty?
+              items = tmpsplat.shift[1].dup
+              if new_item
+                new_item = false
+              else
+                path[-1] = path[-1].dup << items.shift
+              end
+              path.concat items
+            end
+            replace = false
+          else
+            append_match_for(rindex, path)
+            rindex = ""
+          end
+
+          next
+        else
+          replace = true
+        end
       end and next unless escape
 
       if replace