tty-table 0.1.0 → 0.2.0

data/lib/tty/table/{columns.rb → column_constraint.rb}

@@ -7,24 +7,21 @@ module TTY
     # Used internally by {Renderer::Basic} to enforce correct column widths.
     #
     # @api private
-    class Columns
-
-      attr_reader :table
-
-      attr_reader :renderer
-
+    class ColumnConstraint
       MIN_WIDTH = 1
 
       BORDER_WIDTH = 1
 
       # Initialize a Columns
       #
+      # @param [TTY::Table] table
+      #
       # @param [TTY::Table::Renderer] renderer
       #
       # @api public
-      def initialize(renderer)
+      def initialize(table, renderer)
+        @table    = table
         @renderer = renderer
-        @table    = renderer.table
       end
 
       # Estimate outside border size
@@ -42,7 +39,17 @@ module TTY
       #
       # @api public
       def border_size
-        BORDER_WIDTH * (table.column_size - 1) + outside_border_size
+        BORDER_WIDTH * (table.columns_size - 1) + outside_border_size
+      end
+
+      # Measure total padding size for a table
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def padding_size
+        padding = renderer.padding
+        (padding.left + padding.right) * (table.columns_size - 1)
       end
 
       # Estimate minimum table width to be able to display content
@@ -51,7 +58,7 @@ module TTY
       #
       # @api public
       def minimum_width
-        table.column_size * MIN_WIDTH + border_size
+        table.columns_size * MIN_WIDTH + border_size
       end
 
       # Return column's natural unconstrained widths
@@ -60,7 +67,7 @@ module TTY
       #
       # @api public
       def natural_width
-        renderer.column_widths.inject(0, &:+) + border_size
+        renderer.column_widths.inject(0, &:+) + border_size + padding_size
       end
 
       # Return the constrained column widths.
@@ -72,33 +79,22 @@ module TTY
       def enforce
         assert_minimum_width
 
-        unless renderer.padding.empty?
-          renderer.column_widths = adjust_padding
-        end
-
         if natural_width <= renderer.width
-          renderer.column_widths = expand if renderer.resize
+          renderer.resize ? expand : renderer.column_widths
         else
           if renderer.resize
-            renderer.column_widths = shrink
+            shrink
           else
             rotate
-            renderer.column_widths = ColumnSet.widths_from(table)
           end
         end
       end
 
-      # Adjust column widths to account for padding whitespace
-      #
-      # @api private
-      def adjust_padding
-        padding     =  renderer.padding
-        column_size = table.column_size
+      private
 
-        (0...column_size).reduce([]) do |lengths, col|
-          lengths + [padding.left + renderer.column_widths[col] + padding.right]
-        end
-      end
+      attr_reader :table
+
+      attr_reader :renderer
 
       # Rotate table to vertical orientation and print information to stdout
       #
@@ -109,13 +105,14 @@ module TTY
                    'orientation.'
         table.orientation = :vertical
         table.rotate
+        ColumnSet.widths_from(table)
       end
 
       # Expand column widths to match the requested width
       #
       # @api private
       def expand
-        column_size = table.column_size
+        column_size = table.columns_size
         ratio       = ((renderer.width - natural_width) / column_size.to_f).floor
 
         widths = (0...column_size).reduce([]) do |lengths, col|
@@ -128,7 +125,7 @@ module TTY
       #
       # @api private
       def shrink
-        column_size = table.column_size
+        column_size = table.columns_size
         ratio       = ((natural_width - renderer.width) / column_size.to_f).ceil
 
         widths = (0...column_size).reduce([]) do |lengths, col|
@@ -155,7 +152,8 @@ module TTY
       #
       # @api private
       def distribute_extra_width(widths)
-        column_size     = table.column_size
+        column_size     = table.columns_size
+        # TODO - add padding size to fully check extra width
         extra_width     = renderer.width - (widths.reduce(:+) + border_size)
         per_field_width = extra_width / column_size
         remaining_width = extra_width % column_size
@@ -165,6 +163,6 @@ module TTY
           width + per_field_width + extra[index]
         end
       end
