tty-table 0.1.0

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

@@ -0,0 +1,294 @@
+# encoding: utf-8
+
+require 'tty/table/validatable'
+
+module TTY
+  class Table
+    class Renderer
+      # Renders table without any border styles.
+      #
+      # @api private
+      class Basic
+        include TTY::Table::Validatable
+
+        # Table to be rendered
+        #
+        # @return [TTY::Table]
+        #
+        # @api public
+        attr_reader :table
+        # private :table
+
+        # Table border to be rendered
+        #
+        # @return [TTY::Table::Border]
+        #
+        # @api private
+        attr_accessor :border_class
+
+        # The table enforced column widths
+        #
+        # @return [Array]
+        #
+        # @api public
+        attr_writer :column_widths
+
+        # The table column alignments
+        #
+        # @return [Array]
+        #
+        # @api private
+        attr_accessor :column_aligns
+
+        # 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
+
+        # 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
+        # @option options [String] :column_aligns
+        #   used to format table individual column alignment
+        # @option options [String] :column_widths
+        #   used to format table individula column width
+        # @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 = {})
+          @table         = assert_table_type(table)
+          @multiline     = options.fetch(:multiline) { false }
+          @operations    = TTY::Table::Operations.new(table)
+          @operations.add(:escape, Operation::Escape.new)
+          @border        = TTY::Table::BorderOptions.from(options.delete(:border))
+          @column_widths = options.fetch(:column_widths, nil)
+          @column_aligns = Array(options.delete(:column_aligns)).map(&:to_sym)
+          @filter        = options.fetch(:filter) { proc { |val, _| val } }
+          @width         = options.fetch(:width) { TTY::Screen.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[:padding])
+        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
+        #
+        # @param [Hash, Table::BorderOptions] options
+        #
+        # @yield [Table::BorderOptions]
+        #   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 add_operations
+          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,
+        #
+        # @param [Integer] value
+        #   the amount of padding, not allowed to be zero
+        #
+        # @api public
+        def padding=(value)
+          @padding = TTY::Table::Padder.parse(value)
+        end
+
+        # Renders table
+        #
+        # @return [String] string representation of table
+        #
+        # @api public
+        def render
+          return if table.empty?
+
+          operations.run_operations(:escape) unless multiline
+          columns_constraints.enforce
+          add_operations
+          ops = [:alignment]
+          ops << :padding unless padding.empty?
+          multiline ? ops << :wrapping : ops << :truncation
+          ops << :filter
+          operations.run_operations(*ops)
+
+          render_data.compact.join("\n")
+        end
+
+        private
+
+        # 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)
+          bottom_line      = data_border.bottom_line
+
+          insert_indent(bottom_line) if bottom_line
+
+          [header, rows_with_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 [String]
+        #
+        # @api private
+        def render_header(row, data_border)
+          top_line = data_border.top_line
+          if row.is_a?(TTY::Table::Header)
+            header = [top_line, data_border.row_line(row), data_border.separator]
+            insert_indent(header.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(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
+        end
+
+        # Format a single row with border
+        #
+        # @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, data_border, is_last_row)
+          separator = data_border.separator
+          row_line  = data_border.row_line(row)
+
+          if (border.separator == TTY::Table::Border::EACH_ROW) && is_last_row
+            insert_indent([row_line, separator])
+          else
+            insert_indent(row_line)
+          end
+        end
+      end # Basic
+    end # Renderer
+  end # Table
+end # TTY

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

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    class Renderer
+      class Color < Basic
+
+
+      end # Color
+    end # Renderer
+  end # Table
+end # TTY

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    class Renderer
+      # Unicode representation of table renderer
+      #
+      # @api private
+      class Unicode < Basic
+        # Create Unicode renderer
+        #
+        # @param [Table] table
+        #
+        # @api private
+        def initialize(table, options = {})
+          super(table, options.merge(border_class: TTY::Table::Border::Unicode))
+        end
+      end # Unicode
+    end # Renderer
+  end # Table
+end # TTY

data/lib/tty/table/renderer.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class responsible for rendering tabular data
+    #
+    # Used internally by {Table} to render table content out.
+    #
+    # @api private
+    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_MAPPER = {
+        ascii:   TTY::Table::Renderer::ASCII,
+        basic:   TTY::Table::Renderer::Basic,
+        color:   TTY::Table::Renderer::Color,
+        unicode: TTY::Table::Renderer::Unicode
+      }
+
+      # Select renderer class based on string name.
+      #
+      # The possible values for renderer are
+      # [:basic, :ascii, :unicode, :color]
+      #
+      # @param [Symbol] renderer
+      #   the renderer used for displaying table
+      #
+      # @return [TTY::Table::Renderer]
+      #
+      # @api private
+      def self.select(type)
+        RENDERER_MAPPER[type || :basic]
+      end
+
+      # Raises an error if provided border class is of wrong type or has invalid
+      # implementation
+      #
+      # @raise [TypeError]
+      #   raised when providing wrong class for border
+      #
+      # @raise [NoImplementationError]
+      #   raised when border class does not implement core methods
+      #
+      # @api public
+      def self.assert_border_class(border_class)
+        return unless border_class
+        unless border_class <= TTY::Table::Border
+          fail TypeError,
+               "#{border_class} should inherit from TTY::Table::Border"
+        end
+        unless border_class.characters
+          fail NoImplementationError,
+               "#{border_class} should implement def_border"
+        end
+      end
+
+      # Add custom border for the renderer
+      #
+      # @param [TTY::Table::Border] border_class
+      #
+      # @param [TTY::Table] table
+      #
+      # @param [Hash] options
+      #
+      # @raise [TypeError]
+      #   raised if the klass does not inherit from Table::Border
+      #
+      # @raise [NoImplemntationError]
+      #   raise if the klass does not implement def_border
+      #
+      # @api public
+      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
+
+      # 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
+end # TTY

data/lib/tty/table/row.rb

@@ -0,0 +1,248 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # Convert an Array row into Row
+    #
+    # @return [TTY::Table::Row]
+    #
+    # @api private
+    def to_row(row, header = nil)
+      Row.new(row, header)
+    end
+
+    # A class that represents a row in a table.
+    #
+    # Used internally by {Table} to store row represenation by converting
+    # {Array} into {Row} instance.
+    #
+    # @api private
+    class Row
+      include Enumerable, Equatable
+      extend Forwardable
+
+      # The row attributes that describe each element
+      #
+      # @return [Array]
+      #
+      # @api private
+      attr_reader :attributes
+
+      # The row data
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :data
+
+      # The row fields
+      #
+      # @api public
+      attr_reader :fields
+
+      def_delegators :to_ary, :join
+
+      # Initialize a Row
+      #
+      # @example
+      #   row = new TTY::Table::Row.new [1,2,3]
+      #   row[1]  # => 2
+      #
+      #   row = new TTY::Table::Row.new [1,2,3], %w[a b c]
+      #   row[0]   # => 1
+      #   row['a'] # => 1
+      #
+      #   row = new TTY::Table::Row.new {"a": 1, "b": 2, "c": 3}
+      #   row[0]   # => 1
+      #   row['a'] # => 1
+      #
+      # @param [#to_ary] data
+      #   the row data
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(data, header = nil)
+        case data
+        when Array
+          @attributes = (header || (0...data.length)).to_a
+          @fields     = coerce_to_fields(data)
+        when Hash
+          @data       = data.dup
+          @fields     = coerce_to_fields(@data.values)
+          @attributes = (header || data.keys).to_a
+        end
+        @data = Hash[@attributes.zip(fields)]
+      end
+
+      # Coerces values to field instances
+      #
+      # @param [Array[Object]] values
+      #
+      # @return [Array[TTY::Table::Field]]
+      #
+      # @api public
+      def coerce_to_fields(values)
+        values.reduce([]) { |acc, el| acc << to_field(el) }
+      end
+
+      # Instantiates a new field
+      #
+      # @api public
+      def to_field(options = nil)
+        Field.new(options)
+      end
+
+      # Lookup a value in the row given an attribute allowing for Array or
+      # Hash like indexing
+      #
+      # @exmaple
+      #   row[1]
+      #   row[:id]
+      #   row.call(:id)
+      #
+      # @api public
+      def [](attribute)
+        case attribute
+        when Integer
+          data[attributes[attribute]].value
+        else
+          data.fetch(attribute) do |name|
+            fail UnknownAttributeError, "the attribute #{name} is unkown"
+          end.value
+        end
+      end
+
+      # Lookup attribute without evaluation
+      #
+      # @api public
+      def call(attribute)
+        data[attributes[attribute]]
+      end
+
+      # Set value at index
+      #
+      # @example
+      #   row[attribute] = value
+      #
+      # @api public
+      def []=(attribute, value)
+        case attribute
+        when Integer
+          data[attributes[attribute]] = to_field(value)
+        else
+          data[attribute] = to_field(value)
+          attributes << attribute unless attributes.include?(attribute)
+        end
+      end
+
+      # Iterate over each element in the Row
+      #
+      # @example
+      #   vec = Row.new [1,2,3], ['a','b','c']
+      #   vec.each { |element| ... }
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        to_ary.each { |element| yield element }
+        self
+      end
+
+      # Number of data items in a row
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def size
+        data.size
+      end
+      alias :length :size
+
+      # Check if there are no elements
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        to_ary.empty?
+      end
+
+      # Find maximum row height
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def height
+        fields.map(&:height).max
+      end
+
+      # Convert the Row into Array
+      #
+      # @example
+      #   array = row.to_ary
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ary
+        to_hash.values_at(*attributes)
+      end
+
+      # Return the Row elements in an array.
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_a
+        to_ary.dup
+      end
+
+      # Convert the Row into hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_hash
+        hash = data.dup
+        hash.update(hash) { |_, val| val.value if val }
+      end
+
+      # Check if this row is equivalent to another row
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        to_a == other.to_a
+      end
+      alias :eql? :==
+
+      # Provide a unique hash value. If a row contains the same data as another
+      # row, they will hash to the same value.
+      #
+      # @api public
+      def hash
+        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
+end # TTY

data/lib/tty/table/transformation.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class for transforming table values
+    #
+    # Used internally by {Table}
+    #
+    # @api private
+    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.reduce([]) { |arr, el| arr + el.values }
+        [header, rows]
+      end
+    end # Transformation
+  end # Table
+end # TTY