ansi 1.4.1 → 1.4.2

data/lib/ansi/bbcode.rb

@@ -1,4 +1,4 @@
-# = BBCode
+# BBCode
 #
 # Copyright (c) 2002 Thomas-Ivo Heinen
 #
@@ -9,31 +9,26 @@
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.
 
+#
 module ANSI
 
-  # = BBCode
-  #
+  # TODO: Integrate BBCode with Code module.
+
   # The BBCode module helps ease the separation of core and frontend with the
   # core (or submodules) being still able to say, what colors shall be used
   # in it's responses. This is achieved by encoding formatting information
   # using the BBCode tokens. This enables you to "pipe" layout information
-  # such as colors, style, fonttype, size and alignment through the core to
+  # such as colors, style, font, size and alignment through the core to
   # the frontend.
   #
   # Additionally it converts markups/codes between ANSI, HTML and BBCode
   # almost freely ;)
   #
-  # == Usage
-  #
   #   # Converting a bbcode string to ANSI and XHTML
-  #
   #   str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
   #   print( BBCode.bbcode_to_ansi(str) )
   #   print( BBCode.bbcode_to_html(str) )
   #
-  #--
-  # TODO: integrate with Code module.
-  #++
   module BBCode
 
     ## ANSIname => ANSIcode LUT

data/lib/ansi/chain.rb

@@ -0,0 +1,50 @@
+require 'ansi/code'
+
+module ANSI
+
+  # ANSI::Chain was inspired by Kazuyoshi Tlacaelel's Isna library.
+  #
+  class Chain
+
+    #
+    def initialize(string)
+      @string = string.to_s
+      @codes  = []
+    end
+
+    #
+    attr :string
+
+    #
+    attr :codes
+
+    #
+    def method_missing(s, *a, &b)
+      if ANSI::CHART.key?(s)
+        @codes << s
+        self
+      else
+        super(s, *a, &b)
+      end
+    end
+
+    #
+    def to_s
+      if codes.empty?
+        result = @string
+      else
+        result = Code.ansi(@string, *codes)
+        codes.clear
+      end
+      result
+    end
+
+    #
+    def to_str
+      to_s
+    end
+
+  end
+
+end
+

data/lib/ansi/chart.rb

@@ -19,6 +19,7 @@ module ANSI
     :slow_blink       => 5,
     :rapid            => 6,
     :rapid_blink      => 6,
+    :invert           => 7,
     :inverse          => 7,
     :reverse          => 7,
     :negative         => 7,

data/lib/ansi/code.rb

@@ -17,6 +17,8 @@ module ANSI
   # NOTE: This has no effect of methods that return ANSI codes.
   $ansi = true
 
+  # TODO: up, down, right, left, etc could have yielding methods too?
+
   # ANSI Codes
   #
   # Ansi::Code module makes it very easy to use ANSI codes.
@@ -32,10 +34,6 @@ module ANSI
   #
   # See {ANSI::Code::CHART} for list of all supported codes.
   #
-  #--
-  # TODO: up, down, right, left, etc could have yielding methods too?
-  #++
-
   module Code
     extend self
 
@@ -235,9 +233,13 @@ module ANSI
 
       return string unless $ansi
 
-      code(*codes) + string + ENDCODE
+      c = code(*codes)
+
+      c + string.gsub(ENDCODE, ENDCODE + c) + ENDCODE
     end
 
+    # TODO: Allow selective removal using *codes argument?
+
     # Remove ANSI codes from string or block value.
     #
     # @param [String]
@@ -246,9 +248,6 @@ module ANSI
     # @return [String]
     #   String wrapped ANSI code.
     #
-    #--
-    # TODO: Allow selective removal using *codes argument?
-    #++
     def unansi(string=nil) #:yield:
       if block_given?
         string = yield.to_s

data/lib/ansi/columns.rb

@@ -3,32 +3,47 @@ require 'ansi/terminal'
 
 module ANSI
 
+  #
   class Columns
 
     # Create a column-based layout.
     #
-    # list - Multiline String or Array of strings to columnize
+    # @param [String,Array] list
+    #   Multiline String or Array of strings to columnize.
     #
-    # options[:columns] - number of columns
-    # options[:align]   - align :left or :right
-    # options[:padding] - space to add to each cell
+    # @param [Hash] options
+    #   Options to customize columnization.
+    #
+    # @option options [Fixnum] :columns
+    #   Number of columns.
+    #
+    # @option options [Symbol] :align
+    #   Column alignment, either :left, :right or :center.
+    #
+    # @option options [String,Fixnum] :padding
+    #   String or number or spaces to append to each column.
     #
     # The +format+ block MUST return ANSI codes.
     def initialize(list, options={}, &format)
       self.list = list
 
