tty 0.0.3 → 0.0.4

data/README.md

@@ -38,15 +38,18 @@ Or install it yourself as:
 
 ### Table
 
-To instantiate table
+To instantiate table pass 2-dimensional array:
 
 ```ruby
   table = TTY::Table[['a1', 'a2'], ['b1', 'b2']]
   table = TTY::Table.new [['a1', 'a2'], ['b1', 'b2']]
   table = TTY::Table.new rows: [['a1', 'a2'], ['b1', 'b2']]
+
+  table = TTY::Table.new ['h1', 'h2'], [['a1', 'a2'], ['b1', 'b2']]
+  table = TTY::Table.new header: ['h1', 'h2'], rows: [['a1', 'a2'], ['b1', 'b2']]
 ```
 
-Apart from `rows`, you can provide other customization options such as
+Apart from `rows` and `header`, you can provide other customization options such as
 
 ```ruby
   column_widths   # enforce maximum columns widths
@@ -59,6 +62,7 @@ Table behaves like an Array so `<<`, `each` and familiar methods can be used
 ```ruby
   table << ['a1', 'a2', 'a3']
   table << ['b1', 'b2', 'b3']
+  table << ['a1', 'a2'] << ['b1', 'b2']  # chain rows assignment
 
   table.each { |row| ... }  # iterate over rows
   table[i, j]               # return element at row(i) and column(j)
@@ -66,6 +70,7 @@ Table behaves like an Array so `<<`, `each` and familiar methods can be used
   table.column(j) { ... }   # return array for column(j)
   table.row_size            # return row size
   table.column_size         # return column size
+  table.size                # return an array of [row_size, column_size]
 ```
 
 or pass your rows in a block
@@ -77,7 +82,6 @@ or pass your rows in a block
   end
 ```
 
