ansi 1.2.5 → 1.3.0

data/lib/ansi/constants.rb

@@ -0,0 +1,18 @@
+module ANSI
+
+  # Converts {CHART} and {SPECIAL_CHART} entries into constants.
+  module Constants
+
+    require 'ansi/chart'
+
+    CHART.each do |name, code|
+      const_set(name.to_s.upcase, "\e[#{code}m")
+    end
+
+    SPECIAL_CHART.each do |name, code|
+      const_set(name.to_s.upcase, code)
+    end
+
+  end
+
+end

data/lib/ansi/core.rb

@@ -0,0 +1,24 @@
+require 'ansi/code'
+
+class ::String
+  #
+  def ansi(*codes)
+    ANSI::Code.ansi(self, *codes)
+  end
+
+  #
+  def ansi!(*codes)
+    replace(ansi(*codes))
+  end
+
+  #
+  def unansi
+    ANSI::Code.unansi(self)
+  end
+
+  #
+  def unansi!
+    replace(unansi)
+  end
+end
+

data/lib/ansi/diff.rb

@@ -3,8 +3,6 @@ require 'ansi/code'
 module ANSI
 
   # Diff can produced a colorized difference of two string or objects.
-  #
-  # IMPORTANT! This class is still a very much a work in progress.
   class Diff
 
     #
@@ -34,65 +32,8 @@ module ANSI
 
     # Take two plain strings and produce colorized
     # versions of each highlighting their differences.
-    #
-    # TODO: I am sure there are better ways to do this,
-    # but for now this suffices.
-    def diff_string(str1, str2)
-      i1, i2 = 0, 0
-      m1, m2 = nil, nil
-      s1, s2 = "", ""
-      t1, t2 = "", ""
-      c = 0
-
-      loop do
-        if str1[i1,1] == str2[i2,1]
-          s1 << red(t1); t1 = "" unless t1 == ""
-          s2 << red(t2); t2 = "" unless t2 == ""
-          s1 << str1[i1,1].to_s
-          s2 << str2[i2,1].to_s
-          i1 += 1; i2 += 1
-          #m1 += 1; m2 += 1
-        else
-          if m1 && str1[m1,1] == str2[i2,1]
-            s2 << color1(t2)
-            t1, t2 = "", ""
-            i1 = m1
-            m1, m2 = nil, nil
-          elsif m2 && str1[i1,1] == str2[m2,1]
-            s1 << color2(t1)
-            t1, t2 = "", ""
-            i2 = m2
-            m1, m2 = nil, nil
-          else
-            t1 << str1[i1,1].to_s
-            t2 << str2[i2,1].to_s
-            m1, m2 = i1, i2 if m1 == nil
-            i1 += 1; i2 += 1
-          end
-        end
-        break if i1 >= str1.size && i2 >= str2.size
-      end
-      s1 << red(t1); t1 = "" unless t1 == ""
-      s2 << red(t2); t2 = "" unless t2 == ""
-      #s1 << ANSI::Code::CLEAR
-      #s2 << ANSI::Code::CLEAR
-
-      return s1, s2
-    end
-
-    #
-    def red(str)
-      ANSI.color(:red){ str }
-    end
-
-    #
-    def color1(str)
-      ANSI.color(:blue){ str }
-    end
-
-    #
-    def color2(str)
-      ANSI.color(:green){ str }
+    def diff_string(string1, string2)
+      compare(string1, string2)
     end
 
     # Ensure the object of comparison is a string. If +object+ is not
@@ -108,6 +49,102 @@ module ANSI
       end
     end
 
