tty 0.0.10 → 0.0.11

data/lib/tty/table/padder.rb

@@ -0,0 +1,142 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+
+    # A class responsible for processing table field padding
+    class Padder
+      include TTY::Equatable
+
+      attr_reader :padding
+
+      # Initialize a Padder
+      #
+      # @api public
+      def initialize(padding)
+        @padding = padding
+      end
+
+      # Parse padding options
+      #
+      # @param [Object] value
+      #
+      # @return [TTY::Padder]
+      #
+      # @api public
+      def self.parse(value = nil)
+        return value if value.kind_of?(self)
+
+        padding = if value.class <= Numeric
+          [value, value, value, value]
+        elsif value.nil?
+          []
+        elsif value.size == 2
+          [value[0], value[1], value[0], value[1]]
+        elsif value.size == 4
+          value
+        else
+          raise ArgumentError, 'Wrong :padding parameter, must be an array'
+        end
+        new(padding)
+      end
+
+      # Top padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def top
+        @padding[0].to_i
+      end
+
+      # Set top padding
+      #
+      # @param [Integer] val
+      #
+      # @api public
+      def top=(value)
+        @padding[0] = value
+      end
+
+      # Right padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def right
+        @padding[1].to_i
+      end
+
+      # Set right padding
+      #
+      # @param [Integer] val
+      #
+      # @api public
+      def right=(value)
+        @padding[1] = value
+      end
+
+      # Bottom padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def bottom
+        @padding[2].to_i
+      end
+
+      # Set bottom padding
+      #
+      # @param [Integer] value
+      #
+      # @api public
+      def bottom=(value)
+        @padding[2] = value
+      end
+
+      # Left padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def left
+        @padding[3].to_i
+      end
+
+      # Set left padding
+      #
+      # @param [Integer] value
+      #
+      # @api public
+      def left=(value)
+        @padding[3] = value
+      end
+
+      # Check if padding is set
+      #
+      # @api public
+      def empty?
+        padding.empty?
+      end
+
+      # Check if vertical padding is applied
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def vertical?
+        top.nonzero? or bottom.nonzero?
+      end
+
+      # Check if horizontal padding is applied
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def horizontal?
+        left.nonzero? or right.nonzero?
+      end
+
+    end # Padder
+  end # Table
+end # TTY

data/lib/tty/table/renderer/basic.rb

@@ -16,7 +16,7 @@ module TTY
         #
         # @api public
         attr_reader :table
-        private :table
+        # private :table
 
         # Table border to be rendered
         #
@@ -57,6 +57,36 @@ module TTY
         # @api public
         attr_accessor :multiline
 
+        # The table indentation value
+        #
+        # @return [Integer]
+        #
+        # @api public
+        attr_accessor :indent
+
+        # The table totabl width
+        #
+        # @return [Integer]
+        #
+        # @api public
+        attr_accessor :width
+
+        # The table resizing behaviour. If true the algorithm will automatically
+        # expand or shrink table to fit the terminal width or specified width.
+        # By default its false.
+        #
+        # @return [Integer]
+        #
+        # @api public
+        attr_accessor :resize
+
+        # The table padding settings
+        #
+        # @return [TTY::Table::Padder]
+        #
+        # @api public
+        attr_reader :padding
+
         # Initialize a Renderer
         #
         # @param [Hash] options
@@ -64,31 +94,39 @@ module TTY
         #   used to format table individual column alignment
         # @option options [String] :column_widths
         #   used to format table individula column width
-        #
-        #   :indent - Indent the first column by indent value
-        #   :padding - Pad out the row cell by padding value
+        # @option options [Integer] :indent
+        #   indent the first column by indent value
+        # @option options [Integer,Array] :padding
+        #   add padding to table fields
         #
         # @return [TTY::Table::Renderer::Basic]
         #
         # @api private
-        def initialize(table, options={})
-          validate_rendering_options!(options)
+        def initialize(table, options = {})
           @table         = table || (raise ArgumentRequired, "Expected TTY::Table instance, got #{table.inspect}")
           @multiline     = options.fetch(:multiline) { false }
           @operations    = TTY::Table::Operations.new(table)
-          unless multiline
-            @operations.add_operation(:escape, Operation::Escape.new)
-            @operations.run_operations(:escape)
+          if not multiline
+            @operations.add(:escape, Operation::Escape.new)
           end
-
           @border        = TTY::Table::BorderOptions.from(options.delete(:border))
-          @column_widths = Array(options.fetch(:column_widths) {
-            ColumnSet.new(table).extract_widths
-          }).map(&:to_i)
+          @column_widths = options.fetch(:column_widths, nil)
           @column_aligns = Array(options.delete(:column_aligns)).map(&:to_sym)
           @filter        = options.fetch(:filter) { proc { |val, row, col| val } }
           @width         = options.fetch(:width) { TTY.terminal.width }
           @border_class  = options.fetch(:border_class) { Border::Null }