-      @columns = options[:columns]
-      @padding = options[:padding] || 1
-      @align   = options[:align]
-      #@ansi    = [options[:ansi]].flatten
-      @format  = format
+      self.columns = options[:columns] || options[:cols]
+      self.padding = options[:padding] || 1
+      self.align   = options[:align]   || :left
+      #self.ansi    = options[:ansi]
+      self.format  = format
 
-      @columns = nil if @columns == 0
+      #@columns = nil if @columns == 0
+    end
+
+    #
+    def inspect
+      "#<#{self.class}:#{object_id} #{list.inspect} x #{columns}>"
     end
 
     # List layout into columns. Each new line is taken to be 
     # a row-column cell.
-    attr_accessor :list
+    attr :list
 
     def list=(list)
       case list
@@ -41,38 +56,80 @@ module ANSI
 
     # Default number of columns to display. If nil then the number
     # of coumns is estimated from the size of the terminal.
-    attr_accessor :columns
+    attr :columns
+
+    # Set column count ensuring value is either an integer or nil.
+    # The the value given is zero, it will be taken to mean the same
+    # as nil, which means fit-to-screen.
+    def columns=(integer)
+      integer = integer.to_i
+      @columns = (integer.zero? ? nil : integer)
+    end
 
     # Padding size to apply to cells.
-    attr_accessor :padding
+    attr :padding
+
+    # Set padding to string or number (of spaces).
+    def padding=(pad)
+      case pad
+      when Numeric
+        @padding = ' ' * pad.to_i
+      else
+        @padding = pad.to_s
+      end
+    end
 
     # Alignment to apply to cells.
-    attr_accessor :align
+    attr :align
+
+    # Set alignment ensuring value is a symbol.
+    #
+    # @param [Symbol] Either `:right`, `:left` or `:center`.
+    def align=(symbol)
+      symbol = symbol.to_sym
+      raise ArgumentError, "invalid alignment -- #{symbol.inspect}" \
+            unless [:left, :right, :center].include?(symbol)
+      @align = symbol
+    end
 
     # Formating to apply to cells.
-    attr_accessor :format
+    attr :format
+
+    # Set formatting procedure. The procedure must return
+    # ANSI codes, suitable for passing to String#ansi method.
+    def format=(procedure)
+      @format = procedure ? procedure.to_proc : nil
+    end
+
+    # TODO: Should #to_s also take options and formatting block?
+    #       Maybe instead have hoin take all these and leave #to_s bare.
 
     # Return string in column layout. The number of columns is determined
     # by the `columns` property or overriden by +cols+ argument.
-    #--
-    # TODO: Allow #to_s to take options and formating block?
-    #++
     def to_s(cols=nil)
       to_s_columns(cols || columns)
     end
 
-    private
+    #
+    def join(cols=nil)
+      to_s_columns(cols || columns)
+    end
+
+  private
 
     # Layout string lines into columns.
     #
-    # TODO: put in empty strings for blank cells
+    # @todo Put in empty strings for blank cells.
+    # @todo Centering look like it's off by one to the right.
+    #
     def to_s_columns(columns=nil)
       lines = list.to_a
       count = lines.size
       max   = lines.map{ |l| l.size }.max
+
       if columns.nil?
         width = Terminal.terminal_width
-        columns = (width / (max + padding)).to_i
+        columns = (width / (max + padding.size)).to_i
       end
 
       rows = []
@@ -83,12 +140,12 @@ module ANSI
         (rows[index % mod] ||=[]) << line.strip
       end
 
-      pad = " " * padding
+      pad = padding
       tmp = template(max, pad)
       str = ""
       rows.each_with_index do |row, ri|
         row.each_with_index do |cell, ci|
-          ansi_codes = ansi_formating(cell, ci, ri)
+          ansi_codes = ansi_formatting(cell, ci, ri)
           if ansi_codes.empty?
             str << (tmp % cell)
           else
@@ -102,10 +159,11 @@ module ANSI
     end
 
     # Aligns the cell left or right.
-    #
-    # TODO: Handle centered alignment.
     def template(max, pad)
       case align
+      when :center, 'center'
+        offset = " " * (max / 2)
+        "#{offset}%#{max}s#{offset}#{pad}"
       when :right, 'right'
         "%#{max}s#{pad}"
       else
@@ -113,8 +171,8 @@ module ANSI
       end
     end
 
-    # Used to apply ANSI formating to each cell.
-    def ansi_formating(cell, col, row)
+    # Used to apply ANSI formatting to each cell.
+    def ansi_formatting(cell, col, row)
       if @format
         case @format.arity
         when 0

data/lib/ansi/constants.rb

@@ -1,10 +1,17 @@
 module ANSI
 
