tty 0.0.11 → 0.1.0

data/lib/tty/table/renderer.rb

@@ -1,9 +1,12 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 module TTY
   class Table
-
     # A class responsible for rendering tabular data
+    #
+    # Used internally by {Table} to render table content out.
+    #
+    # @api private
     class Renderer
       autoload :ASCII,   'tty/table/renderer/ascii'
       autoload :Basic,   'tty/table/renderer/basic'
@@ -11,22 +14,25 @@ module TTY
       autoload :Unicode, 'tty/table/renderer/unicode'
 
       RENDERER_MAPPER = {
-        :ascii   => TTY::Table::Renderer::ASCII,
-        :basic   => TTY::Table::Renderer::Basic,
-        :color   => TTY::Table::Renderer::Color,
-        :unicode => TTY::Table::Renderer::Unicode
+        ascii:   TTY::Table::Renderer::ASCII,
+        basic:   TTY::Table::Renderer::Basic,
+        color:   TTY::Table::Renderer::Color,
+        unicode: TTY::Table::Renderer::Unicode
       }
 
-      # Select renderer class based on string name
+      # Select renderer class based on string name.
+      #
+      # The possible values for renderer are
+      # [:basic, :ascii, :unicode, :color]
       #
       # @param [Symbol] renderer
-      #   the renderer used for displaying table out of [:basic, :ascii, :unicode, :color]
+      #   the renderer used for displaying table
       #
       # @return [TTY::Table::Renderer]
       #
       # @api private
       def self.select(type)
-         RENDERER_MAPPER[type || :basic]
+        RENDERER_MAPPER[type || :basic]
       end
 
       # Raises an error if provided border class is of wrong type or has invalid
@@ -42,10 +48,12 @@ module TTY
       def self.assert_border_class(border_class)
         return unless border_class
         unless border_class <= TTY::Table::Border
-          raise TypeError, "#{border_class} should inherit from TTY::Table::Border"
+          fail TypeError,
+               "#{border_class} should inherit from TTY::Table::Border"
         end
         unless border_class.characters
-          raise NoImplementationError, "#{border_class} should implement def_border"
+          fail NoImplementationError,
+               "#{border_class} should implement def_border"
         end
       end
 
@@ -64,7 +72,7 @@ module TTY
       #   raise if the klass does not implement def_border
       #
       # @api public
-      def self.render_with(border_class, table, options={}, &block)
+      def self.render_with(border_class, table, options = {}, &block)
         assert_border_class(border_class)
         options[:border_class] = border_class if border_class
         render(table, options, &block)
@@ -83,12 +91,11 @@ module TTY
       # @return [String]
       #
       # @api public
-      def self.render(table, options={}, &block)
+      def self.render(table, options = {}, &block)
         renderer = select(options[:renderer]).new(table, options)
         yield renderer if block_given?
         renderer.render
       end
     end # Renderer
-
   end # Table
 end # TTY

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

@@ -1,14 +1,15 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 module TTY
   class Table
     class Renderer
       class ASCII < Basic
-
-        def initialize(table, options={})
-          super(table, options.merge(:border_class => TTY::Table::Border::ASCII))
+        # Create ASCII renderer
+        #
+        # @api private
+        def initialize(table, options = {})
+          super(table, options.merge(border_class: TTY::Table::Border::ASCII))
         end
-
       end # ASCII
     end # Renderer
   end # Table

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

@@ -1,12 +1,13 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'tty/table/validatable'
 
 module TTY
   class Table
     class Renderer
-
       # Renders table without any border styles.
+      #
+      # @api private
       class Basic
         include TTY::Table::Validatable
 
@@ -30,7 +31,7 @@ module TTY
         # @return [Array]
         #
         # @api public
-        attr_accessor :column_widths
+        attr_writer :column_widths
 
         # The table column alignments
         #
@@ -71,9 +72,9 @@ module TTY
         # @api public
         attr_accessor :width
 
-        # The table resizing behaviour. If true the algorithm will automatically
-        # expand or shrink table to fit the terminal width or specified width.
-        # By default its false.
+        # The table resizing behaviour. If true the algorithm will
+        # automatically expand or shrink table to fit the terminal
+        # width or specified width. By default its false.
         #
         # @return [Integer]
         #
