tty 0.0.9 → 0.0.10

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

@@ -1,12 +1,14 @@
 # -*- encoding: utf-8 -*-
 
+require 'tty/table/validatable'
+
 module TTY
   class Table
-    module Renderer
+    class Renderer
 
       # Renders table without any border styles.
       class Basic
-        extend TTY::Delegatable
+        include TTY::Table::Validatable
 
         # Table to be rendered
         #
@@ -14,40 +16,108 @@ module TTY
         #
         # @api public
         attr_reader :table
+        private :table
 
         # Table border to be rendered
         #
         # @return [TTY::Table::Border]
         #
         # @api private
-        attr_reader :border_class
+        attr_accessor :border_class
 
-        TABLE_DELEGATED_METHODS = [:column_widths, :column_aligns]
+        # The table enforced column widths
+        #
+        # @return [Array]
+        #
+        # @api public
+        attr_accessor :column_widths
 
-        delegatable_method :table, *TABLE_DELEGATED_METHODS
+        # The table column alignments
+        #
+        # @return [Array]
+        #
+        # @api private
+        attr_accessor :column_aligns
 
-        # Initialize and setup a Renderer
+        # The table operations applied to rows
+        #
+        # @api public
+        attr_reader :operations
+
+        # A callable object used for formatting field content
+        #
+        # @api public
+        attr_accessor :filter
+
+        # The table column span behaviour. When true the column's line breaks
+        # cause the column to span multiple rows. By default set to false.
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        attr_accessor :multiline
+
+        # Initialize a Renderer
         #
         # @param [Hash] options
+        # @option options [String] :column_aligns
+        #   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
         #
-        # @return [Table::Renderer::Basic]
-        def initialize(options={})
-          setup(options)
+        # @return [TTY::Table::Renderer::Basic]
+        #
+        # @api private
+        def initialize(table, options={})
+          validate_rendering_options!(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)
+          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_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 }
         end
 
-        # Setup attributes when Renderer is invoked
+        # Store border characters, style and separator for the table rendering
+        #
+        # @param [Hash, BorderOptions] options
         #
-        # @return [self]
+        # @yield [] block representing border options
+        #
+        # @api public
+        def border(options=(not_set=true), &block)
+          @border = TTY::Table::BorderOptions.new unless @border
+          if block_given?
+            border_dsl = TTY::Table::BorderDSL.new(&block)
+            @border = border_dsl.options
+          elsif !not_set
+            @border = TTY::Table::BorderOptions.from(options)
+          end
+          @border
+        end
+
+        # Initialize and add operations
         #
         # @api private
-        def setup(options = {})
-          @padding    = 0
-          @indent     = options.fetch :indent, 0
-          self
+        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))
         end
-        private :setup
 
         # Sets the output padding,
         #
@@ -59,74 +129,72 @@ module TTY
           @padding = [0, value].max
         end
 
-        # @api public
-        def self.render(table, options={})
-          new(options).render(table)
-        end
-
         # Renders table
         #
-        # @param [TTY::Table] table
-        #   the table to be rendered
-        #
         # @return [String] string representation of table
         #
         # @api public
-        def render(table, border_class=Border::Null)
-          @table = table
-          @border_class = table.border_class || border_class
+        def render
           return if table.empty?
 
-          body = []
-          unless table.length.zero?
-            ColumnSet.new(table).extract_widths!
-            # 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
-            body += render_header
-            body += render_rows
-          end
-          body.compact.join("\n")
+          # 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
+          add_operations
+          ops = [:filter, :alignment]
+          multiline ? ops << :wrapping : ops << :truncation
+          operations.run_operations(*ops)
+          render_data.compact.join("\n")
         end
 
         private
 
-        # Format the header
+        # Render table data
+        #
+        # @api private
+        def render_data
+          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
+        end
+
+        # Format the header if present
+        #
+        # @param [TTY::Table::Row, TTY::Table::Header] row
+        #   the first row in the table
+        #
+        # @param [TTY::Table::Border] data_boder
+        #   the border for this table
         #
-        # @return [Array[String]]
+        # @return [String]
         #
         # @api private
-        def render_header
-          header = table.header
-          if header && !header.empty?
-            operations = table.operations
-            operations.run_operations(:alignment, header)
-            border = border_class.new(header, table.border)
-            [ border.top_line, border.row_line ].compact
+        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
           else
-            []
+            top_line
           end
         end
 
         # Format the rows
         #
+        # @param [TTY::Table::Border] data_boder
+        #   the border for this table
+        #
         # @return [Arrays[String]]
         #
         # @api private
