tty 0.0.7 → 0.0.8

data/lib/tty/table/operations.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+
+    # A class holding table field operations
+    class Operations
+
+      # The table
+      #
+      # @api private
+      attr_reader :table
+      private :table
+
+      # Initialize Operations
+      #
+      # @param [TTY::Table] table
+      #   the table to perform operations on
+      #
+      # @return [Object]
+      #
+      # @api public
+      def initialize(table)
+        @table = table
+      end
+
+      # Available operations
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def operations
+        @operations ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      # Add operation
+      #
+      # @param [Symbol] type
+      #   the operation type
+      # @param [Object] object
+      #   the callable object
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def add_operation(type, object)
+        operations[type] << object
+      end
+
+      # Apply operations to a table row
+      #
+      # @param [Symbol] type
+      #  the operation type
+      # @param [#to_ary, Row] row
+      #   the row to apply operation to
+      # @param [Hash] options
+      #   the options for the row
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def run_operations(type, row, options={})
+        options.merge!(:column_widths => table.column_widths)
+        operations[type].each { |op| op.call(row, options) }
+      end
+
+    end # Operations
+  end # Table
+end # TTY

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

@@ -8,10 +8,6 @@ module TTY
       class Basic
         extend TTY::Delegatable
 
-        attr_reader :padding
-
-        attr_reader :indent
-
         # Table to be rendered
         #
         # @return [TTY::Table]
@@ -19,7 +15,6 @@ module TTY
         # @api public
         attr_reader :table
 
-
         # Table border to be rendered
         #
         # @return [TTY::Table::Border]
@@ -27,18 +22,10 @@ module TTY
         # @api private
         attr_reader :border_class
 
-        TABLE_DELEGATED_METHODS = [:column_widths, :alignments]
+        TABLE_DELEGATED_METHODS = [:column_widths, :column_aligns]
 
         delegatable_method :table, *TABLE_DELEGATED_METHODS
 
-        # Return an AlignmentSet object for processing alignments
-        #
-        # @return [AlignmentSet]
-        #
-        # @api private
-        attr_reader :alignment_set
-        private :alignment_set
-
         # Initialize and setup a Renderer
         #
         # @param [Hash] options
@@ -88,16 +75,14 @@ module TTY
         def render(table, border_class=Border::Null)
           @table = table
           @border_class = table.border_class || border_class
+          return if table.empty?
 
-          return if table.to_a.empty?
-          # setup(options)
           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
@@ -114,10 +99,10 @@ module TTY
         def render_header
           header = table.header
           if header && !header.empty?
-            aligned = alignments.align_header header,
-                                              :column_widths => column_widths
-            border = border_class.new(aligned)
-            [border.top_line, border.row_line].compact
+            operations = table.operations
+            operations.run_operations(:alignment, header)
+            border = border_class.new(header, table.border)
+            [ border.top_line, border.row_line ].compact
           else
             []
           end
@@ -129,17 +114,41 @@ module TTY
         #
         # @api private
         def render_rows
-          aligned = alignments.align_rows table.to_a,
-                                          :column_widths => column_widths
-
-          first_row_border = border_class.new(aligned.first)
-          aligned_border   = aligned.map { |row| border_class.new(row).row_line }
+          operations = table.operations
+          table.each do |row|
+            operations.run_operations(:alignment, row)
+          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
+        #
+        # @param [Array] row
+        #   a row to decorate
+        #
+        # @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
+
+          if (table.border.separator == TTY::Table::Border::EACH_ROW) && is_last_row
+            [row_line, separator]
+          else
+            row_line
+          end
+        end
+
       end # Basic
     end # Renderer
   end # Table

data/lib/tty/table/renderer.rb

@@ -59,7 +59,7 @@ module TTY
       #
       # @api private
       def pick_renderer(type=nil)
-        type ? RENDERER_MAPPER[type].new : self.renderer
+        self.renderer= (type ? RENDERER_MAPPER[type].new : self.renderer)
       end
 
       # Return the default renderer
@@ -82,8 +82,20 @@ module TTY
 
       # Add custom border for the renderer
       #
+      # @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 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
       end
 

data/lib/tty/table/row.rb

