tty-table 0.1.0

data/lib/tty/table/validatable.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # Mixin to provide validation for {Table}.
+    #
+    # Include this mixin to add validation for options.
+    #
+    # @api private
+    module Validatable
+      # Check if table rows are the equal size
+      #
+      # @raise [DimensionMismatchError]
+      #   if the rows are not equal length
+      #
+      # @return [nil]
+      #
+      # @api private
+      def assert_row_sizes(rows)
+        size = (rows[0] || []).size
+        rows.each do |row|
+          next if row.size == size
+          fail TTY::Table::DimensionMismatchError,
+               "row size differs (#{row.size} should be #{size})"
+        end
+      end
+
+      # Check if table type is provided
+      #
+      # @raise [ArgumentRequired]
+      #
+      # @return [Table]
+      #
+      # @api private
+      def assert_table_type(value)
+        return value if value.is_a?(TTY::Table)
+        fail ArgumentRequired,
+             "Expected TTY::Table instance, got #{value.inspect}"
+      end
+
+      # def assert_matching_widths(rows)
+      # end
+      #
+      # def assert_string_values(rows)
+      # end
+
+      # Check if options are of required type
+      #
+      # @api private
+      def validate_options!(options)
+        header = options[:header]
+        rows   = options[:rows]
+
+        if header && (!header.is_a?(Array) || header.empty?)
+          fail InvalidArgument, ':header must be a non-empty array'
+        end
+
+        if rows && !(rows.is_a?(Array) || rows.is_a?(Hash))
+          fail InvalidArgument, ':rows must be a non-empty array or hash'
+        end
+      end
+    end # Validatable
+  end # Table
+end # TTY

data/lib/tty/table/version.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+module TTY
+  class Table
+    VERSION = "0.1.0"
+  end
+end # TTY

data/lib/tty/table.rb