@@ -103,24 +104,23 @@ module TTY
         #
         # @api private
         def initialize(table, options = {})
-          @table         = table || (raise ArgumentRequired, "Expected TTY::Table instance, got #{table.inspect}")
+          @table         = assert_table_type(table)
           @multiline     = options.fetch(:multiline) { false }
           @operations    = TTY::Table::Operations.new(table)
-          if not multiline
-            @operations.add(:escape, Operation::Escape.new)
-          end
+          @operations.add(:escape, Operation::Escape.new)
           @border        = TTY::Table::BorderOptions.from(options.delete(:border))
           @column_widths = options.fetch(:column_widths, nil)
           @column_aligns = Array(options.delete(:column_aligns)).map(&:to_sym)
-          @filter        = options.fetch(:filter) { proc { |val, row, col| val } }
+          @filter        = options.fetch(:filter) { proc { |val, _| val } }
           @width         = options.fetch(:width) { TTY.terminal.width }
           @border_class  = options.fetch(:border_class) { Border::Null }
           @indent        = options.fetch(:indent) { 0 }
           @resize        = options.fetch(:resize) { false }
-          @padding       = TTY::Table::Padder.parse(options.fetch(:padding) { nil })
+          @padding       = TTY::Table::Padder.parse(options[:padding])
         end
 
-        # Parses supplied column widths, if not present calculates natural widths
+        # Parses supplied column widths, if not present
+        # calculates natural widths.
         #
         # @return [Array[Integer]]
         #
@@ -131,9 +131,10 @@ module TTY
 
         # Store border characters, style and separator for the table rendering
         #
-        # @param [Hash, BorderOptions] options
+        # @param [Hash, Table::BorderOptions] options
         #
-        # @yield [] block representing border options
+        # @yield [Table::BorderOptions]
+        #   block representing border options
         #
         # @api public
         def border(options=(not_set=true), &block)
@@ -222,10 +223,9 @@ module TTY
           data_border      = border_class.new(column_widths, border)
           header           = render_header(first_row, data_border)
           rows_with_border = render_rows(data_border)
+          bottom_line      = data_border.bottom_line
 
-          if bottom_line = data_border.bottom_line
-            insert_indent(bottom_line)
-          end
+          insert_indent(bottom_line) if bottom_line
 
           [header, rows_with_border, bottom_line].compact
         end
@@ -288,7 +288,6 @@ module TTY
             insert_indent(row_line)
           end
         end
-
       end # Basic
     end # Renderer
   end # Table

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

@@ -1,14 +1,20 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 module TTY
   class Table
     class Renderer
+      # Unicode representation of table renderer
+      #
+      # @api private
       class Unicode < Basic
-
-        def initialize(table, options={})
-          super(table, options.merge(:border_class => TTY::Table::Border::Unicode))
+        # Create Unicode renderer
+        #
+        # @param [Table] table
+        #
+        # @api private
+        def initialize(table, options = {})
+          super(table, options.merge(border_class: TTY::Table::Border::Unicode))
         end
-
       end # Unicode
     end # Renderer
   end # Table

data/lib/tty/table/row.rb

@@ -1,27 +1,29 @@
-# -*- encoding: utf-8 -*-
+# 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)
+    def to_row(row, header = nil)
       Row.new(row, header)
     end
 
     # A class that represents a row in a table.
+    #
+    # Used internally by {Table} to store row represenation by converting
+    # {Array} into {Row} instance.
+    #
+    # @api private
     class Row < Vector
       include Equatable
       extend Forwardable
 
-      def_delegators :to_ary, :join
-
-      # The row attributes
+      # The row attributes that describe each element
       #
       # @return [Array]
       #
@@ -35,8 +37,13 @@ module TTY
       # @api private
       attr_reader :data
 
+      # The row fields
+      #
+      # @api public
       attr_reader :fields
 
+      def_delegators :to_ary, :join
+
       # Initialize a Row
       #
       # @example
@@ -57,24 +64,34 @@ module TTY
       # @return [undefined]
       #
       # @api public
-      def initialize(data, header=nil)
+      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)]
+          @fields     = coerce_to_fields(data)
         when Hash
