columnist 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fa0309605840f3f0d3703adf7b0aeec35c32458
-  data.tar.gz: da7cd50f03f621888fedd2cb2ac4a42243c098b3
+  metadata.gz: 8962f15088195abd57cc2343cff652e21cdf6cfa
+  data.tar.gz: cbd0348c061ef751a9fe77c772603ccfe34a2f13
 SHA512:
-  metadata.gz: d1b9986c7cf20d37fad2b7dc5e52f55571caa290a955c459d4051c42522f4d831a74b37dfa3671d260981849330655dc1510f8fb1224f51d912eb4df43d0f35f
-  data.tar.gz: 6c12a03ec438fffffbce01633cea2052c1f3f23fb3231bf72955305b7ed54206064427ab9ce98a112297da9dda5239de74655855b19955bf48c0525f39feaa84
+  metadata.gz: 6440fd90b250f7c050f588b8c139e12e892d653e3388898663489225f8fafa0fe5e3e3d641ceef1da5dbdef0ed3937b5fb3545f696bb6972d220678949c94f00
+  data.tar.gz: 2006cfcb0515993cc9940c58f5b5062de17cceceb5e092b9b8f62b5b785902224ae7631537ef3a8174d6116b0c39f18e69afe16bf393dd7ebfacb7920331caa5

data/lib/columnist/column.rb

@@ -5,19 +5,19 @@ module Columnist
         include OptionsValidator
 
         VALID_OPTIONS = [:width, :padding, :align, :color, :bold, :underline, :reversed]
-        attr_accessor :text, :size, *VALID_OPTIONS
+        attr_accessor :text, :text_without_colors, :size, *VALID_OPTIONS
 
         def initialize(text = nil, options = {})
             self.validate_options(options, *VALID_OPTIONS)