+  require 'ansi/chart'
+
   # Converts {CHART} and {SPECIAL_CHART} entries into constants.
+  # So for example, the CHART entry for :red becomes:
+  #
+  #   ANSI::Constants::RED  #=> "\e[31m"
+  #
+  # The ANSI Constants are include into ANSI::Code and can be included
+  # any where will they would be of use.
+  #
   module Constants
 
-    require 'ansi/chart'
-
     CHART.each do |name, code|
       const_set(name.to_s.upcase, "\e[#{code}m")
     end

data/lib/ansi/core.rb

@@ -1,9 +1,15 @@
 require 'ansi/code'
+require 'ansi/chain'
 
 class ::String
+
   #
   def ansi(*codes)
-    ANSI::Code.ansi(self, *codes)
+    if codes.empty?
+      ANSI::Chain.new(self)
+    else
+      ANSI::Code.ansi(self, *codes)
+    end
   end
 
   #

data/lib/ansi/diff.rb

@@ -2,9 +2,33 @@ require 'ansi/code'
 
 module ANSI
 
-  # Diff can produced a colorized difference of two string or objects.
+  # Diff produces colorized differences of two string or objects.
+  #
   class Diff
 
+    # Highlights the differnce between two strings.
+    #
+    # This class method is equivalent to calling:
+    #
+    #   ANSI::Diff.new(object1, object2).to_a
+    #
+    def self.diff(object1, object2, options={})
+      new(object1, object2, options={}).to_a
+    end
+
+    # Setup new Diff object. If the objects given are not Strings
+    # and do not have `#to_str` defined to coerce them to such, then
+    # their `#inspect` methods are used to convert them to strings
+    # for comparison.
+    #
+    # @param [Object] object1
+    #   First object to compare.
+    #
+    # @param [Object] object2
+    #   Second object to compare.
+    #
+    # @param [Hash] options
+    #   Options for contoller the way difference is shown. (Not yet used.)
     #
     def initialize(object1, object2, options={})
       @object1 = convert(object1)
@@ -13,25 +37,56 @@ module ANSI
       @diff1, @diff2 = diff_string(@object1, @object2)
     end
 
-    #
+    # Returns the first object's difference string.
     def diff1
       @diff1
     end
 
-    #
+    # Returns the second object's difference string.
     def diff2
       @diff2
     end
 
+    # Returns both first and second difference strings separated by a
+    # new line character.
     #
+    # @todo Should we use `$/` record separator instead?
+    #
+    # @return [String] Joined difference strings.
     def to_s
       "#{@diff1}\n#{@diff2}"
     end
 
-    private
+    # Returns both first and second difference strings separated by a
+    # the given `separator`. The default is `$/`, the record separator.
+    #
+    # @param [String] separator
+    #   The string to use as the separtor between the difference strings.
+    #
+    # @return [String] Joined difference strings.
+    def join(separator=$/)
+      "#{@diff1}#{separator}#{@diff2}"
+    end
+
+    # Returns the first and second difference strings in an array.
+    #
+    # @return [Array] Both difference strings.
+    def to_a
+      [diff1, diff2]
+    end
+
+  private
 
     # Take two plain strings and produce colorized
     # versions of each highlighting their differences.
+    #
+    # @param [String] string1
+    #   First string to compare.
+    #
+    # @param [String] string2
+    #   Second string to compare.
+    #
+    # @return [Array<String>] The two difference strings.
     def diff_string(string1, string2)
       compare(string1, string2)
     end
@@ -52,7 +107,16 @@ module ANSI
     # Rotation of colors for diff output.
     COLORS = [:red, :yellow, :magenta]
 
+    # Take two plain strings and produce colorized
+    # versions of each highlighting their differences.
     #
+    # @param [String] string1
+    #   First string to compare.
+    #
+    # @param [String] string2
+    #   Second string to compare.
+    #
+    # @return [Array<String>] The two difference strings.
     def compare(x, y)
       c = common(x, y)
       a = x.dup
@@ -70,7 +134,8 @@ module ANSI
       return a, b
     end
 
-    #
+    # Oh, I should have documented this will I knew what the
+    # hell it was doing ;)
     def common(x,y)
       c = lcs(x, y)
 
@@ -99,24 +164,7 @@ module ANSI
       [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
-
-    #
+    # Least common string.
     def lcs(s1, s2)
       res="" 
       num=Array.new(s1.size){Array.new(s2.size)}
@@ -145,6 +193,23 @@ module ANSI
       res
     end
 
+    # Hmm... is this even useful?
+    def lcs_size(s1, s2)
+      num=Array.new(s1.size){Array.new(s2.size)}
+      len,ans=0,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
+
   end
 
 end