+    # Rotation of colors for diff output.
+    COLORS = [:red, :yellow, :magenta]
+
+    #
+    def compare(x, y)
+      c = common(x, y)
+      a = x.dup
+      b = y.dup
+      oi = 0
+      oj = 0
+      c.each_with_index do |m, q|
+        i = a.index(m, oi)
+        j = b.index(m, oj)
+        a[i,m.size] = ANSI.ansi(m, COLORS[q%3]) if i
+        b[j,m.size] = ANSI.ansi(m, COLORS[q%3]) if j
+        oi = i + m.size if i
+        oj = j + m.size if j
+      end
+      return a, b
+    end
+
+    #
+    def common(x,y)
+      c = lcs(x, y)
+
+      i = x.index(c)
+      j = y.index(c)
+
+      ix = i + c.size
+      jx = j + c.size
+
+      if i == 0 
+        l = y[0...j]
+      elsif j == 0
+        l = x[0...i]
+      else
+        l = common(x[0...i], y[0...j])
+      end
+
+      if ix == x.size - 1
+        r = y[jx..-1]
+      elsif jx = y.size - 1
+        r = x[ix..-1]
+      else
+        r = common(x[ix..-1], y[jx..-1])
+      end
+
+      [l, c, r].flatten.reject{ |s| s.empty? }
+    end
+
+    #
+    def lcs_size(s1, s2)
+      num=Array.new(s1.size){Array.new(s2.size)}
+      len,ans=0
+      s1.scan(/./).each_with_index do |l1,i |
+        s2.scan(/./).each_with_index do |l2,j |
+          unless l1==l2
+            num[i][j]=0
+          else
+            (i==0 || j==0)? num[i][j]=1 : num[i][j]=1 + num[i-1][j-1]
+            len = ans = num[i][j] if num[i][j] > len
+          end
+        end
+      end
+      ans
+    end
+
+    #
+    def lcs(s1, s2)
+      res="" 
+      num=Array.new(s1.size){Array.new(s2.size)}
+      len,ans=0
+      lastsub=0
+      s1.scan(/./).each_with_index do |l1,i |
+        s2.scan(/./).each_with_index do |l2,j |
+          unless l1==l2
+            num[i][j]=0
+          else
+            (i==0 || j==0)? num[i][j]=1 : num[i][j]=1 + num[i-1][j-1]
+            if num[i][j] > len
+              len = ans = num[i][j]
+              thissub = i
+              thissub -= num[i-1][j-1] unless num[i-1][j-1].nil?  
+              if lastsub==thissub
+                res+=s1[i,1]
+              else
+                lastsub=thissub
+                res=s1[lastsub, (i+1)-lastsub]
+              end
+            end
+          end
+        end
+      end
+      res
+    end
+
   end
 
 end

data/lib/ansi/string.rb

@@ -1,23 +1,22 @@
 require 'ansi/code'
 #require 'ansi/layout/split'
-#require 'clio/facets/string'
 
 # Create a new Ansi::String object.
 def ANSI.string(str)
   ANSI::String.new(str)
 end
 
-# = String
+# IMPORTANT! ANSI::String is experimental!!!
 #
-# ANSI Strings store a regular string (@text) and
-# a Hash mapping character index to ANSI codes (@marks).
+# ANSI::String stores a regular string (`@text`) and an associative
+# array that ties a character index to an ANSI code (`marks`).
 # For example is we have the string:
 #
 #   "Big Apple"
 #
-# And applied the color red to it, the marks hash would be:
+# And applied the color red to it, the marks list would be:
 #
-#   { 0=>[:red] , 9=>[:clear] }
+#   [[0, :red], [9, :clear]]
 #
 # TODO: In the future we may be able to subclass String,
 # instead of delegating via @text, but not until it is more
@@ -25,7 +24,7 @@ end
 #
 class ANSI::String
 
-  CLR = ANSI::Code.clear
+  CLR = ANSI::Code::CLEAR
 
   attr :text
   attr :marks
@@ -41,7 +40,7 @@ class ANSI::String
   # This converts the intental markup codes to ANSI codes.
   def to_s
     s = text.dup
-    m = marks.sort do |(a,b)|
+    m = marks.sort do |a,b|
       v = b[0] <=> a[0]
       if v == 0
         (b[1] == :clear or b[1] == :reset) ? -1 : 1

data/lib/ansi/terminal.rb

@@ -16,10 +16,10 @@ module ANSI
 
     modes = %w{win32 termios curses stty}
 
-    #
     # This section builds character reading and terminal size functions
-    # to suit the proper platform we're running on.  Be warned:  Here be
-    # dragons!
+    # to suit the proper platform we're running on.
+    #
+    # Be warned: Here be dragons!
     #
     begin
       require 'ansi/terminal/' + (mode = modes.pop)

data/qed/01_ansicode.rdoc

@@ -44,13 +44,6 @@ As well as combined color methods.
   str = white_on_red + "Hello"
   str.assert == "\e[37m\e[41mHello"
 
-In addition the library offers an extension to String class
-called #ansi, which allows some of the ANSI::Code methods
-to be called in a more object-oriented fashion.
-
-  str = "Hello".ansi(:red) + "World".ansi(:blue)
-  str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
-
 The ANSI::Code module supports most standard ANSI codes, though
 not all platforms support every code, so YMMV.
 

data/qed/09_diff.rb

@@ -7,7 +7,7 @@
 
   diff = ANSI::Diff.new(a,b)
 
-  puts diff.to_s
+  diff.to_s.assert == "\e[31mabc\e[0m\e[33mYefg\e[0m\n\e[31mabc\e[0mXefg"
 
 Try another.
 
@@ -16,7 +16,7 @@ Try another.
 
   diff = ANSI::Diff.new(a,b)
 
-  puts diff.to_s
+  diff.to_s.assert == "\e[31mabc\e[0m\n\e[31mabc\e[0mdef"
 
 And another.
 