-          @data = data.dup
-          @fields = @data.values.inject([]){|arr, datum| arr << to_field(datum) }
+          @data       = data.dup
+          @fields     = coerce_to_fields(@data.values)
           @attributes = (header || data.keys).to_a
-          @data = Hash[@attributes.zip(fields)]
         end
+        @data = Hash[@attributes.zip(fields)]
+      end
+
+      # Coerces values to field instances
+      #
+      # @param [Array[Object]] values
+      #
+      # @return [Array[TTY::Table::Field]]
+      #
+      # @api public
+      def coerce_to_fields(values)
+        values.reduce([]) { |acc, el| acc << to_field(el) }
       end
 
       # Instantiates a new field
       #
       # @api public
-      def to_field(options=nil)
+      def to_field(options = nil)
         Field.new(options)
       end
 
@@ -93,7 +110,7 @@ module TTY
           data[attributes[attribute]].value
         else
           data.fetch(attribute) do |name|
-            raise UnknownAttributeError, "the attribute #{name} is unkown"
+            fail UnknownAttributeError, "the attribute #{name} is unkown"
           end.value
         end
       end
@@ -114,10 +131,10 @@ module TTY
       def []=(attribute, value)
         case attribute
         when Integer
-          self.data[attributes[attribute]] = to_field(value)
+          data[attributes[attribute]] = to_field(value)
         else
-          self.data[attribute] = to_field(value)
-          self.attributes << attribute unless attributes.include?(attribute)
+          data[attribute] = to_field(value)
+          attributes << attribute unless attributes.include?(attribute)
         end
       end
 
@@ -137,7 +154,7 @@ module TTY
       #
       # @api public
       def height
-        fields.map { |field| field.height }.max
+        fields.map(&:height).max
       end
 
       # Convert the Row into Array
@@ -159,7 +176,7 @@ module TTY
       # @api public
       def to_hash
         hash = data.dup
-        hash.update(hash) { |key, val| val.value if val }
+        hash.update(hash) { |_, val| val.value if val }
       end
 
       # Check if this row is equivalent to another row
@@ -196,6 +213,5 @@ module TTY
         "#<#{self.class.name} fields=#{to_a}>"
       end
     end # Row
-
   end # Table
 end # TTY

data/lib/tty/table/transformation.rb

@@ -1,11 +1,13 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 module TTY
   class Table
-
     # A class for transforming table values
+    #
+    # Used internally by {Table}
+    #
+    # @api private
     class Transformation
-
       # Extract the header and row tuples from the value
       #
       # @param [Array] args
@@ -29,10 +31,9 @@ module TTY
       # @api public
       def self.group_header_and_rows(value)
         header = value.map(&:keys).flatten.uniq
-        rows   = value.inject([]) { |arr, el| arr + el.values }
+        rows   = value.reduce([]) { |arr, el| arr + el.values }
         [header, rows]
       end
-
     end # Transformation
   end # Table
 end # TTY

data/lib/tty/table/validatable.rb

@@ -1,11 +1,13 @@
-# -*- encoding: utf-8 -*-
+# 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
-
-      MIN_CELL_WIDTH = 3.freeze
-
       # Check if table rows are the equal size
       #
       # @raise [DimensionMismatchError]
@@ -17,33 +19,46 @@ module TTY
       def assert_row_sizes(rows)
         size = (rows[0] || []).size
         rows.each do |row|
-          if not row.size == size
-            raise TTY::Table::DimensionMismatchError, "row size differs (#{row.size} should be #{size})"
-          end
+          next if row.size == size
+          fail TTY::Table::DimensionMismatchError,
+               "row size differs (#{row.size} should be #{size})"
         end
       end
 
-      def assert_matching_widths(rows)
+      # 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_string_values(rows)
-      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)
-        if (header = options[:header]) &&
-           (!header.kind_of?(Array) || header.empty?)
-          raise InvalidArgument, ":header must be a non-empty array"
+        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 = options[:rows]) &&
-          !(rows.kind_of?(Array) || rows.kind_of?(Hash))
-          raise InvalidArgument, ":rows must be a non-empty array or hash"
+        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