tty-table 0.1.0

data/lib/tty/table/columns.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class responsible for enforcing column constraints.
+    #
+    # Used internally by {Renderer::Basic} to enforce correct column widths.
+    #
+    # @api private
+    class Columns
+
+      attr_reader :table
+
+      attr_reader :renderer
+
+      MIN_WIDTH = 1
+
+      BORDER_WIDTH = 1
+
+      # Initialize a Columns
+      #
+      # @param [TTY::Table::Renderer] 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
+
+        unless 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
+        Kernel.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
+        return unless width <= minimum_width
+        fail ResizeError, "Table's width is too small to contain the content " \
+                          "(min width #{minimum_width}, currently set #{width})"
+      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/empty.rb

@@ -0,0 +1,26 @@
+module TTY
+  class Table
+    class Empty < TTY::Table
+
+      ZERO_ROW = [].freeze
+
+      def self.new(header, rows = ZERO_ROW)
+        super.new(header, rows)
+      end
+
+      def each
+        return to_enum unless block_given?
+        self
+      end
+
+      def size
+        0
+      end
+
+      def width
+        0
+      end
+
+    end # Empty
+  end # Table
+end # TTY

data/lib/tty/table/error.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # Raised when inserting into table with a mismatching row(s)
+    class DimensionMismatchError < ArgumentError; end
+
+    # Raised when reading non-existent element from a table
+    class TupleMissing < IndexError
+      attr_reader :i, :j
+
+      def initialize(i, j)
+        @i, @j = i, j
+        super("element at(#{i},#{j}) not found")
+      end
+    end
+
+    # Raised when the table orientation is unkown
+    class InvalidOrientationError < ArgumentError; end
+
+    # Raised when the table cannot be resized
+    class ResizeError < ArgumentError; end
+
+    # Raised when the operation is not implemented
+    class NoImplementationError < NotImplementedError; end
+
+    # Raised when the argument type is different from expected
+    class TypeError < ArgumentError; end
+
+    # Raised when the required argument is not supplied
+    class ArgumentRequired < ArgumentError; end
+
+    # Raised when the argument is not expected
+    class InvalidArgument < ArgumentError; end
+
+    # Raised when the attribute is unknown
+    class UnknownAttributeError < IndexError; end
+  end # Table
+end # TTY

data/lib/tty/table/field.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class that represents a unique element in a table.
+    #
+    # Used internally by {Table::Row} to define internal structure.
+    #
+    # @api private
+    class Field
+      include Equatable
+
+      # The value inside the field
+      #
+      # @api public
+      attr_reader :value
+
+      # The name for the value
+      #
+      # @api public
+      attr_reader :name
+
+      # TODO: Change to :content to separate value from formatted string
+      attr_writer :value
+
+      # The field value width
+      #
+      # @api public
+      attr_reader :width
+
+      # Number of columns this field spans. Defaults to 1.
+      #
+      attr_reader :colspan
+
+      # Number of rows this field spans. Defaults to 1.
+      #
+      attr_reader :rowspan
+
+      attr_reader :align
+
+      # Initialize a Field
+      #
+      # @example
+      #   field = TTY::Table::Field.new 'a1'
+      #   field.value  # => a1
+      #
+      # @example
+      #   field = TTY::Table::Field.new value: 'a1'
+      #   field.value  # => a1
+      #
+      # @example
+      #   field = TTY::Table::Field.new value: 'a1', align: :center
+      #   field.value  # => a1
+      #   field.align  # => :center
+      #
+      # @api private
+      def initialize(value)
+        options  = extract_options(value)
+        @width   = options.fetch(:width) { @value.to_s.size }
+        @align   = options.fetch(:align) { nil }
+        @colspan = options.fetch(:colspan) { 1 }
+        @rowspan = options.fetch(:rowspan) { 1 }
+      end
+
+      # Extract options and set value
+      #
+      # @api private
+      def extract_options(value)
+        if value.class <= Hash
+          options = value
+          @value = options.fetch(:value)
+        else
+          @value = value
+          options = {}
+        end
+        options
+      end
+
+      # Return the width this field would normally have bar other contraints
+      #
+      # @api public
+      def value_width
+        @width
+      end
+
+      def value_height
+        @height
+      end
+
+      # Return number of lines this value spans.
+      #
+      # A distinction is being made between escaped and non-escaped strings.
+      #
+      # @return [Array[String]]
+      #
+      # @api public
+      def lines
+        escaped = value.to_s.scan(/(\\n|\\t|\\r)/)
+        escaped.empty? ? value.to_s.split(/\n/, -1) : [value.to_s]
+      end
+
+      # If the string contains unescaped new lines then the longest token
+      # deterimines the actual field length.
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def length
+        (lines.max_by(&:length) || '').size
+      end
+
+      # Extract the number of lines this value spans
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def height
+        lines.size
+      end
+
+      def chars
+        value.chars
+      end
+
+      # Render value inside this field box
+      #
+      # @api public
+      def render
+      end
+
+      # Return field value
+      #
+      # @api public
+      def to_s
+        value
+      end
+    end # Field
+  end # Table
+end # TTY