-        def render_rows
-          operations = table.operations
-          table.each do |row|
-            operations.run_operations(:alignment, row)
+        def render_rows(data_border)
+          rows   = table.rows
+          size   = rows.size
+          rows.each_with_index.map do |row, index|
+            render_row(row, data_border, size != (index += 1))
           end
-          aligned = table.to_a
-          first_row_border = border_class.new(aligned.first, table.border)
-          aligned_border = aligned.each_with_index.map { |row, index|
-            render_row(row, aligned.size != (index += 1))
-          }
-
-          [ table.header ? first_row_border.separator : first_row_border.top_line,
-            aligned_border,
-            first_row_border.bottom_line ].compact
         end
 
         # Format a single row with border
@@ -134,15 +202,17 @@ module TTY
         # @param [Array] row
         #   a row to decorate
         #
+        # @param [TTY::Table::Border] data_boder
+        #   the border for this table
+        #
         # @param [Boolean] is_last_row
         #
         # @api private
-        def render_row(row, is_last_row)
-          border    = border_class.new(row, table.border)
-          separator = border.separator
-          row_line  = border.row_line
+        def render_row(row, data_border, is_last_row)
+          separator = data_border.separator
+          row_line  = data_border.row_line(row)
 
-          if (table.border.separator == TTY::Table::Border::EACH_ROW) && is_last_row
+          if (border.separator == TTY::Table::Border::EACH_ROW) && is_last_row
             [row_line, separator]
           else
             row_line

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

@@ -2,12 +2,9 @@
 
 module TTY
   class Table
-    module Renderer
+    class Renderer
       class Color < Basic
 
-        def initialize
-
-        end
 
       end # Color
     end # Renderer

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

@@ -2,11 +2,11 @@
 
 module TTY
   class Table
-    module Renderer
+    class Renderer
       class Unicode < Basic
 
-        def render(table)
-          super table, TTY::Table::Border::Unicode
+        def initialize(table, options={})
+          super(table, options.merge(:border_class => TTY::Table::Border::Unicode))
         end
 
       end # Unicode

data/lib/tty/table/renderer.rb

@@ -3,39 +3,13 @@
 module TTY
   class Table
 
-    # Determine renderer based on terminal capabilities
-    #
-    # @return [TTY::Table::Renderer]
-    #
-    # @api public
-    def self.renderer
-      @renderer ||= if TTY.terminal.color?
-        TTY::Table::Renderer::Color
-      else
-        TTY::Table::Renderer::Basic
-      end
-    end
-
-    # @api public
-    def self.renderer=(klass)
-      @renderer = klass
-    end
-
-    # A mixin to allow common rendering methods
-    #
-    # @return [self]
-    #
-    # @api public
-    module Renderer
-      extend TTY::Delegatable
-
+    # A class responsible for rendering tabular data
+    class Renderer
       autoload :ASCII,   'tty/table/renderer/ascii'
       autoload :Basic,   'tty/table/renderer/basic'
       autoload :Color,   'tty/table/renderer/color'
       autoload :Unicode, 'tty/table/renderer/unicode'
 
-      RENDERER_DELEGATED_METHODS = [ :render, :total_width]
-
       RENDERER_MAPPER = {
         :ascii   => TTY::Table::Renderer::ASCII,
         :basic   => TTY::Table::Renderer::Basic,
@@ -43,44 +17,45 @@ module TTY
         :unicode => TTY::Table::Renderer::Unicode
       }
 
-      # Initialize a Renderer
-      #
-      # @api private
-      def initialize(options={})
-        super()
-      end
-
-      # Determine renderer class based on string name
+      # Select renderer class based on string name
       #
       # @param [Symbol] renderer
-      #   the renderer used for displaying table out of [:basic, :color, :unicode]
+      #   the renderer used for displaying table out of [:basic, :ascii, :unicode, :color]
       #
       # @return [TTY::Table::Renderer]
       #
       # @api private
-      def pick_renderer(type=nil)
-        self.renderer= (type ? RENDERER_MAPPER[type].new : self.renderer)
+      def self.select(type)
+         RENDERER_MAPPER[type || :basic]
       end
 
-      # Return the default renderer
+      # Raises an error if provided border class is of wrong type or has invalid
+      # implementation
       #
-      # @return [TTY::Table::Renderer]
+      # @raise [TypeError]
+      #   raised when providing wrong class for border
+      #
+      # @raise [NoImplementationError]
+      #   raised when border class does not implement core methods
       #
       # @api public
-      def renderer
-        @renderer ||= TTY::Table.renderer.new
+      def self.assert_border_class(border_class)
+        return unless border_class
+        unless border_class <= TTY::Table::Border
+          raise TypeError, "#{border_class} should inherit from TTY::Table::Border"
+        end
+        unless border_class.characters
+          raise NoImplementationError, "#{border_class} should implement def_border"
+        end
       end
 