@@ -0,0 +1,469 @@
+# coding: utf-8
+
+module TTY
+  # A core class intended for storing data in a structured, tabular form.
+  # Once the data is stored in a TTY::Table various operations can be performed
+  # before the information is dumped into a stdout.
+  class Table
+    include Comparable, Enumerable, Validatable, Equatable
+    extend Forwardable
+
+    # The table header
+    #
+    # @return [Enumerable]
+    #
+    # @api public
+    attr_reader :header
+
+    # The table rows
+    #
+    # @return [Enumerable]
+    #
+    # @api private
+    attr_reader :rows
+    # private :rows
+
+    # The table orientation out of :horizontal and :vertical
+    #
+    # @reutrn [TTY::Table::Orientation]
+    #
+    # @api public
+    attr_reader :orientation
+
+    # The table original row count
+    #
+    # @reutrn [Integer]
+    #
+    # @api public
+    attr_reader :original_rows
+
+    # The table original column count
+    #
+    # @reutrn [Integer]
+    #
+    # @api public
+    attr_reader :original_columns
+
+    # Subset of safe methods that both Array and Hash implement
+    def_delegators(:data, :assoc, :flatten, :include?, :index,
+                   :length, :select, :to_a, :values_at, :pretty_print, :rassoc)
+
+    # Create a new Table where each argument is a row
+    #
+    # @example
+    #   table = TTY::Table[['a1', 'a2'], ['b1', 'b2']]
+    #
+    # @api public
+    def self.[](*rows)
+      new(rows: rows)
+    end
+
+    # Instantiate a new Table
+    #
+    # @example of no header
+    #   rows  = [ ['a1', 'a2'], ['b1', 'b2'] ]
+    #   table = Table.new rows
+    #
+    # @example of direct parameters
+    #   rows  = [ ['a1', 'a2'], ['b1', 'b2'] ]
+    #   table = Table.new ['Header 1', 'Header 2'], rows
+    #
+    # @example of parameters passed as options
+    #   rows  = [ ['a1', 'a2'], ['b1', 'b2'] ]
+    #   table = Table.new header: ['Header 1', 'Header 2'], rows: rows
+    #
+    # @example of parameters passed as hash
+    #   Table.new [ {'Header1' => ['a1','a2'], 'Header2' => ['b1', 'b2'] }] }
+    #
+    # @param [Array[Symbol], Hash] *args
+    #
+    # @api public
+    def self.new(*args, &block)
+      options = args.last.respond_to?(:to_hash) ? args.pop : {}
+      if args.size.nonzero?
+        super(Transformation.extract_tuples(args).merge(options), &block)
+      else
+        super(options, &block)
+      end
+    end
+
+    # Initialize a Table
+    #
+    # @param [Hash] options
+    #   the options to create the table with
+    # @option options [String] :header
+    #   column names to be displayed
+    # @option options [String] :rows
+    #   Array of Arrays expressing the rows
+    # @option options [Symbol] :orientation
+    #   used to transform table orientation
+    #
+    # @return [TTY::Table]
+    #
+    # @api private
+    def initialize(options = {}, &block)
+      validate_options! options
+      @converter     = Necromancer.new
+      @header        = (value = options[:header]) ? Header.new(value) : nil
+      @rows          = coerce(options.fetch(:rows) { Row.new([]) })
+      @rotated       = false
+      self.orientation = options.fetch(:orientation) { :horizontal }
+
+      assert_row_sizes @rows
+      orientation.transform(self)
+
+      yield_or_eval(&block) if block_given?
+    end
+
+    # Provides access to all table data
+    #
+    # @return [Array]
+    #
+    # @api public
+    def data
+      (header && !header.empty?) ? [header] + rows : rows
+    end
+
+    # Sets table orientation
+    #
+    # @param [String,Symbol] value
+    #
+    # @api public
+    def orientation=(value)
+      @orientation = Orientation.coerce(value)
+    end
+
+    # Marks this table as rotated
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def rotated?
+      @rotated
+    end
+
+    # Rotate the table between vertical and horizontal orientation
+    #
+    # @return [self]
+    #
+    # @api private
+    def rotate
+      orientation.transform(self)
+      self
+    end
+
+    # Rotate the table vertically
+    #
+    # @api private
+    def rotate_vertical
+      @original_columns = column_size
+      @original_rows    = row_size
+      @rows             = orientation.slice(self)
+      @header           = [] if header
+      @rotated          = true
+    end
+
+    # Rotate the table horizontally
+    #
+    # @api private
+    def rotate_horizontal
+      return unless rotated?
+      head, body = orientation.slice(self)
+      if header && header.empty?
+        @header = head[0]
+        @rows   = body.map { |row| to_row(row, @header) }
+      else
+        @rows = body.map { |row| to_row(row) }
+      end
+    end
+
+    # Lookup element of the table given a row(i) and column(j)
+    #
+    # @api public
+    def [](row_index, column_index = false)
+      return row(row_index) unless column_index
+      if row_index >= 0 && column_index >= 0
+        rows.fetch(row_index) { return nil }[column_index]
+      else
+        fail TTY::Table::TupleMissing.new(row_index, column_index)
+      end
+    end
+    alias at        []
+    alias element   []
+    alias component []
+
+    # Set table value at row(i) and column(j)
+    #
+    # @api private
+    def []=(row_index, column_index, val)
+      @rows[row_index][column_index] = val
+    end
+    private :[]=
+
+    # Return a row number at the index of the table as an Array.
+    # When a block is given, the elements of that Array are iterated over.
+    #
+    # @example
+    #   rows  = [ ['a1', 'a2'], ['b1', 'b2'] ]
+    #   table = TTY::Table.new :rows => rows
+    #   table.row(1) { |element| ... }
+    #
+    # @param [Integer] index
+    #
+    # @yield []
+    #   optional block to execute in the iteration operation
+    #
+    # @return [self]
+    #
+    # @api public
+    def row(index, &block)
+      if block_given?
+        rows.fetch(index) { return self }.each(&block)
+        self
+      else
+        rows.fetch(index) { return nil }
+      end
+    end
+
+    # Return a column number at the index of the table as an Array.
+    # If the table has a header then column can be searched by header name.
+    # When a block is given, the elements of that Array are iterated over.
+    #
+    # @example
+    #   header = [:h1, :h2]
+    #   rows  = [ ['a1', 'a2'], ['b1', 'b2'] ]
+    #   table = TTY::Table.new :rows => rows, :header => header
+    #   table.column(1)
+    #   table.column(1)   { |element| ... }
+    #   table.column(:h1)
+    #   table.column(:h1) { |element| ... }
+    #
+    # @param [Integer, String, Symbol] index
+    #
+    # @yield []
+    #   optional block to execute in the iteration operation
+    #
+    # @return [self]
+    #
+    # @api public
+    def column(index)
+      index_unknown = index.is_a?(Integer) && (index >= column_size || index < 0)
+      if block_given?
+        return self if index_unknown
+        rows.map { |row| yield row[index] }
+      else
+        return nil if index_unknown
+        rows.map { |row| row[index] }.compact
+      end
+    end
+
+    # Add row to table
+    #
+    # @param [Array] row
+    #
+    # @return [self]
+    #
+    # @api public
+    def <<(row)
+      rows_copy = rows.dup
+      assert_row_sizes rows_copy << row
+      rows << to_row(row)
+      self
+    end
+
+    # Iterate over each tuple in the set
+    #
+    # @example
+    #   table = TTY::Table.new(header, tuples)
+    #   table.each { |row| ... }
+    #
+    # @yield [Array[Array]]
+    #
+    # @return [self]
+    #
+    # @api public
+    def each
+      return to_enum unless block_given?
+      data.each { |row| yield row }
+      self
+    end
+
+    # Iterate over each element yielding in addition row and column index
+    #
+    # @example
+    #   table = TTY::Table.new(header, tuples)
+    #   table.each_with_index { |el, row, col| puts "#{el} at #{row},#{col}" }
+    #
+    # @return self
+    #
+    # @api public
+    def each_with_index
+      return to_enum unless block_given?
+      start_index = 0
+      if header && !header.empty?
+        header.attributes.each_with_index do |el, col_index|
+          yield el, 0, col_index
+        end
+        start_index = 1
+      end
+
+      rows.each_with_index do |row, row_index|
+        row.fields.each_with_index do |el, col_index|
+          yield el, row_index + start_index, col_index
+        end
+      end
+      self
+    end
+
+    # Return the number of columns
+    #
+    # @example
+    #   table.column_size # => 5
+    #
+    # @return [Integer]
+    #
+    # @api public
+    # TODO: renmae to columns_size
+    def column_size
+      rows.size > 0 ? rows[0].size : 0
+    end
+
+    # Return the number of rows
+    #
+    # @example
+    #   table.row_size # => 5
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def row_size
+      rows.size
+    end
+
+    # Return the number of rows and columns
+    #
+    # @example
+    #   table.size # => [3,5]
+    #
+    # @return [Array] row x columns
+    #
+    # @api public
+    def size
+      [row_size, column_size]
+    end
+
+    # Check table width
+    #
+    # @return [Integer] width
+    #
+    # @api public
+    def width
+      ColumnSet.new(self).total_width
+    end
+
+    # Return true if this is an empty table, i.e. if the number of
+    # rows or the number of columns is 0
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def empty?
+      column_size == 0 || row_size == 0
+    end
+
+    # Return string representation of table using basic renderer.
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_s
+      render(:basic)
+    end
+
+    # Return renderer for this table
+    #
+    # @param [Symbol] type
+    #   the renderer type
+    #
+    # @param [Hash] options
+    #   the renderer options
+    #
+    def renderer(type = :basic, options = {})
+      @renderer ||= Renderer.select(type).new(self, options)
+    end
+
+    # Render a given table. This method takes options which will be passed
+    # to the renderer prior to rendering, which allows the caller to set any
+    # table rendering variables.
+    #
+    # @param [Symbol] renderer_type
+    #   the renderer to be used
+    #
+    # @param [Hash] options
+    #
+    # @yield [renderer]
+    #
+    # @yieldparam [TTY::Table::Renderer] renderer
+    #   the renderer for the table
+    #
+    # @return [String]
+    #
+    # @api public
+    def render(*args, &block)
+      render_with(nil, *args, &block)
+    end
+
+    # Render a given table using custom border class.
+    #
+    # @param [TTY::Table::Border]
+    #
+    # @param [Symbol] renderer_type
+    #
+    # @yield [renderer]
+    #
+    # @yieldparam [TTY::Table::Renderer] renderer
+    #   the renderer for the table
+    #
+    # @return [String]
+    #
+    # @api public
+    def render_with(border_class, renderer_type=(not_set=true), options={}, &block)
+      unless not_set
+        if renderer_type.respond_to?(:to_hash)
+          options = renderer_type
+        else
+          options[:renderer] = renderer_type
+        end
+      end
+
+      Renderer.render_with(border_class, self, options, &block)
+    end
+
+    # Coerce an Enumerable into a Table
+    # This coercion mechanism is used by Table to handle Enumerable types
+    # and force them into array type.
+    #
+    # @param [Enumerable] object
+    #    the object to coerce
+    #
+    # @return [Array]
+    #
+    # @api public
+    def coerce(rows)
+      rows = @converter.convert(rows).to(:array)
+      rows.map { |row| to_row(row, header) }
+    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 # Table
+end # TTY