+          @indent        = options.fetch(:indent) { 0 }
+          @resize        = options.fetch(:resize) { false }
+          @padding       = TTY::Table::Padder.parse(options.fetch(:padding) { nil })
+        end
+
+        # Parses supplied column widths, if not present calculates natural widths
+        #
+        # @return [Array[Integer]]
+        #
+        # @api public
+        def column_widths
+          @column_widths = ColumnSet.widths_from(table, @column_widths)
         end
 
         # Store border characters, style and separator for the table rendering
@@ -113,10 +151,35 @@ module TTY
         #
         # @api private
         def add_operations
-          operations.add_operation(:alignment, Operation::AlignmentSet.new(column_aligns, column_widths))
-          operations.add_operation(:filter, Operation::Filter.new(filter))
-          operations.add_operation(:truncation, Operation::Truncation.new(column_widths))
-          operations.add_operation(:wrapping, Operation::Wrapped.new(column_widths))
+          operations.add(:alignment,  Operation::AlignmentSet.new(column_aligns,
+                                                                  column_widths))
+          operations.add(:filter,     Operation::Filter.new(filter))
+          operations.add(:truncation, Operation::Truncation.new(column_widths))
+          operations.add(:wrapping,   Operation::Wrapped.new(column_widths, padding))
+          operations.add(:padding,    Operation::Padding.new(padding, multiline))
+        end
+
+        # Initializes indentation
+        #
+        # @return [TTY::Table::Indentation]
+        #
+        # @api private
+        def indentation
+          @indentation ||= TTY::Table::Indentation.new(self)
+        end
+
+        # Delegate indentation insertion
+        #
+        # @api public
+        def insert_indent(line)
+          indentation.insert_indent(line)
+        end
+
+        # Return column contraints
+        #
+        # @api private
+        def columns_constraints
+          TTY::Table::Columns.new(self)
         end
 
         # Sets the output padding,
@@ -126,7 +189,7 @@ module TTY
         #
         # @api public
         def padding=(value)
-          @padding = [0, value].max
+          @padding = TTY::Table::Padder.parse(value)
         end
 
         # Renders table
@@ -137,13 +200,15 @@ module TTY
         def render
           return if table.empty?
 
-          # TODO: throw an error if too many columns as compared to terminal width
-          # and then change table.orientation from vertical to horizontal
-          # TODO: Decide about table orientation
+          operations.run_operations(:escape) unless multiline
+          columns_constraints.enforce
           add_operations
-          ops = [:filter, :alignment]
+          ops = [:alignment]
+          ops << :padding unless padding.empty?
           multiline ? ops << :wrapping : ops << :truncation
+          ops << :filter
           operations.run_operations(*ops)
+
           render_data.compact.join("\n")
         end
 
@@ -153,12 +218,16 @@ module TTY
         #
         # @api private
         def render_data
-          first_row   = table.first
-          data_border = border_class.new(column_widths, border)
-          header      = render_header(first_row, data_border)
+          first_row        = table.first
+          data_border      = border_class.new(column_widths, border)
+          header           = render_header(first_row, data_border)
           rows_with_border = render_rows(data_border)
 
-          [header, rows_with_border, data_border.bottom_line].compact
+          if bottom_line = data_border.bottom_line
+            insert_indent(bottom_line)
+          end
+
+          [header, rows_with_border, bottom_line].compact
         end
 
         # Format the header if present
@@ -175,7 +244,8 @@ module TTY
         def render_header(row, data_border)
           top_line = data_border.top_line
           if row.is_a?(TTY::Table::Header)
-            [top_line, data_border.row_line(row), data_border.separator].compact
+            header = [top_line, data_border.row_line(row), data_border.separator]
+            insert_indent(header.compact)
           else
             top_line
           end
@@ -190,8 +260,8 @@ module TTY
         #
         # @api private
         def render_rows(data_border)
-          rows   = table.rows
-          size   = rows.size
+          rows = table.rows
+          size = rows.size
           rows.each_with_index.map do |row, index|
             render_row(row, data_border, size != (index += 1))
           end
@@ -213,9 +283,9 @@ module TTY
           row_line  = data_border.row_line(row)
 
           if (border.separator == TTY::Table::Border::EACH_ROW) && is_last_row
-            [row_line, separator]
+            insert_indent([row_line, separator])
           else
-            row_line
+            insert_indent(row_line)
           end
         end
 

data/lib/tty/table/validatable.rb

@@ -29,13 +29,6 @@ module TTY
       def assert_string_values(rows)
       end
 