@@ -0,0 +1,174 @@
+# -*- encoding: utf-8 -*-
+
+require 'tty/vector'
+
+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.
+    class Row < Vector
+      include Equatable
+      extend Forwardable
+
+      def_delegators :to_ary, :join
+
+      # The row attributes
+      #
+      # @return [Array]
+      #
+      # @api private
+      attr_reader :attributes
+
+      # The row data
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :data
+
+      # 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 = 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) }
+          @attributes = (header || data.keys).to_a
+          @data = Hash[@attributes.zip(fields)]
+        end
+      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|
+            raise UnknownAttributeError, "the attribute #{name} is unkown"
+          end.value
+        end
+      end
+      alias :call :[]
+
+      # Set value at index
+      #
+      # @example
+      #   row[attribute] = value
+      #
+      # @api public
+      def []=(attribute, value)
+        case attribute
+        when Integer
+          self.data[attributes[attribute]] = to_field(value)
+        else
+          self.data[attribute] = to_field(value)
+          self.attributes << attribute unless attributes.include?(attribute)
+        end
+      end
+
+      # Number of data items in a row
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def size
+        data.size
+      end
+      alias :length :size
+
+      # Convert the Row into Array
+      #
+      # @example
+      #   array = row.to_ary
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ary
+        to_hash.values_at(*attributes)
+      end
+
+      # Convert the Row into hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_hash
+        hash = data.dup
+        hash.update(hash) { |key, 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
+
+      def map!(&block)
+        data.values_at(*attributes).each do |field|
+          field.value = block.call(field)
+        end
+      end
+    end # Row
+
+  end # Table
+end # TTY

data/lib/tty/table.rb

@@ -4,8 +4,14 @@ require 'forwardable'
 require 'tty/table/renderer'
 require 'tty/table/error'
 require 'tty/table/validatable'
+require 'tty/table/header'
+require 'tty/table/row'
 
 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, Renderer, Conversion
     include Validatable, Equatable
@@ -35,10 +41,10 @@ module TTY
 
     # The table column alignments
     #
-    # @return [Operation::AlignmentSet]
+    # @return [Array]
     #
     # @api private
-    attr_reader :alignments
+    attr_reader :column_aligns
 
     # The table border class
     #
@@ -47,11 +53,21 @@ module TTY
 
     # The table orientation out of :horizontal and :vertical
     #
-    # @reutnr [TTY::Table::Orientation]
+    # @reutrn [TTY::Table::Orientation]
     #
     # @api public
     attr_reader :orientation
 
+    # A callable object used for formatting field content
+    #
+    # @api public
+    attr_accessor :filter
+
+    # The table operations applied to rows
+    #
+    # @api public
+    attr_reader :operations
+
     # Subset of safe methods that both Array and Hash implement
     def_delegators(:@rows, :[], :assoc, :flatten, :include?, :index,
                    :length, :select, :to_a, :values_at, :pretty_print, :rassoc)
@@ -124,26 +140,41 @@ module TTY
     #   used to format table individual column alignment
     # @option options [String] :column_widths
     #   used to format table individula column width
+    # @option options [Symbol] :orientation
+    #   used to transform table orientation
     #
     # @return [TTY::Table]
     #
     # @api private
     def initialize(options={}, &block)
       validate_options! options
-
-      @header        = options.fetch(:header) { nil }
-      @rows          = coerce options.fetch(:rows) { [] }
+      @header        = (value = options[:header]) ? Header.new(value) : nil
+      @rows          = coerce(options.fetch(:rows) { Row.new([]) })
       @renderer      = pick_renderer options[:renderer]
-      @orientation   = Orientation.coerce options.fetch(:orientation) { :horizontal }
+      @border        = TTY::Table::BorderOptions.from(options.delete(:border))
+      @orientation   = Orientation.coerce(options.fetch(:orientation) { :horizontal })
       # TODO: assert that row_size is the same as column widths & aligns
       @column_widths = Array(options.delete(:column_widths)).map(&:to_i)
-      @alignments    = Operation::AlignmentSet.new Array(options.delete(:column_aligns)).map(&:to_sym)
+      @column_aligns = Array(options.delete(:column_aligns)).map(&:to_sym)
+      @operations    = TTY::Table::Operations.new(self)
+      @operations.add_operation(:alignment, Operation::AlignmentSet.new(@column_aligns))
+      @filter        = options.fetch(:filter) { nil }
+      @width         = options.fetch(:width) { TTY.terminal.width }
 
       assert_row_sizes @rows
       @orientation.transform(self)
       yield_or_eval &block if block_given?
     end
 
+    # Set table fields filter
+    #
+    # @param [#call] block
+    #
+    # @api public
+    def filter(&block)
+      @operations.add_operation(:filter, block)
+    end
+
     # Sets table orientation
     #
     # @param [String,Symbol] value
@@ -155,6 +186,8 @@ module TTY
 
     # Marks this table as rotated
     #
+    # @return [Boolean]
+    #
     # @api public
     def rotated?
       @rotated
@@ -174,7 +207,7 @@ module TTY
     #
     # @api private
     def rotate_vertical
-      @rows    = ([header].compact + rows).transpose
+      @rows    = ([header].compact + rows).transpose.map { |row| to_row(row) }
       @header  = [] if header
       @rotated = true
     end
@@ -185,13 +218,31 @@ module TTY
     def rotate_horizontal
       transposed = rows.transpose
       if header && header.empty?
-        @rows = transposed[1..-1]
         @header = transposed[0]
+        @rows   = transposed[1..-1].map { |row| to_row(row, @header) }
       elsif rotated?
-        @rows = transposed
+        @rows = transposed.map { |row| to_row(row) }
       end
     end
 
+    # Store border characters, style and separator for the table rendering
+    #
+    # @param [Hash, BorderOptions] options
+    #
+    # @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
+
     # Lookup element of the table given a row(i) and column(j)
     #
     # @api public
@@ -241,14 +292,19 @@ module TTY
     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
-    #   table.column(1) { |element| ... }
+    #   table = TTY::Table.new :rows => rows, :header => header
+    #   table.column(1)
+    #   table.column(1)   { |element| ... }
+    #   table.column(:h1)
+    #   table.column(:h1) { |element| ... }
     #
-    # @param [Integer] index
+    # @param [Integer, String, Symbol] index
     #
     # @yield []
     #   optional block to execute in the iteration operation
@@ -257,11 +313,12 @@ module TTY
     #
     # @api public
     def column(index)
+      index_unknown = index.is_a?(Integer) && (index >= column_size || index < 0)
       if block_given?
-        return self if index >= column_size || index < 0
-        rows.map { |row| yield row[index].compact }
+        return self if index_unknown
+        rows.map { |row| yield row[index] }
       else
-        return nil if index >= column_size || index < 0
+        return nil if index_unknown
         rows.map { |row| row[index] }.compact
       end
     end
@@ -276,7 +333,7 @@ module TTY
     def <<(row)
       rows_copy = rows.dup
       assert_row_sizes rows_copy << row
-      rows << row
+      rows << to_row(row)
       self
     end
 
@@ -293,8 +350,25 @@ module TTY
     # @api public
     def each
       return to_enum unless block_given?
-      rows.each do |row|
-        yield row
+      rows.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?
+      rows.each_with_index do |row, row_index|
+        row.each_with_index do |el, col_index|
+          yield el, row_index, col_index
+        end
       end
       self
     end
@@ -375,7 +449,8 @@ module TTY
     #
     # @api public
     def coerce(rows)
-      convert_to_array(rows)
+      rows = convert_to_array(rows)
+      rows.map { |row| to_row(row, header) }
     end
 
   private

data/lib/tty/text/truncation.rb

@@ -57,7 +57,7 @@ module TTY
 
         as_unicode do
           chars = text.chars.to_a
-          return chars.join if chars.length < length
+          return chars.join if chars.length <= length
           stop = chars[0, length_without_trailing].rindex(separator)
 
           chars[0, stop || length_without_trailing].join + trailing

data/lib/tty/vector.rb

@@ -41,7 +41,7 @@ module TTY
     #
     # @api public
     def [](indx)
-      elements[i]
+      elements[indx]
     end
     alias at      []
     alias element []
@@ -58,7 +58,7 @@ module TTY
     #
     # @api public
     def []=(indx, value)
-      elements[index] = value
+      self.elements[indx] = value
     end
     alias set_element []=
 
@@ -71,9 +71,9 @@ module TTY
     # @return [self]
     #
     # @api public
-    def each(&block)
-      return to_enum(:each) unless block_given?
-      to_ary.each(&block)
+    def each
+      return to_enum unless block_given?
+      to_ary.each { |element| yield element }
       self
     end
 
@@ -83,7 +83,7 @@ module TTY
     #
     # @api public
     def to_ary
-      elements
+      @elements
     end
 
     # Check if there are not elements.
@@ -103,6 +103,7 @@ module TTY
     def size
       to_ary.size
     end
+    alias :length :size
 
     # Return the vector elements in an array.
     #
@@ -110,7 +111,7 @@ module TTY
     #
     # @api public
     def to_a
-      elements.dup
+      to_ary.dup
     end
 
   end # Vector

data/lib/tty/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
 
 module TTY
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end