data/lib/tty-table.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+require 'equatable'
+require 'forwardable'
+require 'necromancer'
+require 'verse'
+require 'tty-screen'
+require 'pastel'
+
+require 'tty/table/header'
+require 'tty/table/row'
+require 'tty/table/field'
+require 'tty/table/version'
+require 'tty/table/validatable'
+require 'tty/table/error'
+
+require 'tty/table/border'
+require 'tty/table/border_dsl'
+require 'tty/table/border_options'
+require 'tty/table/border/unicode'
+require 'tty/table/border/ascii'
+require 'tty/table/border/null'
+require 'tty/table/border/row_line'
+
+require 'tty/table/renderer'
+require 'tty/table/renderer/ascii'
+require 'tty/table/renderer/basic'
+require 'tty/table/renderer/color'
+require 'tty/table/renderer/unicode'
+
+require 'tty/table/column_set'
+require 'tty/table/columns'
+require 'tty/table/orientation'
+require 'tty/table/orientation/horizontal'
+require 'tty/table/orientation/vertical'
+require 'tty/table/transformation'
+require 'tty/table/indentation'
+require 'tty/table/padder'
+
+require 'tty/table/operations'
+require 'tty/table/operation/alignment_set'
+require 'tty/table/operation/truncation'
+require 'tty/table/operation/wrapped'
+require 'tty/table/operation/filter'
+require 'tty/table/operation/escape'
+require 'tty/table/operation/padding'
+
+require 'tty/table'

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
+require 'tty-table'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 2
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end
+
+class String
+  def normalize
+    gsub(/^[ \t]*/, '').chomp
+  end
+end