-      def validate_rendering_options!(options)
-        if (column_widths = options[:column_widths]) &&
-           (!column_widths.kind_of?(Array) || column_widths.empty?)
-          raise InvalidArgument, ":column_widths must be a non-empty array"
-        end
-      end
-
       # Check if options are of required type
       #
       # @api private

data/lib/tty/terminal/color.rb

@@ -16,28 +16,44 @@ module TTY
       STYLES = %w[ BOLD CLEAR UNDERLINE ].freeze
 
       # Escape codes for text color.
-      BLACK      = "\e[30m"
-      RED        = "\e[31m"
-      GREEN      = "\e[32m"
-      YELLOW     = "\e[33m"
-      BLUE       = "\e[34m"
-      MAGENTA    = "\e[35m"
-      CYAN       = "\e[36m"
-      WHITE      = "\e[37m"
-
-      TEXT_COLORS = %w[ BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE ].freeze
+      BLACK         = "\e[30m"
+      RED           = "\e[31m"
+      GREEN         = "\e[32m"
+      YELLOW        = "\e[33m"
+      BLUE          = "\e[34m"
+      MAGENTA       = "\e[35m"
+      CYAN          = "\e[36m"
+      WHITE         = "\e[37m"
+
+      LIGHT_BLACK   = "\e[90m"
+      LIGHT_RED     = "\e[91m"
+      LIGHT_GREEN   = "\e[92m"
+      LIGHT_YELLOW  = "\e[93m"
+      LIGHT_BLUE    = "\e[94m"
+      LIGHT_MAGENTA = "\e[95m"
+      LIGHT_CYAN    = "\e[96m"
+
+      TEXT_COLORS = (constants.grep(/^[^ON_]*/) - STYLES).freeze
 
       # Escape codes for background color.
-      ON_BLACK   = "\e[40m"
-      ON_RED     = "\e[41m"
-      ON_GREEN   = "\e[42m"
-      ON_YELLOW  = "\e[43m"
-      ON_BLUE    = "\e[44m"
-      ON_MAGENTA = "\e[45m"
-      ON_CYAN    = "\e[46m"
-      ON_WHITE   = "\e[47m"
-
-      BACKGROUND_COLORS = %w[ ON_BLACK ON_RED ON_GREEN ON_YELLOW ON_BLUE ON_MAGENTA ON_CYAN  ON_WHITE ].freeze
+      ON_BLACK         = "\e[40m"
+      ON_RED           = "\e[41m"
+      ON_GREEN         = "\e[42m"
+      ON_YELLOW        = "\e[43m"
+      ON_BLUE          = "\e[44m"
+      ON_MAGENTA       = "\e[45m"
+      ON_CYAN          = "\e[46m"
+      ON_WHITE         = "\e[47m"
+
+      ON_LIGHT_BLACK   = "\e[100m"
+      ON_LIGHT_RED     = "\e[101m"
+      ON_LIGHT_GREEN   = "\e[102m"
+      ON_LIGHT_YELLOW  = "\e[103m"
+      ON_LIGHT_BLUE    = "\e[104m"
+      ON_LIGHT_MAGENTA = "\e[105m"
+      ON_LIGHT_CYAN    = "\e[106m"
+
+      BACKGROUND_COLORS = constants.grep(/^ON_*/).freeze
 
       attr_reader :enabled
 

data/lib/tty/text/truncation.rb

@@ -19,6 +19,8 @@ module TTY
 
       attr_reader :trailing
 
+      attr_reader :escape
+
       # Initialize a Truncation
       #
       # @param [String] text
@@ -36,6 +38,7 @@ module TTY
       #   @option options [Symbol] :length    the desired length
       #   @option options [Symbol] :separator the character for splitting words
       #   @option options [Symbol] :trailing  the character for ending sentence
+      #   @option options [Symbol] :escape    remove ANSI escape sequences
       #
       # @api private
       def initialize(text, *args)
@@ -45,6 +48,7 @@ module TTY
         @length    = args[0] unless args.empty?
         @separator = options.fetch(:separator) { nil }
         @trailing  = options.fetch(:trailing) { DEFAULT_TRAILING }
+        @escape    = options.fetch(:escape) { true }
       end
 
       # Truncate a text
@@ -56,7 +60,7 @@ module TTY
         return text unless length && length > 0
 
         as_unicode do
-          chars = text.chars.to_a
+          chars = (escape ? escape_text : text).chars.to_a
           return chars.join if chars.length <= length
           stop = chars[0, length_without_trailing].rindex(separator)
 
@@ -66,6 +70,17 @@ module TTY
 
       private
 
+      # Strip ANSI characters from the text
+      #
+      # @param [String] text
+      #
+      # @return [String]
+      #
+      # @api private
+      def escape_text
+        TTY.terminal.color.remove text.dup
+      end
+
       # Leave space for the trailing characters
       #
       # @return [Integer]