tty 0.0.10 → 0.0.11

data/lib/tty/table/columns.rb

@@ -0,0 +1,167 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+
+    # A class responsible for enforcing column constraints
+    class Columns
+
+      attr_reader :table
+
+      attr_reader :renderer
+
+      MIN_WIDTH = 1
+
+      BORDER_WIDTH = 1
+
+      # Initialize a Columns
+      #
+      # @param [TTY::Table::Renderer]
+      #
+      # @api public
+      def initialize(renderer)
+        @renderer = renderer
+        @table    = renderer.table
+      end
+
+      # Estimate outside border size
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def outside_border_size
+        renderer.border_class == TTY::Table::Border::Null ? 0 : 2
+      end
+
+      # Total border size
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def border_size
+        BORDER_WIDTH * (table.column_size - 1) + outside_border_size
+      end
+
+      # Estimate minimum table width to be able to display content
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def minimum_width
+        table.column_size * MIN_WIDTH + border_size
+      end
+
+      # Return column's natural unconstrained widths
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def natural_width
+        renderer.column_widths.inject(0, &:+) + border_size
+      end
+
+      # Return the constrained column widths. Account for table field widths
+      # and any user defined constraints on the table width.
+      #
+      # @api public
+      def enforce
+        assert_minimum_width
+
+        if not renderer.padding.empty?
+          renderer.column_widths = adjust_padding
+        end
+
+        if natural_width <= renderer.width
+          renderer.column_widths = expand if renderer.resize
+        else
+          if renderer.resize
+            renderer.column_widths = 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
+
+        (0...column_size).reduce([]) do |lengths, col|
+          lengths + [padding.left + renderer.column_widths[col] + padding.right]
+        end
+      end
+
+      # Rotate table to vertical orientation and print information to stdout
+      #
+      # @api private
+      def rotate
+        TTY.shell.warn 'The table size exceeds the currently set width.' +
+        'To avoid error either. Defaulting to vertical orientation.'
+        table.orientation= :vertical
+        table.rotate
+      end
+
+      # Expand column widths to match the requested width
+      #
+      # @api private
+      def expand
+        column_size = table.column_size
+        ratio       = ((renderer.width - natural_width) / column_size.to_f).floor
+
+        widths = (0...column_size).reduce([]) do |lengths, col|
+          lengths + [renderer.column_widths[col] + ratio]
+        end
+        distribute_extra_width(widths)
+      end
+
+      # Shrink column widths to match the requested width
+      #
+      # @api private
+      def shrink
+        column_size = table.column_size
+        ratio       = ((natural_width - renderer.width) / column_size.to_f).ceil
+
+        widths = (0...column_size).reduce([]) do |lengths, col|
+          lengths + [renderer.column_widths[col] - ratio]
+        end
+        distribute_extra_width(widths)
+      end
+
+      # Assert minimum width for the table content
+      #
+      # @raise [TTY::ResizeError]
+      #
+      # @api private
+      def assert_minimum_width
+        width = renderer.width
+        if width <= minimum_width
+          raise ResizeError,
+            "Table's width is too small to contain the content " +
+            "(min width #{minimum_width}, currently set #{width})"
+        end
+      end
+
+      # Distribute remaining width to meet the total width requirement.
+      #
+      # @param [Array[Integer]] widths
+      #
+      # @api private
+      def distribute_extra_width(widths)
+        column_size     = table.column_size
+        extra_width     = renderer.width - (widths.reduce(:+) + border_size)
+        per_field_width = extra_width / column_size
+        remaining_width = extra_width % column_size
+        extra = [1] * remaining_width + [0] * (column_size - remaining_width)
+
+        widths.map.with_index do |width, index|
+          width + per_field_width + extra[index]
+        end
+      end
+
+    end # Columns
+  end # Table
+end # TTY

data/lib/tty/table/field.rb

@@ -77,7 +77,7 @@ module TTY
       # @api public
       def lines
         escaped = value.to_s.scan(/(\\n|\\t|\\r)/)
-        escaped.empty? ? value.to_s.split(/\n/) : [value.to_s]
+        escaped.empty? ? value.to_s.split(/\n/, -1) : [value.to_s]
       end
 
       # If the string contains unescaped new lines then the longest token
@@ -87,7 +87,7 @@ module TTY
       #
       # @api public
       def length
-        lines.max_by(&:length).size
+        (lines.max_by(&:length) || '').size
       end
 
       # Extract the number of lines this value spans

data/lib/tty/table/indentation.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+
+    # A class responsible for indenting table representation
+    class Indentation
+
+      attr_reader :renderer
+
+      # Initialize an Indentation
+      #
+      # @api public
+      def initialize(renderer)
+        @renderer = renderer
+      end
+
+      # Create indentation
+      #
+      # @api public
+      def indentation
+        ' ' * renderer.indent
+      end
+
+      # Return a table part with indentation inserted
+      #
+      # @param [#map, #to_s] part
+      #   the rendered table part
+      #
+      # @api public
+      def insert_indent(part)
+        if part.respond_to?(:to_a)
+          part.map { |line| insert_indentation(line) }
+        else
+          insert_indentation(part)
+        end
+      end
+
+      private
+
+      # Insert indentation into a table renderd line
+      #
+      # @param [#to_a, #to_s] line
+      #   the rendered table line
+      #
+      # @api public
+      def insert_indentation(line)
+        line = line.is_a?(Array) ? line[0] : line
+        line.insert(0, indentation) if line
+      end
+
+    end # Indentation
+  end # Table
+end # TTY

data/lib/tty/table/operation/escape.rb

@@ -19,7 +19,7 @@ module TTY
         #
         # @api public
         def call(field, row, col)
