tty-table 0.1.0

data/lib/tty/table/border.rb

@@ -0,0 +1,219 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # Abstract base class that is responsible for building the table border.
+    class Border
+      include Equatable
+
+      EMPTY_CHAR = ''.freeze
+
+      SPACE_CHAR = ' '.freeze
+
+      # Represent a separtor on each row
+      EACH_ROW = :each_row
+
+      # The row field widths
+      #
+      # @api private
+      attr_reader :widths
+      private :widths
+
+      # The table custom border characters
+      attr_reader :border
+
+      # The table
+
+      class << self
+        # Store characters for border
+        #
+        # @api private
+        attr_accessor :characters
+      end
+
+      # Instantiate a new object
+      #
+      # @param [Array] column_widths
+      #   the table column widths
+      #
+      # @param [BorderOptions] options
+      #
+      # @return [Object]
+      #
+      # @api private
+      def initialize(column_widths, options = nil)
+        if self.class == Border
+          fail NotImplementedError, "#{self} is an abstract class"
+        else
+          @widths = column_widths
+          @border = TTY::Table::BorderOptions.from options
+          @color  = Pastel.new
+        end
+      end
+
+      # Define border characters
+      #
+      # @param [Hash] characters
+      #   the border characters
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def self.def_border(characters=(not_set=true), &block)
+        return self.characters = characters unless not_set
+
+        dsl = TTY::Table::BorderDSL.new(&block)
+        self.characters = dsl.characters
+      end
+
+      # Retrive individula character by type
+      #
+      # @param [String] type
+      #   the character type
+      #
+      # @return [String]
+      #
+      # @api private
+      def [](type)
+        characters = self.class.characters
+        chars = border.nil? ? characters : characters.merge(border.characters)
+        chars[type] || EMPTY_CHAR
+      end
+
+      # Check if border color is set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def color?
+        border && border.style
+      end
+
+      # Set color on characters
+      #
+      # @param [Symbol] color
+      #
+      # @param [Array[String]] array of strings
+      #
+      # @return [Array[String]]
+      #
+      # @api public
+      def set_color(color, *strings)
+        strings.map { |string| @color.decorate(string, color) }
+      end
+
+      # A line spanning all columns marking top of a table.
+      #
+      # @return [String]
+      #
+      # @api private
+      def top_line
+        (result = render(:top)).empty? ? nil : result
+      end
+
+      # A line spannig all columns marking bottom of a table.
+      #
+      # @return [String]
+      #
+      # @api private
+      def bottom_line
+        (result = render(:bottom)).empty? ? nil : result
+      end
+
+      # A line spanning all columns delemeting rows in a table.
+      #
+      # @return [String]
+      #
+      # @api private
+      def separator
+        (result = render(:mid)).empty? ? nil : result
+      end
+
+      # A line spanning all columns delemeting fields in a row.
+      #
+      # @param [TTY::Table::Row] row
+      #   the table row
+      #
+      # @return [String]
+      #
+      # @api public
+      def row_line(row)
+        line = RowLine.new(self['left'], self['center'], self['right'])
+        line.colorize(self, border.style) if color?
+
+        result = row_heights(row, line)
+        result.empty? ? EMPTY_CHAR : result
+      end
+
+      protected
+
+      # Separate multiline string into individual rows with border.
+      #
+      # @param [TTY::Table::Row] row
+      #   the table row
+      #
+      # @param [TTY::Table::Border::RowLine] line
+      #
+      # @api private
+      def row_heights(row, line)
+        if row.size > 0
+          row.height.times.map do |line_index|
+            row_height_line(row, line_index, line)
+          end.join("\n")
+        else
+          line.left + line.right
+        end
+      end
+
+      # Generate border for a given multiline row
+      #
+      # @param [TTY::Table::Row] row
+      #   the table row
+      #
+      # @param [Integer] line
+      #  the index for current line inside multiline
+      #
+      # @param [TTY::Table::Border::RowLine] line
+      #
+      # @return [String]
+      #
+      # @api private
+      def row_height_line(row, line_index, line)
+        line.left + row.fields.each_with_index.map do |field, index|
+          (field.lines[line_index] || EMPTY_CHAR).ljust(widths[index])
+        end.join(line.center) + line.right
+      end
+
+      # Generate particular border type
+      #
+      # @param [String] type
+      #  border type one of [:top, :bottom, :mid]
+      #
+      # @api private
+      def render(type)
+        type = type.to_s
+        border_char = self[type]
+        line = render_line(border_char,
+                           self["#{type}_left"]  || border_char,
+                           self["#{type}_right"] || border_char,
+                           self["#{type}_mid"])
+
+        if color? && !line.empty?
+          line = set_color(border.style, line)
+        end
+        line
+      end
+
+      # Generate a border string
+      #
+      # @param [String] line
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_line(line, left, right, intersection)
+        left + widths.map { |width| line * width }.join(intersection) + right
+      end
+    end # Border
+  end # Table
+end # TTY