-      # Set the renderer
+      # Add custom border for the renderer
       #
-      # @return [TTY::Table::Renderer]
+      # @param [TTY::Table::Border] border_class
       #
-      # @api private
-      def renderer=(renderer)
-        @renderer = renderer
-      end
-
-      # Add custom border for the renderer
+      # @param [TTY::Table] table
+      #
+      # @param [Hash] options
       #
       # @raise [TypeError]
       #   raised if the klass does not inherit from Table::Border
@@ -89,18 +64,30 @@ module TTY
       #   raise if the klass does not implement def_border
       #
       # @api public
-      def renders_with(klass)
-        unless klass <= TTY::Table::Border
-          raise TypeError, "#{klass} should inherit from TTY::Table::Border"
-        end
-        unless klass.characters
-          raise NoImplementationError, "#{klass} should implement def_border"
-        end
-        @border_class = klass
+      def self.render_with(border_class, table, options={}, &block)
+        assert_border_class(border_class)
+        options[:border_class] = border_class if border_class
+        render(table, options, &block)
       end
 
-      delegatable_method :renderer, *RENDERER_DELEGATED_METHODS
-
+      # Render a given table and return the string representation.
+      #
+      # @param [TTY::Table] table
+      #   the table to be rendered
+      #
+      # @param [Hash] options
+      #   the options to render the table with
+      # @option options [String] :renderer
+      #   used to format table output
+      #
+      # @return [String]
+      #
+      # @api public
+      def self.render(table, options={}, &block)
+        renderer = select(options[:renderer]).new(table, options)
+        yield renderer if block_given?
+        renderer.render
+      end
     end # Renderer
 
   end # Table

data/lib/tty/table/row.rb

@@ -35,6 +35,8 @@ module TTY
       # @api private
       attr_reader :data
 
+      attr_reader :fields
+
       # Initialize a Row
       #
       # @example
@@ -59,11 +61,11 @@ module TTY
         case data
         when Array
           @attributes = (header || (0...data.length)).to_a
-          fields = data.inject([]) { |arr, datum| arr << to_field(datum) }
+          @fields = data.inject([]) { |arr, datum| arr << to_field(datum) }
           @data = Hash[@attributes.zip(fields)]
         when Hash
           @data = data.dup
-          fields = @data.values.inject([]){|arr, datum| arr << to_field(datum) }
+          @fields = @data.values.inject([]){|arr, datum| arr << to_field(datum) }
           @attributes = (header || data.keys).to_a
           @data = Hash[@attributes.zip(fields)]
         end
@@ -95,7 +97,13 @@ module TTY
           end.value
         end
       end
-      alias :call :[]
+
+      # Lookup attribute without evaluation
+      #
+      # @api public
+      def call(attribute)
+        data[attributes[attribute]]
+      end
 
       # Set value at index
       #
@@ -123,6 +131,15 @@ module TTY
       end
       alias :length :size
 
+      # Find maximum row height
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def height
+        fields.map { |field| field.height }.max
+      end
+
       # Convert the Row into Array
       #
       # @example
@@ -163,11 +180,21 @@ module TTY
         to_a.hash
       end
 
+      # Map field values
+      #
+      # @api public
       def map!(&block)
         data.values_at(*attributes).each do |field|
           field.value = block.call(field)
         end
       end
+
+      # String representation of a row with its fields
+      #
+      # @api public
+      def inspect
+        "#<#{self.class.name} fields=#{to_a}>"
+      end
     end # Row
 
   end # Table

data/lib/tty/table/transformation.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+
+    # A class for transforming table values
+    class Transformation
+
+      # Extract the header and row tuples from the value
+      #
+      # @param [Array] args
+      #
+      # @return [Object]
+      #
+      # @api public
+      def self.extract_tuples(args)
+        rows   = args.pop
+        header = args.size.zero? ? nil : args.first
+        if rows.first.is_a?(Hash)
+          header, rows = group_header_and_rows(rows)
+        end
+        { header: header, rows: rows }
+      end
+
+      # Group hash keys into header and values into rows
+      #
+      # @params [Hash] value
+      #
+      # @api public
+      def self.group_header_and_rows(value)
+        header = value.map(&:keys).flatten.uniq
+        rows   = value.inject([]) { |arr, el| arr + el.values }
+        [header, rows]
+      end
+
+    end # Transformation
+  end # Table
+end # TTY

data/lib/tty/table/validatable.rb

@@ -29,6 +29,13 @@ 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
@@ -42,11 +49,6 @@ module TTY
           !(rows.kind_of?(Array) || rows.kind_of?(Hash))
           raise InvalidArgument, ":rows must be a non-empty array or hash"
         end
-
-        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
 
     end # Validatable