-            self.text = text.to_s
-            self.width = options[:width] || 10
-            self.align = options[:align] || 'left'
-            self.padding = options[:padding] || 0
-            self.color = options[:color] || nil
-            self.bold = options[:bold] || false
-            self.underline = options[:underline] || false
-            self.reversed = options[:reversed] || false
-
+            self.text_without_colors = text.to_s.gsub(/(.)\[\d{1,3};\d{1,3};\d{1,3}m/, '')
+            self.text                = text.to_s
+            self.width               = options[:width] || 10
+            self.align               = options[:align] || 'left'
+            self.padding             = options[:padding] || 0
+            self.color               = options[:color] || nil
+            self.bold                = options[:bold] || false
+            self.underline           = options[:underline] || false
+            self.reversed            = options[:reversed] || false
             raise ArgumentError unless self.width > 0
             raise ArgumentError unless self.padding.to_s.match(/^\d+$/)
         end
@@ -27,14 +27,37 @@ module Columnist
         end
 
         def required_width
-            self.text.to_s.size + 2 * self.padding
+            self.text_without_colors.to_s.size + 2 * self.padding
         end
 
         def screen_rows
-            if self.text.nil? || self.text.empty?
+            if self.text_without_colors.nil? || self.text_without_colors.empty?
                 [' ' * self.width]
             else
-                self.text.scan(/.{1,#{self.size}}/m).map { |s| to_cell(s) }
+                x = self.text.scan(/.{1,#{self.size}}/).map { |s| to_cell(s) }
+                if x.length > 1
+                    actual_length = 0
+                    x.each do |z|
+                        z                    = z.gsub(/\A(.)\[\d{1,3};\d{1,3};\d{1,3}m/, '').gsub(/\s+(.)\[\d{1,3};\d{1,3};\d{1,3}m\z/, '')
+                        characters_to_ignore = 0
+                        matches_to_ignore    = z.scan(/\[\d{1,3};\d{1,3};\d{1,3}m/)
+                        matches_to_ignore.each do |match|
+                            characters_to_ignore += match.length + 1
+                        end
+                        actual_length += z.length - characters_to_ignore
+                    end
+                    if actual_length < self.size
+                        y = []
+                        x.each do |z|
+                            y << z.gsub(/\A(.)\[\d{1,3};\d{1,3};\d{1,3}m/, '').gsub(/\s+(.)\[\d{1,3};\d{1,3};\d{1,3}m\z/, '')
+                        end
+                        y = ["#{y.join}#{' ' * (self.size - actual_length)}"]
+                        return y
+                    end
+                    return [x[0]]
+                else
+                    return x
+                end
             end
         end
 
@@ -44,7 +67,7 @@ module Columnist
             # NOTE: For making underline and reversed work Change so that based on the
             # unformatted text it determines how much spacing to add left and right
             # then colorize the cell text
-            cell = str.empty? ? blank_cell : aligned_cell(str)
+            cell        = str.empty? ? blank_cell : aligned_cell(str)
             padding_str = ' ' * self.padding
             padding_str + colorize(cell) + padding_str
         end

data/lib/columnist/formatter/nested.rb

@@ -2,69 +2,69 @@ require 'singleton'
 require 'colored'
 
 module Columnist
-  class NestedFormatter
-    include Singleton
-    include OptionsValidator
+    class NestedFormatter
+        include Singleton
+        include OptionsValidator
 
-    VALID_OPTIONS = [:message, :type, :complete, :indent_size, :color, :bold]
-    attr_accessor :indent_size, :complete_string, :message_string, :color, :bold
+        VALID_OPTIONS = [:message, :type, :complete, :indent_size, :color, :bold]
+        attr_accessor :indent_size, :complete_string, :message_string, :color, :bold
 
-    def format(options, block)
-      self.validate_options(options, *VALID_OPTIONS)
+        def format(options, block)
+            self.validate_options(options, *VALID_OPTIONS)
 
-      indent_level :incr
+            indent_level :incr
 
-      padding = ' ' * @indent_level * (options[:indent_size] || self.indent_size)
+            padding = ' ' * @indent_level * (options[:indent_size] || self.indent_size)
 
-      message_str = padding + (options[:message] || self.message_string)
-      complete_str = options[:complete] || self.complete_string
+            message_str  = padding + (options[:message] || self.message_string)
+            complete_str = options[:complete] || self.complete_string
 
-      if options[:type] == 'inline'
-        colorize("#{message_str}...", true, options)
-      else
-        colorize(message_str, false, options)
-        complete_str = padding + complete_str
-      end
+            if options[:type] == 'inline'
+                colorize("#{message_str}...", true, options)
+            else
+                colorize(message_str, false, options)
+                complete_str = padding + complete_str
+            end
 
-      block.call
+            block.call
 
-      colorize(complete_str, false, options)
+            colorize(complete_str, false, options)
 
-      indent_level :decr
-    end
+            indent_level :decr
+        end
 
-    def message_string
-      @message_string ||= 'working'
-    end
+        def message_string
+            @message_string ||= 'working'
+        end
 
-    def complete_string
-      @complete_string ||= 'complete'
-    end
+        def complete_string
+            @complete_string ||= 'complete'
+        end
 
-    def indent_size
-      @indent_size ||= 2
-    end
+        def indent_size
+            @indent_size ||= 2
+        end
 
-    private
+        private
 
-    def colorize(str, inline, options)
-      str = str.send(options[:color]) if options[:color]
-      str = str.bold if options[:bold]
+        def colorize(str, inline, options)
+            str = str.send(options[:color]) if options[:color]
+            str = str.bold if options[:bold]
 
-      if inline
-        print str
-      else
-        puts str
-      end
-    end
+            if inline
+                print str
+            else
+                puts str
+            end
+        end
 
-    def indent_level(value)
-      case value
-      when :incr
-        @indent_level = (@indent_level) ? @indent_level + 1 : 0
-      when :decr
-        @indent_level -= 1
-      end
+        def indent_level(value)
+            case value
+                when :incr
+                    @indent_level = (@indent_level) ? @indent_level + 1 : 0
+                when :decr
+                    @indent_level -= 1
+            end
+        end
     end
-  end
 end

data/lib/columnist/formatter/progress.rb

@@ -2,36 +2,36 @@ require 'singleton'
 require 'colored'
 
 module Columnist
-  class ProgressFormatter
-    include Singleton
-    include OptionsValidator
+    class ProgressFormatter
+        include Singleton
+        include OptionsValidator
 
-    VALID_OPTIONS = [:indicator, :color, :bold]
-    attr_accessor *VALID_OPTIONS
+        VALID_OPTIONS = [:indicator, :color, :bold]
+        attr_accessor *VALID_OPTIONS
 
-    def format(options, block)
-      self.validate_options(options, *VALID_OPTIONS)
+        def format(options, block)
+            self.validate_options(options, *VALID_OPTIONS)
 
-      self.indicator = options[:indicator] if options[:indicator]
-      self.color = options[:color]
-      self.bold = options[:bold] || false
+            self.indicator = options[:indicator] if options[:indicator]
+            self.color     = options[:color]
+            self.bold      = options[:bold] || false
 
-      block.call
+            block.call
 
-      puts
-    end
+            puts
+        end
 
-    def progress(override = nil)
-      str = override || self.indicator
+        def progress(override = nil)
+            str = override || self.indicator
 
-      str = str.send(self.color) if self.color
-      str = str.send('bold') if self.bold
+            str = str.send(self.color) if self.color
+            str = str.send('bold') if self.bold
 
-      print str
-    end
+            print str
+        end
 
-    def indicator
-      @indicator ||= '.'
+        def indicator
+            @indicator ||= '.'
+        end
     end
-  end
 end

data/lib/columnist/options_validator.rb

@@ -1,5 +1,5 @@
 module OptionsValidator
-  def validate_options(provided, *allowed_keys)
-    raise(ArgumentError, "Valid options: #{allowed_keys}") unless (provided.keys - allowed_keys).empty?
-  end
+    def validate_options(provided, *allowed_keys)
+        raise(ArgumentError, "Valid options: #{allowed_keys}") unless (provided.keys - allowed_keys).empty?
+    end
 end

data/lib/columnist/row.rb

@@ -7,13 +7,13 @@ module Columnist
 
         def initialize(options = {})
             self.validate_options(options, *VALID_OPTIONS)
-            self.columns = []
-            self.border = false
-            self.header = options[:header] || false
-            self.color = options[:color]
+            self.columns      = []
+            self.border       = false
+            self.header       = options[:header] || false
+            self.color        = options[:color]
             self.border_color = options[:border_color]
-            self.bold = options[:bold] || false
-            self.encoding = options[:encoding] || :unicode
+            self.bold         = options[:bold] || false
+            self.encoding     = options[:encoding] || :unicode
         end
 
         def add(column)
@@ -32,7 +32,7 @@ module Columnist
             screen_count.times do |sr|
                 border_char = use_utf8? ? "\u2503" : '|'
                 border_char = colorize(border_char, self.border_color)
-                line = (self.border) ? "#{border_char} " : ''
+                line        = (self.border) ? "#{border_char} " : ''
                 self.columns.size.times do |mc|
                     col = self.columns[mc]
                     # Account for the fact that some columns will have more screen rows than their

data/lib/columnist/table.rb

@@ -7,17 +7,17 @@ module Columnist
 
         def initialize(options = {})
             self.validate_options(options, *VALID_OPTIONS)
-            self.border = options[:border] || false
+            self.border       = options[:border] || false
             self.border_color = options[:border_color] || false
-            self.width = options[:width] || false
-            self.encoding = options[:encoding] || Columnist::DEFAULTS[:encoding]
-            @rows = []
+            self.width        = options[:width] || false
+            self.encoding     = options[:encoding] || Columnist::DEFAULTS[:encoding]
+            @rows             = []
             raise ArgumentError, 'Invalid encoding' unless [:ascii, :unicode].include? self.encoding
         end
 
         def add(row)
             # Inheritance from the table
-            row.border = self.border
+            row.border       = self.border
             row.border_color = self.border_color
 
             # Inherit properties from the appropriate row
@@ -58,8 +58,8 @@ module Columnist
 
         def separator(type = 'middle')
             left, center, right, bar = use_utf8? ? utf8_separator(type) : ascii_separator
-            separator_str = left + self.rows[0].columns.map { |c| bar * (c.width + 2) }.join(center) + right
-            separator_str = colorize(separator_str, self.border_color)
+            separator_str            = left + self.rows[0].columns.map { |c| bar * (c.width + 2) }.join(center) + right
+            separator_str            = colorize(separator_str, self.border_color)
         end
 
         def use_utf8?
@@ -68,7 +68,7 @@ module Columnist
 
         def ascii_separator
             left = right = center = '+'
-            bar = '-'
+            bar  = '-'
             [left, right, center, bar]
         end
 

data/lib/columnist.rb

@@ -8,166 +8,166 @@ require 'columnist/column'
 require 'columnist/table'
 
 module Columnist
-  include OptionsValidator
-
-  attr_reader :formatter
-
-  DEFAULTS = {
-    :width => 100,
-    :align => 'left',
-    :formatter => 'nested',
-    :encoding => :unicode,
-  }
+    include OptionsValidator
+
+    attr_reader :formatter
+
+    DEFAULTS = {
+        :width     => 100,
+        :align     => 'left',
+        :formatter => 'nested',
+        :encoding  => :unicode,
+    }
+
+    def capture_output
+        $stdout.rewind
+        $stdout.read
+    ensure
+        $stdout = STDOUT
+    end
 
-  def capture_output
-    $stdout.rewind
-    $stdout.read
-  ensure
-    $stdout = STDOUT
-  end
-
-  def suppress_output
-    $stdout = StringIO.new
-  end
-
-  def restore_output
-    $stdout = STDOUT
-  end
-
-  def formatter=(type = 'nested')
-    name = type.capitalize + 'Formatter'
-    klass = %W{Columnist #{name}}.inject(Kernel) {|s,c| s.const_get(c)}
-
-    # Each formatter is a singleton that responds to #instance
-    @formatter = klass.instance
-  rescue
-    raise ArgumentError, 'Invalid formatter specified'
-  end
-
-  def header(options = {})
-    section(:header, options)
-  end
-
-  def report(options = {}, &block)
-    self.formatter ||= DEFAULTS[:formatter]
-    self.formatter.format(options, block)
-  end
+    def suppress_output
+        $stdout = StringIO.new
+    end
 
-  def progress(override = nil)
-    self.formatter.progress(override)
-  end
+    def restore_output
+        $stdout = STDOUT
+    end
 
-  def footer(options = {})
-    section(:footer, options)
-  end
+    def formatter=(type = 'nested')
+        name  = type.capitalize + 'Formatter'
+        klass = %W{Columnist #{name}}.inject(Kernel) { |s, c| s.const_get(c) }
 
-  def horizontal_rule(options = {})
-    validate_options(options, :char, :width, :color, :bold)
+        # Each formatter is a singleton that responds to #instance
+        @formatter = klass.instance
+    rescue
+        raise ArgumentError, 'Invalid formatter specified'
+    end
 
-    # Got unicode?
-    use_char = "\u2501" == 'u2501' ? '-' : "\u2501"
+    def header(options = {})
+        section(:header, options)
+    end
 
-    char = options[:char].is_a?(String) ? options[:char] : use_char
-    width = options[:width] || DEFAULTS[:width]
+    def report(options = {}, &block)
+        self.formatter ||= DEFAULTS[:formatter]
+        self.formatter.format(options, block)
+    end
 
-    aligned(char * width, :width => width, :color => options[:color], :bold => options[:bold])
-  end
+    def progress(override = nil)
+        self.formatter.progress(override)
+    end
 
-  def vertical_spacing(lines = 1)
-    puts "\n" * lines
-  rescue
-    raise ArgumentError
-  end
+    def footer(options = {})
+        section(:footer, options)
+    end
 
-  def datetime(options = {})
-    validate_options(options, :align, :width, :format, :color, :bold)
+    def horizontal_rule(options = {})
+        validate_options(options, :char, :width, :color, :bold)
 
-    format = options[:format] || '%Y-%m-%d - %l:%M:%S%p'
-    align = options[:align] || DEFAULTS[:align]
-    width = options[:width] || DEFAULTS[:width]
+        # Got unicode?
+        use_char = "\u2501" == 'u2501' ? '-' : "\u2501"
 
-    text = Time.now.strftime(format)
+        char  = options[:char].is_a?(String) ? options[:char] : use_char
+        width = options[:width] || DEFAULTS[:width]
 
-    raise Exception if text.size > width
+        aligned(char * width, :width => width, :color => options[:color], :bold => options[:bold])
+    end
 
-    aligned(text, :align => align, :width => width, :color => options[:color], :bold => options[:bold])
-  end
+    def vertical_spacing(lines = 1)
+        puts "\n" * lines
+    rescue
+        raise ArgumentError
+    end
 
-  def aligned(text, options = {})
-    validate_options(options, :align, :width, :color, :bold)
+    def datetime(options = {})
+        validate_options(options, :align, :width, :format, :color, :bold)
 
-    align = options[:align] || DEFAULTS[:align]
-    width = options[:width] || DEFAULTS[:width]
-    color = options[:color]
-    bold = options[:bold] || false
+        format = options[:format] || '%Y-%m-%d - %l:%M:%S%p'
+        align  = options[:align] || DEFAULTS[:align]
+        width  = options[:width] || DEFAULTS[:width]
 
-    line = case align
-           when 'left'
-             text
-           when 'right'
-             text.rjust(width)
-           when 'center'
-             text.rjust((width - text.size)/2 + text.size)
-           else
-             raise ArgumentError
-           end
+        text = Time.now.strftime(format)
 
-    line = line.send(color) if color
-    line = line.send('bold') if bold
-
-    puts line
-  end
+        raise Exception if text.size > width
 
-  def table(options = {})
-    @table = Columnist::Table.new(options)
-    yield
-    @table.output
-  end
+        aligned(text, :align => align, :width => width, :color => options[:color], :bold => options[:bold])
+    end
 
-  def row(options = {})
-    options[:encoding] ||= @table.encoding
-    @row = Columnist::Row.new(options)
-    yield
-    @table.add(@row)
-  end
+    def aligned(text, options = {})
+        validate_options(options, :align, :width, :color, :bold)
+
+        align = options[:align] || DEFAULTS[:align]
+        width = options[:width] || DEFAULTS[:width]
+        color = options[:color]
+        bold  = options[:bold] || false
+
+        line = case align
+                   when 'left'
+                       text
+                   when 'right'
+                       text.rjust(width)
+                   when 'center'
+                       text.rjust((width - text.size)/2 + text.size)
+                   else
+                       raise ArgumentError
+               end
+
+        line = line.send(color) if color
+        line = line.send('bold') if bold
+
+        puts line
+    end
 
-  def column(text, options = {})
-    col = Columnist::Column.new(text, options)
-    @row.add(col)
-  end
+    def table(options = {})
+        @table = Columnist::Table.new(options)
+        yield
+        @table.output
+    end
 
-  private
+    def row(options = {})
+        options[:encoding] ||= @table.encoding
+        @row               = Columnist::Row.new(options)
+        yield
+        @table.add(@row)
+    end
 
-  def section(type, options)
-    title, width, align, lines, color, bold = assign_section_properties(options)
+    def column(text, options = {})
+        col = Columnist::Column.new(text, options)
+        @row.add(col)
+    end
 
-    # This also ensures that width is a Fixnum
-    raise ArgumentError if title.size > width
+    private
 
-    if type == :footer
-      vertical_spacing(lines)
-      horizontal_rule(:char => options[:rule], :width => width, :color => color, :bold => bold) if options[:rule]
-    end
+    def section(type, options)
+        title, width, align, lines, color, bold = assign_section_properties(options)
+
+        # This also ensures that width is a Fixnum
+        raise ArgumentError if title.size > width
 
-    aligned(title, :align => align, :width => width, :color => color, :bold => bold)
-    datetime(:align => align, :width => width, :color => color, :bold => bold) if options[:timestamp]
+        if type == :footer
+            vertical_spacing(lines)
+            horizontal_rule(:char => options[:rule], :width => width, :color => color, :bold => bold) if options[:rule]
+        end
 
-    if type == :header
-      horizontal_rule(:char => options[:rule], :width => width, :color => color, :bold => bold) if options[:rule]
-      vertical_spacing(lines)
+        aligned(title, :align => align, :width => width, :color => color, :bold => bold)
+        datetime(:align => align, :width => width, :color => color, :bold => bold) if options[:timestamp]
+
+        if type == :header
+            horizontal_rule(:char => options[:rule], :width => width, :color => color, :bold => bold) if options[:rule]
+            vertical_spacing(lines)
+        end
     end
-  end
 
-  def assign_section_properties options
-    validate_options(options, :title, :width, :align, :spacing, :timestamp, :rule, :color, :bold)
+    def assign_section_properties options
+        validate_options(options, :title, :width, :align, :spacing, :timestamp, :rule, :color, :bold)
 
-    title = options[:title] || 'Report'
-    width = options[:width] || DEFAULTS[:width]
-    align = options[:align] || DEFAULTS[:align]
-    lines = options[:spacing] || 1
-    color = options[:color]
-    bold = options[:bold] || false
+        title = options[:title] || 'Report'
+        width = options[:width] || DEFAULTS[:width]
+        align = options[:align] || DEFAULTS[:align]
+        lines = options[:spacing] || 1
+        color = options[:color]
+        bold  = options[:bold] || false
 
-    return [title, width, align, lines, color, bold]
-  end
+        return [title, width, align, lines, color, bold]
+    end
 end