data/lib/tty/table/border_dsl.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class responsible for bulding and modifying border
+    #
+    # Used internally by {Table::Border} to allow for building custom border
+    # through DSL
+    # @api private
+    class BorderDSL
+      extend Forwardable
+
+      # Border options
+      #
+      # @return [Table::BorderOptions]
+      attr_reader :options
+
+      def_delegators :@options, :characters, :style
+
+      # Initialize a BorderDSL
+      #
+      # @param [Hash] characters
+      #   the border characters
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(characters = nil, &block)
+        @options = TTY::Table::BorderOptions.new
+        @options.characters = characters if characters
+        yield_or_eval(&block) if block_given?
+      end
+
+      # Apply style color to the border
+      #
+      # @param [Symbol] style
+      #   the style color for the border
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def style(value)
+        options.style = value
+      end
+
+      # Apply table tuple separator
+      #
+      # @param [Symbol] separator
+      #   the table tuple separator
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def separator(value)
+        value ? options.separator = value : options.separator
+      end
+
+      # Set top border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def top(value)
+        options.characters['top'] = value
+      end
+
+      # Set top middle border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def top_mid(value)
+        options.characters['top_mid'] = value
+      end
+
+      # Set top left corner border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def top_left(value)
+        options.characters['top_left'] = value
+      end
+
+      # Set top right corner border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def top_right(value)
+        options.characters['top_right'] = value
+      end
+
+      # Set bottom border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def bottom(value)
+        options.characters['bottom'] = value
+      end
+
+      # Set bottom middle border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def bottom_mid(value)
+        options.characters['bottom_mid'] = value
+      end
+
+      # Set bottom left corner border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def bottom_left(value)
+        options.characters['bottom_left'] = value
+      end
+
+      # Set bottom right corner border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def bottom_right(value)
+        options.characters['bottom_right'] = value
+      end
+
+      # Set middle border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def mid(value)
+        options.characters['mid'] = value
+      end
+
+      # Set middle border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def mid_mid(value)
+        options.characters['mid_mid'] = value
+      end
+
+      # Set middle left corner border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def mid_left(value)
+        options.characters['mid_left'] = value
+      end
+
+      # Set middle right corner border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def mid_right(value)
+        options.characters['mid_right'] = value
+      end
+
+      # Set left border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def left(value)
+        options.characters['left'] = value
+      end
+
+      # Set center border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def center(value)
+        options.characters['center'] = value
+      end
+
+      # Set right border character
+      #
+      # @param [String] value
+      #   the character value
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def right(value)
+        options.characters['right'] = value
+      end
+
+      private
+
+      # Evaluate block
+      #
+      # @return [Table]
+      #
+      # @api private
+      def yield_or_eval(&block)
+        return unless block
+        block.arity > 0 ? yield(self) : instance_eval(&block)
+      end
+    end # BorderDSL
+  end # Table
+end # TTY