-          field.value = field.value.gsub(/(\t|\r|\n)/) do |val|
+          field.value = field.value.to_s.gsub(/(\t|\r|\n)/) do |val|
             val.dump.gsub('"', '')
           end
         end

data/lib/tty/table/operation/filter.rb

@@ -30,7 +30,6 @@ module TTY
         end
 
       end # Filter
-
     end # Operation
   end # Table
 end # TTY

data/lib/tty/table/operation/padding.rb

@@ -0,0 +1,95 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    module Operation
+
+      # A class responsible for padding field with whitespace
+      class Padding
+
+        attr_reader :padding_top
+
+        attr_reader :padding_right
+
+        attr_reader :padding_bottom
+
+        attr_reader :padding_left
+
+        attr_reader :padding_width
+
+        attr_reader :multiline
+
+        # Initialize a Padding operation
+        #
+        # @param [TTY::Table::Padder]
+        #
+        # @api public
+        def initialize(padding, multiline)
+          @padding_top    = "\n" * padding.top
+          @padding_right  = ' '  * padding.right
+          @padding_bottom = "\n" * padding.bottom
+          @padding_left   = ' '  * padding.left
+          @padding_width  = padding.left + padding.right
+          @multiline      = multiline
+        end
+
+        # Apply padding to a field
+        #
+        # @param [TTY::Table::Field] field
+        #   the table field
+        #
+        # @param [Integer] row
+        #   the field row index
+        #
+        # @param [Integer] col
+        #   the field column index
+        #
+        # @return [TTY::Table::Field]
+        #
+        # @api public
+        def call(field, row, col)
+          text      = field.value.to_s
+
+          text = multiline ?  pad_multi_line(text) : pad_single_line(text)
+          text.insert(0, padding_top).insert(-1, padding_bottom)
+
+          field.value = text
+        end
+
+        # Apply padding to multi line text
+        #
+        # @param [String] text
+        #
+        # @return [String]
+        #
+        # @api private
+        def pad_multi_line(text)
+          text.split("\n", -1).map { |part| pad_around(part) }.join("\n")
+        end
+
+        # Apply padding to single line text
+        #
+        # @param [String] text
+        #
+        # @return [String]
+        #
+        # @api private
+        def pad_single_line(text)
+          pad_around(text.strip)
+        end
+
+        # Apply padding to left and right side of string
+        #
+        # @param [String] text
+        #
+        # @return [String]
+        #
+        # @api private
+        def pad_around(text)
+          text.insert(0, padding_left).insert(-1, padding_right)
+        end
+
+      end # Padding
+    end # Operation
+  end # Table
+end # TTY

data/lib/tty/table/operation/wrapped.rb

@@ -9,11 +9,14 @@ module TTY
 
         attr_reader :widths
 
+        attr_reader :padding
+
         # Initialize a Wrapped
         #
         # @api public
-        def initialize(widths)
-          @widths = widths
+        def initialize(widths, padding)
+          @widths  = widths
+          @padding = padding.padding
         end
 
         # Apply wrapping to a field
@@ -46,7 +49,7 @@ module TTY
         #
         # @api public
         def wrap(string, width)
-          TTY::Text.wrap(string, width)
+          TTY::Text.wrap(string, width, padding: padding)
         end
 
       end # Wrapped

data/lib/tty/table/operations.rb

@@ -20,8 +20,9 @@ module TTY
       # @return [Object]
       #
       # @api public
-      def initialize(table)
+      def initialize(table, renderer=nil)
         @table = table
+        @renderer = renderer # will be available to each operation
       end
 
       # Available operations
@@ -43,7 +44,7 @@ module TTY
       # @return [Hash]
       #
       # @api public
-      def add_operation(type, object)
+      def add(type, object)
         operations[type] << object
       end
 

data/lib/tty/table/orientation/horizontal.rb

@@ -6,14 +6,40 @@ module TTY
     # A class representing table orientation
     class Orientation
 
+      # A class responsible for horizontal table transformation
       class Horizontal < Orientation
 
         def transform(table)
           table.rotate_horizontal
         end
 
-      end # Horizontal
+        # Slice vertical table data into horizontal
+        #
+        # @param [TTY::Table] table
+        #
+        # @api public
+        def slice(table)
+          head, body, array_h, array_b = 4.times.map { [] }
+          index         = 0
+          first_column  = 0
+          second_column = 1
+
+          (0...table.original_columns * table.original_rows).each do |col_index|
+            row      = table.rows[index]
+            array_h += [row[first_column]]
+            array_b += [row[second_column]]
 
+            if col_index % table.original_columns == 2
+              head << array_h
+              body << array_b
+              array_h, array_b = [], []
+            end
+            index += 1
+          end
+          [head, body]
+        end
+
+      end # Horizontal
     end # Orientation
   end # Table
 end # TTY

data/lib/tty/table/orientation/vertical.rb

@@ -6,14 +6,30 @@ module TTY
     # A class representing table orientation
     class Orientation
 
+      # A class responsible for vertical table transformation
       class Vertical < Orientation
 
         def transform(table)
           table.rotate_vertical
         end
 
-      end # Vertical
+        # Slice horizontal table data into vertical
+        #
+        # @param [TTY::Table] table
+        #
+        # @api public
+        def slice(table)
+          header   = table.header
+          row_size = table.row_size
+
+          head = header ? header : (0..row_size).map { |n| (n + 1).to_s }
 
+          (0...row_size).inject([]) do |array, index|
+            array + head.zip(table.rows[index]).map { |row| table.to_row(row) }
+          end
+        end
+
+      end # Vertical
     end # Orientation
   end # Table
 end # TTY