-
 And then to print do
 
 ```ruby

data/Rakefile

@@ -7,4 +7,6 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
+FileList['tasks/**/*.rake'].each { |task| import task }
+
 task :default => [:spec]

data/lib/tty/support/equatable.rb

@@ -0,0 +1,151 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+
+  # Make it easy to define equality and hash methods.
+  module Equatable
+
+    # Hook into module inclusion.
+    #
+    # @param [Module] base
+    #
+    # @return [self]
+    #
+    # @api private
+    def self.included(base)
+      super
+      base.extend(self)
+      base.class_eval do
+        define_comparison_attrs
+        include Methods
+        define_methods
+      end
+      self
+    end
+
+    # Holds all attributes used for comparison.
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    attr_reader :comparison_attrs
+
+    # Objects that include this module are assumed to be value objects.
+    # It is also assumed that the only values that affect the results of
+    # equality comparison are the values of the object's attributes.
+    #
+    # @param [Array<Symbol>] *args
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def attr_reader(*args)
+      super
+      @comparison_attrs.concat(args)
+    end
+
+    # Copy the comparison_attrs into the subclass.
+    #
+    # @param [Class] subclass
+    #
+    # @api private
+    def inherited(subclass)
+      super
+      subclass.instance_variable_set(:@comparison_attrs, comparison_attrs.dup)
+    end
+
+    private
+
+    # Define class instance #comparison_attrs as an empty array.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_comparison_attrs
+      instance_variable_set('@comparison_attrs', [])
+    end
+
+    # Define all methods needed for ensuring object's equality.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_methods
+      define_compare
+      define_hash
+      define_inspect
+    end
+
+    # Define a #compare? method to check if the receiver is the same
+    # as the other object.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_compare
+      define_method(:compare?) do |comparator, other|
+        attrs = comparison_attrs || []
+        !attrs.find { |attr| send(attr).send(comparator, other.send(attr)) }
+      end
+    end
+
+    # Define a hash method that ensures that the hash value is the same for
+    # the same instance attributes and their corresponding values.
+    #
+    # @api private
+    def define_hash
+      define_method(:hash) do
+        klass = self.class
+        attrs = klass.comparison_attrs || []
+        ([klass] + attrs.map { |attr| send(attr)}).hash
+      end
+    end
+
+    # Define an inspect method that shows the class name and the values for the
+    # instance's attributes.
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_inspect
+      define_method(:inspect) do
+        klass = self.class
+        name = klass.name || klass.inspect
+        attrs = klass.comparison_attrs || []
+        "#<#{name}#{attrs.map { |attr| " #{attr}=#{send(attr).inspect}" }.join}>"
+      end
+    end
+
+    module Methods
+
+      # Compare two objects for equality based on their value
+      # and being an instance of the given class.
+      #
+      # @param [Object] other
+      #   the other object in comparison
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) and compare?(__method__, other)
+      end
+
+      # Compare two objects for equality based on their value
+      # and being a subclass of the given class.
+      #
+      # @param [Object] other
+      #   the other object in comparison
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        return false unless self.class <=> other.class
+        compare?(__method__, other)
+      end
+
+    end # Methods
+
+  end # Equatable
+end # TTY

data/lib/tty/table/operation/alignment.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 module TTY
   class Table
     module Operation
@@ -10,6 +12,9 @@ module TTY
 
         CENTER = :center.freeze
 
+        # Hold the type of alignment
+        #
+        # @api private
         attr_reader :type
 
         # Initialize an Alignment
@@ -25,7 +30,6 @@ module TTY
           assert_valid_type
         end
 
-
         # Assert the type is valid
         #
         # @return [undefined]
@@ -50,26 +54,49 @@ module TTY
           [LEFT, RIGHT, CENTER]
         end
 
-        # Format cell with a given alignment
+        # Format field with a given alignment
+        #
+        # @param [Object] field
+        #
+        # @param [Integer] column_width
+        #
+        # @param [String] space
         #
         # @return [String] aligned
         #
         # @api public
-        def format(cell, column_width, space='')
+        def format(field, column_width, space='')
           case type
           when :left
-            "%-#{column_width}s#{space}" % cell.to_s
+            "%-#{column_width}s#{space}" % field.to_s
           when :right
-            "%#{column_width}s#{space}" % cell.to_s
+            "%#{column_width}s#{space}" % field.to_s
           when :center
-            chars = cell.to_s.chars.to_a
-            if column_width >= chars.size
-              right = ((pad_length = column_width - chars.length).to_f / 2).ceil
-              left = pad_length - right
-              [' ' * left, cell, ' ' * right].join
-            else
-              cell
-            end
+            center_align field, column_width, space
+          end
+        end
+
+      private
+
+        # Center aligns field
+        #
+        # @param [Object] field
+        #
+        # @param [Integer] column_width
+        #
+        # @param [String] space
+        #
+        # @return [String] aligned
+        #
+        # @api private
+        def center_align(field, column_width, space)
+          chars = field.to_s.chars.to_a
+          if column_width >= chars.size
+            right = ((pad_length = column_width - chars.length).to_f / 2).ceil
+            left = pad_length - right
+            [' ' * left, field, ' ' * right, space].join
+          else
+            "#{field}#{space}"
           end
         end
 

data/lib/tty/table/operation/alignment_set.rb

@@ -3,6 +3,8 @@
 module TTY
   class Table
     module Operation
+
+      # A class which responsiblity is to align table rows and header.
       class AlignmentSet
         include Enumerable
 
@@ -61,7 +63,7 @@ module TTY
           @alignments
         end
 
-        # @return [Array]
+        # @return [Array[Alignment]]
         #
         # @api public
         def to_a
@@ -75,11 +77,20 @@ module TTY
           to_ary.empty?
         end
 
-        # Align the supplied rows with the correct alignment
+        # Aligns table header
+        #
+        # @return [Array[String]]
+        #
+        # @api public
+        def align_header(header, options={})
+          align_row(header, options)
+        end
+
+        # Align the supplied rows with the correct alignment.
         #
         # @param [Array] rows
         #
-        # @return [Array]
+        # @return [Array[Array]]
         #   the aligned rows
         #
         # @api private
@@ -95,17 +106,17 @@ module TTY
         #
         # @param [Hash] options
         #
-        # @return [String]
+        # @return [Array[String]]
         #
         # @api private
         def align_row(row, options={})
-          line = ""
+          line = []
           row.each_with_index do |cell, index|
             column_width = options[:column_widths][index]
             alignment = Alignment.new self[index]
 
             if index == row.size - 1
-              line <<  alignment.format(cell, column_width)
+              line << alignment.format(cell, column_width)
             else
               line << alignment.format(cell, column_width, ' ')
             end

data/lib/tty/table/operation/truncation.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    module Operation
+
+      # A class responsible for shortening text.
+      class Truncation
+
+        def truncate(string, width, options={})
+          trailing = options.fetch :trailing, '…'
+
+          as_unicode do
+            chars = string.chars.to_a
+            print 'CHARS '
+            p chars
+            if chars.length < width
+              chars.join
+            else
+              traling_size = trailing.chars.to_a.size
+              ( chars[0, width-traling_size].join ) + trailing
+            end
+          end
+        end
+
+        if "".respond_to?(:encode)
+          def as_unicode
+            yield
+          end
+        else
+          def as_unicode
+            old, $KCODE = $KCODE, "U"
+            yield
+          ensure
+            $KCODE = old
+          end
+        end
+
+      end # Truncation
+    end # Operation
+  end # Table
+end # TTY

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

@@ -3,23 +3,25 @@
 module TTY
   class Table
     module Renderer
+
+      # Renders table without any border styles.
       class Basic
+        extend TTY::Delegatable
 
         attr_reader :padding
 
         attr_reader :indent
 
-        attr_reader :column_widths
-
-        attr_reader :column_aligns
-
-        # Return an array of table rows
+        # Table to be rendered
         #
-        # @return [Array[Array]]
+        # @return [TTY::Table]
         #
-        # @api private
-        attr_reader :rows
-        private :rows
+        # @api public
+        attr_reader :table
+
+        TABLE_DELEGATED_METHODS = [:column_widths, :alignments]
+
+        delegatable_method :table, *TABLE_DELEGATED_METHODS
 
         # Return an AlignmentSet object for processing alignments
         #
@@ -34,7 +36,6 @@ module TTY
         # @param [Hash] options
         #   :indent - Indent the first column by indent value
         #   :padding - Pad out the row cell by padding value
-        #   :col_widths - Enforce particular column width values
         #
         # @return [Table::Renderer::Basic]
         def initialize(options={})
@@ -49,10 +50,6 @@ module TTY
         def setup(options = {})
           @padding    = 0
           @indent     = options.fetch :indent, 0
-          # TODO: assert that row_size is the same as column widths & aligns
-          @column_widths = options.fetch :column_widths, []
-          @column_aligns = options.fetch :column_aligns, []
-          @alignment_set = TTY::Table::Operation::AlignmentSet.new column_aligns
           self
         end
         private :setup
@@ -68,29 +65,33 @@ module TTY
         end
 
         # @api public
-        def self.render(rows, options={})
-          new(options).render(rows)
+        def self.render(table, options={})
+          new(options).render(table)
         end
 
         # Renders table
         #
-        # @param [Enumerable] rows
-        #   the table rows
+        # @param [TTY::Table] table
+        #   the table to be rendered
         #
         # @return [String] string representation of table
         #
         # @api public
-        def render(rows, options={})
-          return if rows.empty?
-          setup(options)
-          # TODO: Decide about table orientation
-          @rows = rows
+        def render(table)
+          @table = table
+          return if table.to_a.empty?
+          # setup(options)
           body = []
-          unless rows.length.zero?
-            extract_column_widths(rows)
+          unless table.length.zero?
+            extract_column_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
-          body.join("\n")
+          body.compact.join("\n")
         end
 
         # Calcualte total table width
@@ -102,25 +103,43 @@ module TTY
           column_widths.reduce(:+)
         end
 
+        private
+
         # Calcualte maximum column widths
         #
         # @return [Array] column widths
         #
         # @api private
-        def extract_column_widths(rows)
+        def extract_column_widths
           return column_widths unless column_widths.empty?
-          # TODO: throw an error if too many columns as compared to terminal width
-          colcount = rows.max{ |a,b| a.size <=> b.size }.size
+          data = table.header ? table.to_a + [table.header] : table.to_a
+          colcount = data.max{ |a,b| a.size <=> b.size }.size
           maximas = []
           start = 0
 
           start.upto(colcount - 1) do |index|
-            maximum = rows.map { |row|
+            maximum = data.map { |row|
               row[index] ? (row[index].to_s.size) : 0
             }.max
             maximas << maximum
           end
-          @column_widths = maximas
+          table.column_widths = maximas
+        end
+
+        # Format the header
+        #
+        # @return [Array[String]]
+        #
+        # @api private
+        def render_header
+          header = table.header
+          if header
+            aligned = alignments.align_header header,
+                                              :column_widths => column_widths
+            [aligned.join]
+          else
+            []
+          end
         end
 
         # Format the rows
@@ -129,7 +148,9 @@ module TTY
         #
         # @api private
         def render_rows
-          alignment_set.align_rows rows, :column_widths => column_widths
+          aligned = alignments.align_rows table.to_a,
+                                          :column_widths => column_widths
+          aligned.map { |row| row.join }
         end
 
       end # Basic

data/lib/tty/table/renderer.rb

@@ -3,6 +3,10 @@
 module TTY
   class Table
 
+    # Determine renderer based on terminal capabilities
+    #
+    # @return [TTY::Table::Renderer]
+    #
     # @api public
     def self.renderer
       @renderer ||= if TTY.terminal.color?
@@ -45,6 +49,14 @@ module TTY
         self.renderer = RENDERER_MAPPER[:"#{options[:renderer]}"].new
       end
 
+      # Determine renderer class based on string name
+      #
+      # @param [TTY::Table::Renderer] renderer
+      #   the renderer used for displaying table
+      #
+      # @return [TTY::Table::Renderer]
+      #
+      # @api private
       def pick_renderer(renderer)
         if renderer
           RENDERER_MAPPER[renderer].new
@@ -62,6 +74,11 @@ module TTY
         @renderer ||= TTY::Table.renderer.new
       end
 
+      # Set the renderer
+      #
+      # @return [TTY::Table::Renderer]
+      #
+      # @api private
       def renderer=(renderer)
         @renderer = renderer
       end

data/lib/tty/table/validatable.rb

@@ -23,9 +23,6 @@ module TTY
         end
       end
 
-      def assert_alignments
-      end
-
       def assert_matching_widths(rows)
       end