-    end # Columns
+    end # ColumnConstraint
   end # Table
 end # TTY

data/lib/tty/table/column_set.rb

@@ -10,13 +10,13 @@ module TTY
     class ColumnSet
       include Equatable
 
-      attr_reader :table
-
       # Initialize a ColumnSet
       #
+      # @param [Array[Array[Object]]] data
+      #
       # @api public
       def initialize(table)
-        @table = table
+        @data = table.data
       end
 
       # Calculate total table width
@@ -34,10 +34,8 @@ module TTY
       #
       # @api private
       def extract_widths
-        data     = table.data
         colcount = data.max { |row_a, row_b| row_a.size <=> row_b.size }.size
-
-        self.class.find_maximas(colcount, data)
+        find_maximas(colcount)
       end
 
       # Assert data integrity for column widths
@@ -72,10 +70,10 @@ module TTY
       def self.widths_from(table, column_widths = nil)
         case column_widths
         when Array
-          assert_widths(column_widths, table.column_size)
+          assert_widths(column_widths, table.columns_size)
           Array(column_widths).map(&:to_i)
         when Numeric
-          Array.new(table.column_size, column_widths)
+          Array.new(table.columns_size, column_widths)
         when NilClass
           new(table).extract_widths
         else
@@ -85,20 +83,22 @@ module TTY
 
       private
 
+      attr_reader :data
+
       # Find maximum widths for each row and header if present.
       #
       # @param [Integer] colcount
       #   number of columns
-      # @param [Array[Array]] data
-      #   the table's header and rows
+      #
+      # @return [Array[Integer]]
       #
       # @api private
-      def self.find_maximas(colcount, data)
+      def find_maximas(colcount)
         maximas = []
         start   = 0
 
         start.upto(colcount - 1) do |col_index|
-          maximas << find_maximum(data, col_index)
+          maximas << find_maximum(col_index)
         end
         maximas
       end
@@ -106,15 +106,16 @@ module TTY
       # Find a maximum column width. The calculation takes into account
       # wether the content is escaped or not.
       #
-      # @param [Array] data
-      #   the table data
-      #
       # @param [Integer] index
       #   the column index
       #
+      # @return [Integer]
+      #
       # @api private
-      def self.find_maximum(data, index)
-        data.map { |row| (value = row.call(index)) ? value.length : 0 }.max
+      def find_maximum(index)
+        data.map do |row|
+          (field = row.call(index)) ? field.length : 0
+        end.max
       end
     end # ColumnSet
   end # Table

data/lib/tty/table/field.rb

@@ -4,7 +4,8 @@ module TTY
   class Table
     # A class that represents a unique element in a table.
     #
-    # Used internally by {Table::Row} to define internal structure.
+    # Used internally by {Table::Header} and {Table::Row} to
+    # define internal structure.
     #
     # @api private
     class Field
@@ -15,28 +16,40 @@ module TTY
       # @api public
       attr_reader :value
 
+      # The formatted value inside the field used for display
+      #
+      # @api public
+      attr_reader :content
+
       # The name for the value
       #
       # @api public
       attr_reader :name
 
-      # TODO: Change to :content to separate value from formatted string
+      # The actual value
+      #
+      # @api public
       attr_writer :value
 
-      # The field value width
+      # The formatted string
       #
       # @api public
-      attr_reader :width
+      attr_writer :content
 
       # Number of columns this field spans. Defaults to 1.
       #
+      # @api public
       attr_reader :colspan
 
       # Number of rows this field spans. Defaults to 1.
       #
+      # @api public
       attr_reader :rowspan
 
-      attr_reader :align
+      # The field alignment
+      #
+      # @api public
+      attr_reader :alignment
 
       # Initialize a Field
       #
@@ -49,15 +62,16 @@ module TTY
       #   field.value  # => a1
       #
       # @example
-      #   field = TTY::Table::Field.new value: 'a1', align: :center
-      #   field.value  # => a1
-      #   field.align  # => :center
+      #   field = TTY::Table::Field.new value: 'a1', alignment: :center
+      #   field.value     # => a1
+      #   field.alignment # => :center
       #
       # @api private
       def initialize(value)
         options  = extract_options(value)