data/lib/tty/table/header.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # Convert an Array row into Header
+    #
+    # @return [TTY::Table::Header]
+    #
+    # @api private
+    def to_header(row)
+      Header.new(row)
+    end
+
+    # A set of header elements that correspond to values in each row
+    class Header
+      include Equatable, Enumerable
+      extend Forwardable
+
+      def_delegators :@attributes, :join, :map, :map!
+
+      # The header attributes
+      #
+      # @return [Array]
+      #
+      # @api private
+      attr_reader :attributes
+      alias :fields :attributes
+
+      # Initialize a Header
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attributes = [])
+        @attributes    = attributes.map { |attr| to_field(attr) }
+        @attribute_for = Hash[@attributes.each_with_index.map.to_a]
+      end
+
+      # Iterate over each element in the vector
+      #
+      # @example
+      #   vec = Vector[1,2,3]
+      #   vec.each { |element| ... }
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        to_ary.each { |element| yield element }
+        self
+      end
+
+      # Instantiates a new field
+      #
+      # @param [String,Hash] attribute
+      #   the attribute value to convert to field object
+      #
+      # @api public
+      def to_field(attribute = nil)
+        Field.new(attribute)
+      end
+
+      # Lookup a column in the header given a name
+      #
+      # @param [Integer, String] attribute
+      #   the attribute to look up by
+      #
+      # @api public
+      def [](attribute)
+        case attribute
+        when Integer
+          @attributes[attribute].value
+        else
+          @attribute_for.fetch(to_field(attribute)) do |header_name|
+            fail UnknownAttributeError,
+                 "the header '#{header_name.value}' is unknown"
+          end
+        end
+      end
+
+      # Lookup attribute without evaluation
+      #
+      # @api public
+      def call(attribute)
+        @attributes[attribute]
+      end
+
+      # Set value at index
+      #
+      # @example
+      #   header[attribute] = value
+      #
+      # @api public
+      def []=(attribute, value)
+        attributes[attribute] = to_field(value)
+      end
+
+      # Size of the header
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def size
+        to_ary.size
+      end
+      alias :length :size
+
+      # Find maximum header height
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def height
+        attributes.map { |field| field.height }.max
+      end
+
+      # Convert the Header into an Array
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ary
+        attributes.map { |attr| attr.value if attr }
+      end
+
+      # Return the header elements in an array.
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_a
+        to_ary.dup
+      end
+
+      # Check if there are no elements.
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        to_ary.empty?
+      end
+
+      # Check if this header is equivalent to another header
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        to_a == other.to_a
+      end
+      alias :eql? :==
+
+      # Provide an unique hash value
+      #
+      # @api public
+      def to_hash
+        to_a.hash
+      end
+    end # Header
+  end # Table
+end # TTY

data/lib/tty/table/indentation.rb

@@ -0,0 +1,52 @@
+# 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/alignment_set.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    module Operation
+      # A class which responsiblity is to align table rows and header.
+      class AlignmentSet
+        include Enumerable
+        # Initialize an AlignmentSet
+        #
+        # @api private
+        def initialize(aligns, widths = nil)
+          @converter = Necromancer.new
+          @elements = @converter.convert(aligns).to(:array)
+          @widths   = widths
+        end
+
+        # Iterate over each element in the alignment set
+        #
+        # @example
+        #   alignment = AlignmentSet.new [1,2,3]
+        #   alignment.each { |element| ... }
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          to_ary.each { |element| yield element }
+          self
+        end
+
+        # Lookup an alignment by index
+        #
+        # @param [Integer]
+        #
+        # @return [Symbol] alignment
+        #
+        # @api public
+        def [](index)
+          elements.fetch(index, :left)
+        end
+
+        # Return each alignment in an Array
+        #
+        # @return [Array]
+        #
+        # @api private
+        def alignments
+          map { |alignment| alignment }
+        end
+
+        # Evaluate alignment of the provided row
+        #
+        # @param [Array] row
+        #  the table row
+        # @param [Hash] options
+        #  the table options
+        #
+        # @return [TTY::Table::Field]
+        #
+        # @api public
+        def call(field, row, col)
+          align_field(field, col)
+        end
+
+        # Convert to array
+        #
+        #  @return [Array]
+        #
+        # @api public
+        def to_ary
+          @elements
+        end
+
+        protected
+
+        attr_reader :widths
+
+        attr_reader :elements
+
+        # Align each field in a row
+        #
+        # @param [TTY::Table::Field] field
+        #   the table field
+        #
+        # @param [Integer] col
+        #   the table column index
+        #
+        # @param [Hash] options
+        #
+        # @return [TTY::Table::Field]
+        #
+        # @api private
+        def align_field(field, col)
+          column_width = widths[col]
+          direction    = field.align || self[col]
+          field.value = Verse.align(field.to_s, column_width, direction)
+        end
+      end # AlignmentSet
+    end # Operation
+  end # Table
+end # TTY