di 0.3.2 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85e6d0dda9d8ab2f37c5781743238023291f5d3a
+  data.tar.gz: d08a5f0ea260bdd94ff720f73670490acdebf649
+SHA512:
+  metadata.gz: 672d1f491243ad2ede807e4176ced0c0fa216965a223e2ea8e8bf44b853cb93ea8d792fb6fa5031708c31b84603d65f2b4a8a79ce03de371bda958983ede1e17
+  data.tar.gz: b5fd0a90f9bace17a97e72b3df21259d96f768b14042b0e1bd5623175b547f16ab2c44d9835905de9402f4c4c03bdf469c9741c221631a7c3943dbadd9c7dbde

data/di.gemspec

@@ -25,4 +25,5 @@ EOS
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
+  gem.add_runtime_dependency("diff-lcs", ["~> 1.2.2"])
 end

data/lib/di.rb

@@ -28,7 +28,7 @@
 # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 # SUCH DAMAGE.
 
-MYVERSION = "0.3.2"
+MYVERSION = "0.4.0"
 MYNAME = File.basename($0)
 MYCOPYRIGHT = "Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Akinori MUSHA"
 
@@ -59,6 +59,10 @@ FIGNORE_GLOBS = ENV.fetch('FIGNORE', '').split(':').map { |pat|
 
 IO::NULL = '/dev/null' unless defined? IO::NULL
 
+PLUS_SIGN  = '+'
+MINUS_SIGN = '-'
+EQUAL_SIGN = '='
+
 def main(args)
   setup
 
@@ -77,28 +81,32 @@ end
 
 def setup
   require 'ostruct'
-  $diff = OpenStruct.new
-  $diff.exclude = []
-  $diff.include = []
-  $diff.flags = []
-  $diff.format_flags = []
-  $diff.format = :normal
-  $diff.colors = {
-    :comment	=> "\e[1m",
-    :file1	=> "\e[1m",
-    :file2	=> "\e[1m",
-    :header	=> "\e[36m",
-    :function	=> "\e[m",
-    :new	=> "\e[32m",
-    :old	=> "\e[31m",
-    :changed	=> "\e[33m",
-    :unchanged	=> "",
-    :whitespace	=> "\e[41m",
-    :off	=> "\e[m",
-    :open_inv	=> "\e[7m",
-    :close_inv	=> "\e[27m",
-  }
-  $diff.reversed = false
+  $diff = OpenStruct.new({
+      :exclude => [],
+      :include => [],
+      :flags => [],
+      :format_flags => [],
+      :format => :normal,
+      :colors => OpenStruct.new({
+          :comment	=> "\e[1m",
+          :file1	=> "\e[1m",
+          :file2	=> "\e[1m",
+          :header	=> "\e[36m",
+          :function	=> "\e[m",
+          :new		=> "\e[32m",
+          :old		=> "\e[31m",
+          :new_word	=> "\e[7;32m",
+          :old_word	=> "\e[7;31m",
+          :changed	=> "\e[33m",
+          :unchanged	=> "",
+          :whitespace	=> "\e[40m",
+          :off		=> "\e[m",
+          :open_inv	=> "\e[7m",
+          :close_inv	=> "\e[27m",
+        }),
+      :reversed => false,
+      :word_regex => /([@$%]*[[:alnum:]_]+|[^\n])/,
+    })
 end
 
 def parse_args!(args)
@@ -127,7 +135,7 @@ usage: #{MYNAME} [flags] [files]
       $diff.colorize = val if $stdout.tty?
     }
     opts.on('--[no-]highlight-whitespace',
-      'Highlight suspicious whitespace differences in colorized output. [+][*]') { |val|
+      'Highlight whitespace differences in colorized output. [+][*]') { |val|
       $diff.highlight_whitespace = val
     }
     opts.on('--[no-]rsync-exclude', '--[no-]cvs-exclude',
@@ -702,91 +710,229 @@ def diff_exclude?(dir, basename)
 end
 
 def colorize_unified_diff(io)
+  begin
+    require 'diff/lcs'
+    colorize_unified_diff_hunk = method(:colorize_hunk_in_unified_diff_inline)
+  rescue LoadError
+    colorize_unified_diff_hunk = method(:colorize_hunk_in_unified_diff_normal)
+  end
+
   colors = $diff.colors
+  colors.to_function ||= colors.off + colors.function
 
   state = :comment
   hunk_left = nil
+  hunk = []
   io.each_line { |line|
+    line.chomp!
     replace_invalid_bytes!(line)
     case state
     when :comment
       case line
       when /^\+{3} /
-        color = colors[:file1]
+        color = colors.file1
       when /^-{3} /
-        color = colors[:file2]
+        color = colors.file2
       when /^@@ -[0-9]+(,([0-9]+))? \+[0-9]+(,([0-9]+))?/
         state = :hunk
         hunk_left = ($1 ? $2.to_i : 1) + ($3 ? $4.to_i : 1)
-        line.sub!(/^(@@ .*? @@)( )?/) {
-          $1 + ($2 ? colors[:off] + $2 + colors[:function] : '')
+        line.sub!(/^(@@ .*? @@ )/) {
+          $1 + colors.to_function
         }
-        color = colors[:header]
+        color = colors.header
       else
-        color = colors[:comment]
+        color = colors.comment
       end
     when :hunk
-      check = false
+      hunk << line
       case line
-      when /^\+/
-        color = colors[:new]
-        hunk_left -= 1
-        check = $diff.highlight_whitespace
-      when /^-/
-        color = colors[:old]
+      when /^[-+]/
         hunk_left -= 1
-        check = $diff.highlight_whitespace
       when /^ /
-        color = colors[:unchanged]
         hunk_left -= 2
-      else
-        # error
-        color = colors[:comment]
-      end
-      if check
-        line.sub!(/([ \t]+)$/) {
-          colors[:off] + colors[:whitespace] + $1
-        }
-        true while line.sub!(/^(.[ \t]*)( +)(\t)/) {
-          $1 + colors[:off] + colors[:whitespace] + $2 + colors[:off] + color + $3
-        }
       end
       if hunk_left <= 0
-        state = :comment
+        colorize_unified_diff_hunk.call(hunk)
         hunk_left = nil
+        hunk.clear
+        state = :comment
       end
+      next
     end
 
-    line.sub!(/^/, color)
-    line.sub!(/$/, colors[:off])
-
-    print line
+    print color, line, colors.off, "\n"
   }
 
   io.close
 end
 
+def colorize_hunk_in_unified_diff_normal(hunk)
+  colors = $diff.colors
+
+  hunk.each { |line|
+    case line
+    when /^\+/
+      color = colors.new
+      ws = $diff.highlight_whitespace
+    when /^-/
+      color = colors.old
+      ws = $diff.highlight_whitespace
+    when /^ /
+      color = colors.unchanged
+      ws = false
+    end
+    if ws
+      highlight_whitespace_in_unified_diff!(line, color)
+    end
+    print color, line, colors.off, "\n"
+  }
+end
+
+def colorize_hunk_in_unified_diff_inline(hunk)
+  colors = $diff.colors
+
+  skip_next = false
+
+  Enumerator.new { |y|
+    y << nil
+    hunk.each { |line|
+      y << line
+    }
+    y << nil << nil
+  }.each_cons(4) { |line0, line1, line2, line3|
+    case
+    when skip_next
+      skip_next = false
+      next
+    when line1.nil?
+      break
+    when /^[-+]/ !~ line0 && /^-/ =~ line1 &&  /^\+/ =~ line2 &&  /^[-+]/ !~ line3
+      colorize_inline_diff(line1, line2)
+      skip_next = true
+      next
+    when /^\+/ =~ line1
+      color = colors.new
+      ws = $diff.highlight_whitespace
+    when /^-/ =~ line1
+      color = colors.old
+      ws = $diff.highlight_whitespace
+    when /^ / =~ line1
+      color = colors.unchanged
+      ws = false
+    end
+    if ws
+      line1 = line1.dup
+      highlight_whitespace_in_unified_diff!(line1, color)
+    end
+    print color, line1, colors.off, "\n"
+  }
+end
+
+def colorize_inline_diff(line1, line2)
+  words1, words2 = [line1, line2].map { |line|
+    line[1..-1].split($diff.word_regex)
+  }
+  xwords1, xwords2 = [words1, words2].map { |words|
+    words.each_with_index.map { |word, i| i.even? ? nil : word }
+  }
+  swords1, swords2, signs1, signs2 = [], [], [], []
+
+  Diff::LCS.sdiff(xwords1, xwords2).each { |tuple|
+    sign, (pos1, word1), (pos2, word2) = *tuple
+    case sign
+    when PLUS_SIGN
+      if signs2.last == sign
+        swords2.last << word2 if word2
+      else
+        swords2 << (word2 || '')
+        signs2 << sign
+      end
+    when MINUS_SIGN
+      if signs1.last == sign
+        swords1.last << word1 if word1
+      else
+        swords1 << (word1 || '')
+        signs1 << sign
+      end
+    else
+      if signs1.last == sign
+        swords1.last << words1[pos1]
+      else
+        swords1 << words1[pos1]
+        signs1 << sign
+      end
+      if signs2.last == sign
+        swords2.last << words2[pos2]
+      else
+        swords2 << words2[pos2]
+        signs2 << sign
+      end
+    end
+  }
+
+  colors = $diff.colors
+
+  aline1 = ''.tap { |line|
+    signs1.zip(swords1) { |sign, word|
+      case sign
+      when EQUAL_SIGN
+        line << colors.off << colors.old << word
+      else
+        line << colors.off << colors.old_word << word
+      end
+    }
+  }
+  aline2 = ''.tap { |line|
+    signs2.zip(swords2) { |sign, word|
+      case sign
+      when EQUAL_SIGN
+        line << colors.off << colors.new << word
+      else
+        line << colors.off << colors.new_word << word
+      end
+    }
+  }
+
+  print colors.old, '-', aline1, "\n",
+        colors.new, '+', aline2, "\n"
+end
+
+def highlight_whitespace_in_unified_diff!(line, color)
+  colors = $diff.colors
+  colors.to_whitespace ||= colors.off + colors.whitespace
+
+  line.gsub!(/([ \t]+)$|( +)(?=\t)/) {
+    if $1
+      colors.to_whitespace + $1
+    else
+      colors.to_whitespace + $2 << colors.off << color
+    end
+  }
+end
+
 def colorize_context_diff(io)
   colors = $diff.colors
+  colors.to_function ||= colors.off + colors.function
 
   state = :comment
   hunk_part = nil
   io.each_line { |line|
+    line.chomp!
     replace_invalid_bytes!(line)
     case state
     when :comment
       case line
       when /^\*{3} /
-        color = colors[:file1]
+        color = colors.file1
       when /^-{3} /
-        color = colors[:file2]
+        color = colors.file2
       when /^\*{15}/
         state = :hunk
         hunk_part = 0
-        line.sub!(/^(\*{15})( )?/) {
-          $1 + ($2 ? colors[:off] + $2 + colors[:function] : '')
+        line.sub!(/^(\*{15} )/) {
+          $1 + colors.to_function
         }
-        color = colors[:header]
+        color = colors.header
       end
     when :hunk
       case hunk_part
@@ -794,10 +940,10 @@ def colorize_context_diff(io)
         case line
         when /^\*{3} /
           hunk_part = 1
-          color = colors[:header]
+          color = colors.header
         else
           # error
-          color = colors[:comment]
+          color = colors.comment
         end
       when 1, 2
         check = false
@@ -805,53 +951,60 @@ def colorize_context_diff(io)
         when /^\-{3} /
           if hunk_part == 1
             hunk_part = 2
-            color = colors[:header]
+            color = colors.header
           else
             #error
-            color = colors[:comment]
+            color = colors.comment
           end
         when /^\*{3} /, /^\*{15} /
           state = :comment
           redo
         when /^\+ /
-          color = colors[:new]
+          color = colors.new
           check = $diff.highlight_whitespace
         when /^- /
-          color = colors[:old]
+          color = colors.old
           check = $diff.highlight_whitespace
         when /^! /
-          color = colors[:changed]
+          color = colors.changed
           check = $diff.highlight_whitespace
         when /^  /
-          color = colors[:unchanged]
+          color = colors.unchanged
         else
           # error
-          color = colors[:comment]
+          color = colors.comment
         end
         if check
-          line.sub!(/^(. .*)([ \t]+)$/) {
-            $1 + colors[:off] + colors[:whitespace] + $2
-          }
-          true while line.sub!(/^(. [ \t]*)( +)(\t)/) {
-            $1 + colors[:off] + colors[:whitespace] + $2 + colors[:off] + color + $3
-          }
+          highlight_whitespace_in_context_diff!(line, color)
         end
       end
     end
 
-    line.sub!(/^/, color)
-    line.sub!(/$/, colors[:off])
-
-    print line
+    print color, line, colors.off, "\n"
   }
 
   io.close
 end
 
+def highlight_whitespace_in_context_diff!(line, color)
+  colors = $diff.colors
+  colors.to_whitespace ||= colors.off + colors.whitespace
+
+  line.gsub!(/^(..)|([ \t]+)$|( +)(?=\t)/) {
+    if $1
+      $1
+    elsif $2
+      colors.to_whitespace + $2
+    else
+      colors.to_whitespace + $3 << colors.off << color
+    end
+  }
+end
+
 def replace_invalid_bytes!(text)
   colors = $diff.colors
   text.replace(text.replace_invalid_bytes { |byte|
-      '%s<%02X>%s' % [colors[:open_inv], byte, colors[:close_inv]]
+      '%s<%02X>%s' % [colors.open_inv, byte, colors.close_inv]
     })
 end
 

metadata

@@ -1,21 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: di
 version: !ruby/object:Gem::Version
-  version: 0.3.2
-  prerelease: 
+  version: 0.4.0
 platform: ruby
 authors:
 - Akinori MUSHA
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-09 00:00:00.000000000 Z
-dependencies: []
-description: ! 'The di(1) command wraps around GNU diff(1) to provide reasonable
-
+date: 2013-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+description: |
+  The di(1) command wraps around GNU diff(1) to provide reasonable
   default settings and some original features.
-
-'
 email:
 - knu@idaemons.org
 executables:
@@ -38,27 +49,26 @@ files:
 - test/test_di.rb
 homepage: https://github.com/knu/di
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A wrapper around GNU diff(1)
 test_files:
 - test/helper.rb