-        @width   = options.fetch(:width) { @value.to_s.size }
-        @align   = options.fetch(:align) { nil }
+        @content = @value.to_s
+        @width   = options[:width]
+        @alignment = options.fetch(:alignment) { nil }
         @colspan = options.fetch(:colspan) { 1 }
         @rowspan = options.fetch(:rowspan) { 1 }
       end
@@ -76,15 +90,18 @@ module TTY
         options
       end
 
-      # Return the width this field would normally have bar other contraints
+      # Reset to original value
       #
       # @api public
-      def value_width
-        @width
+      def reset!
+        @content = @value.to_s
       end
 
-      def value_height
-        @height
+      # The content width
+      #
+      # @api public
+      def width
+        @width || UnicodeUtils.display_width(@content)
       end
 
       # Return number of lines this value spans.
@@ -95,8 +112,8 @@ module TTY
       #
       # @api public
       def lines
-        escaped = value.to_s.scan(/(\\n|\\t|\\r)/)
-        escaped.empty? ? value.to_s.split(/\n/, -1) : [value.to_s]
+        escaped = content.scan(/(\\n|\\t|\\r)/)
+        escaped.empty? ? content.split(/\n/, -1) : [content]
       end
 
       # If the string contains unescaped new lines then the longest token
@@ -106,7 +123,9 @@ module TTY
       #
       # @api public
       def length
-        (lines.max_by(&:length) || '').size
+        (lines.map do |line|
+          display_width(self.class.color.strip(line))
+        end << 0).max
       end
 
       # Extract the number of lines this value spans
@@ -119,20 +138,26 @@ module TTY
       end
 
       def chars
-        value.chars
+        content.chars
       end
 
-      # Render value inside this field box
+      # Return field content
+      #
+      # @return [String]
       #
       # @api public
-      def render
+      def to_s
+        content
       end
 
-      # Return field value
-      #
       # @api public
-      def to_s
-        value
+      def self.color
+        @color ||= Pastel.new(enabled: true)
+      end
+
+      # @api public
+      def display_width(string)
+        UnicodeUtils.display_width(string)
       end
     end # Field
   end # Table

data/lib/tty/table/header.rb

@@ -39,8 +39,8 @@ module TTY
       # Iterate over each element in the vector
       #
       # @example
-      #   vec = Vector[1,2,3]
-      #   vec.each { |element| ... }
+      #   header = TTY::Table::Header.new [1,2,3]
+      #   header.each { |element| ... }
       #
       # @return [self]
       #
@@ -158,6 +158,10 @@ module TTY
       def to_hash
         to_a.hash
       end
+
+      def inspect
+        "#<#{self.class.name} fields=#{to_a}>"
+      end
     end # Header
   end # Table
 end # TTY

data/lib/tty/table/indentation.rb

@@ -4,21 +4,16 @@ module TTY
   class Table
     # A class responsible for indenting table representation
     class Indentation
-
-      attr_reader :renderer
-
-      # Initialize an Indentation
+      # The amount of indentation
       #
       # @api public
-      def initialize(renderer)
-        @renderer = renderer
-      end
+      attr_accessor :indentation
 
-      # Create indentation
+      # Initialize an Indentation
       #
       # @api public
-      def indentation
-        ' ' * renderer.indent
+      def initialize(indentation)
+        @indentation = indentation
       end
 
       # Return a table part with indentation inserted
@@ -27,7 +22,7 @@ module TTY
       #   the rendered table part
       #
       # @api public
-      def insert_indent(part)
+      def indent(part)
         if part.respond_to?(:to_a)
           part.map { |line| insert_indentation(line) }
         else
@@ -45,7 +40,7 @@ module TTY
       # @api public
       def insert_indentation(line)
         line = line.is_a?(Array) ? line[0] : line
-        line.insert(0, indentation) if line
+        line.insert(0, ' ' * indentation) if line
       end
     end # Indentation
   end # Table