data/lib/tty/table/border_options.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class that represents table border options
+    #
+    # Used internally by {Table::Border} to manage options such as style
+    #
+    # @api private
+    class BorderOptions < Struct.new(:characters, :separator, :style)
+      # Initialize a BorderOptions
+      #
+      # @api public
+      def initialize(*args)
+        super(*args)
+        self.characters = {} unless characters
+      end
+
+      # Create options instance from hash
+      #
+      # @api public
+      def self.from(value)
+        value ? new.update(value) : new
+      end
+
+      # Set all accessors with hash attributes
+      #
+      # @param [Hash, BorderOptions] obj
+      #
+      # @return [BorderOptions]
+      #
+      # @api public
+      def update(obj)
+        obj.each_pair do |key, value|
+          send("#{key}=", value)
+        end
+        self
+      end
+
+      # Convert to hash
+      #
+      # @api public
+      def to_hash
+        hash = {}
+        members.each do |key|
+          value = send(key)
+          hash[key.to_sym] = value if value
+        end
+        hash
+      end
+    end # BorderOptions
+  end # Table
+end # TTY

data/lib/tty/table/column_set.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class that represents table column properties.
+    #
+    # Used by {Table} to manage column sizing.
+    #
+    # @api private
+    class ColumnSet
+      include Equatable
+
+      attr_reader :table
+
+      # Initialize a ColumnSet
+      #
+      # @api public
+      def initialize(table)
+        @table = table
+      end
+
+      # Calculate total table width
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def total_width
+        extract_widths.reduce(:+)
+      end
+
+      # Calcualte maximum column widths
+      #
+      # @return [Array] column widths
+      #
+      # @api private
+      def extract_widths
+        data     = table.data
+        colcount = data.max { |row_a, row_b| row_a.size <=> row_b.size }.size
+
+        self.class.find_maximas(colcount, data)
+      end
+
+      # Assert data integrity for column widths
+      #
+      # @param [Array] column_widths
+      #
+      # @param [Integer] table_widths
+      #
+      # @raise [TTY::InvalidArgument]
+      #
+      # @api public
+      def self.assert_widths(column_widths, table_widths)
+        if column_widths.empty?
+          fail InvalidArgument, 'Value for :column_widths must be ' \
+                                 'a non-empty array'
+        end
+        if column_widths.size != table_widths
+          fail InvalidArgument, 'Value for :column_widths must match ' \
+                                 'table column count'
+        end
+      end
+
+      # Converts column widths to array format or infers default widths
+      #
+      # @param [TTY::Table] table
+      #
+      # @param [Array, Numeric, NilClass] column_widths
+      #
+      # @return [Array[Integer]]
+      #
+      # @api public
+      def self.widths_from(table, column_widths = nil)
+        case column_widths
+        when Array
+          assert_widths(column_widths, table.column_size)
+          Array(column_widths).map(&:to_i)
+        when Numeric
+          Array.new(table.column_size, column_widths)
+        when NilClass
+          new(table).extract_widths
+        else
+          fail TypeError, 'Invalid type for column widths'
+        end
+      end
+
+      private
+
+      # Find maximum widths for each row and header if present.
+      #
+      # @param [Integer] colcount
+      #   number of columns
+      # @param [Array[Array]] data
+      #   the table's header and rows
+      #
+      # @api private
+      def self.find_maximas(colcount, data)
+        maximas = []
+        start   = 0
+
+        start.upto(colcount - 1) do |col_index|
+          maximas << find_maximum(data, col_index)
+        end
+        maximas
+      end
+
+      # Find a maximum column width. The calculation takes into account
+      # wether the content is escaped or not.
+      #
+      # @param [Array] data
+      #   the table data
+      #
+      # @param [Integer] index
+      #   the column index
+      #
+      # @api private
+      def self.find_maximum(data, index)
+        data.map { |row| (value = row.call(index)) ? value.length : 0 }.max
+      end
+    end # ColumnSet
+  end # Table
+end # TTY