@@ -25,7 +25,7 @@ And another.
 
   diff = ANSI::Diff.new(a,b)
 
-  puts diff.to_s
+  diff.to_s.assert == "\e[31mabc\e[0m\e[33mXXXghi\e[0m\n\e[31mabc\e[0mdefghi"
 
 And another.
 
@@ -34,7 +34,7 @@ And another.
 
   diff = ANSI::Diff.new(a,b)
 
-  puts diff.to_s
+  diff.to_s.assert == "\e[31mabc\e[0m\e[33mXXX\e[0m\e[35mdefghi\e[0m\n\e[31mabc\e[0m\e[35mdefghi\e[0m"
 
 Comparison that is mostly different.
 
@@ -43,5 +43,5 @@ Comparison that is mostly different.
 
   diff = ANSI::Diff.new(a,b)
 
-  puts diff.to_s
+  diff.to_s.assert == "\e[31mabc\e[0m\e[33mpppz123\e[0m\n\e[31mabc\e[0mxyzzz43"
 

data/qed/10_core.rdoc

@@ -0,0 +1,11 @@
+= String Extensions
+
+In addition the library offers an extension to String class
+called #ansi, which allows some of the ANSI::Code methods
+to be called in a more object-oriented fashion.
+
+  require 'ansi/core'
+
+  str = "Hello".ansi(:red) + "World".ansi(:blue)
+  str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+

data/test/case_ansicode.rb

@@ -1,19 +1,29 @@
 require 'ansi/code'
 
-class TestANSICode < KO::TestCase
+testcase ANSI::Code do
 
-  include ANSI::Code
+  unit :red do
+    str = ANSI::Code.red
+    out = "\e[31m"
+    out.assert == str
+  end
+
+  unit :red => "with block notation" do
+    str = ANSI::Code.red { "Hello" }
+    out = "\e[31mHello\e[0m"
+    out.assert == str
+  end
 
-  test "base methods" do
-    str = red + "Hello" + blue + "World"
-    out = "\e[31mHello\e[34mWorld"
-    out == str
+  unit :blue do
+    str = ANSI::Code.blue
+    out = "\e[34m"
+    out.assert == str
   end
 
-  test "block notation" do
-    str = red { "Hello" } + blue { "World" }
-    out = "\e[31mHello\e[0m\e[34mWorld\e[0m"
-    out == str
+  unit :blue => "with block notation" do
+    str = ANSI::Code.blue { "World" }
+    out = "\e[34mWorld\e[0m"
+    out.assert == str
   end
 
 end

data/test/case_bbcode.rb

@@ -1,28 +1,27 @@
 require 'ansi/bbcode'
 
-class TC_BBCode < KO::TestCase
+testcase ANSI::BBCode do
 
-  test "to_ansi" do
+  meta :bbcode_to_ansi do
     str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
     out = "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n"
-    out == ANSI::BBCode.bbcode_to_ansi(str)
+    out.assert == ANSI::BBCode.bbcode_to_ansi(str)
   end
 
-  test "to_html" do
+  meta :bbcode_to_html do
     str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
     out = "this is <font color=\"red\">red</font>, this is <strong>bold</strong><br />\n"
-    out == ANSI::BBCode.bbcode_to_html(str)
+    out.assert == ANSI::BBCode.bbcode_to_html(str)
   end
 
-  test "ansi_to_html" do
+  meta :ansi_to_html do
     str = "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n" +
           "this is a line without any ansi code\n" +
           "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n"
     out = "this is <font color=\"red\">red</font>, this is <strong>bold</strong><br />\n" +
           "this is a line without any ansi code<br />\n" +
           "this is <font color=\"red\">red</font>, this is <strong>bold</strong><br />\n"
-    out == ANSI::BBCode.ansi_to_html(str)
+    out.assert == ANSI::BBCode.ansi_to_html(str)
   end
 
 end
-

data/test/case_mixin.rb

@@ -1,21 +1,28 @@
 require 'ansi/mixin'
 
-class TestANSIMixin < KO::TestCase
+testcase ANSI::Mixin do
 
+  # TODO: subclass
   class ::String
     include ANSI::Mixin
   end
 
-  test "methods" do
-    str = "Hello".red + "World".blue
-    out = "\e[31mHello\e[0m\e[34mWorld\e[0m"
-    out == str
+  unit :red do
+    str = "Hello".red
+    out = "\e[31mHello\e[0m"
+    out.assert == str
   end
 
-  test "display" do
+  unit :blue do
+    str = "World".blue
+    out = "\e[34mWorld\e[0m"
+    out.assert == str
+  end
+
+  unit :display do
     str = "Hello".display(4,10)
     out = "\e[s\e[4;10HHello\e[u"
-    out == str
+    out.assert == str
   end
 
 end