tty 0.0.4 → 0.0.5

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

@@ -3,6 +3,8 @@
 module TTY
   class Table
     module Operation
+
+      # A class representing an alignment of cell data.
       class Alignment
         include TTY::Coercion
 

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

@@ -5,34 +5,7 @@ module TTY
     module Operation
 
       # A class which responsiblity is to align table rows and header.
-      class AlignmentSet
-        include Enumerable
-
-        # Initialize an AlignmentSet
-        #
-        # @param [Array] alignments
-        #
-        # @api public
-        def initialize(alignments = nil)
-          @alignments = alignments || []
-        end
-
-        # Iterate over each alignment in the set
-        #
-        # @example
-        #   alignment_set = AlignmentSet.new alignments
-        #   alignment_set.each { |alignment| ... }
-        #
-        # @yield [alignment]
-        #
-        # @return [self]
-        #
-        # @api public
-        def each
-          return to_enum unless block_given?
-          to_ary.each { |alignment| yield alignment }
-          self
-        end
+      class AlignmentSet < Vector
 
         # Lookup an alignment by index
         #
@@ -42,9 +15,7 @@ module TTY
         #
         # @api public
         def [](index)
-          @alignments.fetch(index) do |alignment_index|
-            :left
-          end
+          elements.fetch(index, :left)
         end
 
         # Return each alignment in an Array
@@ -56,28 +27,7 @@ module TTY
           map { |alignment| alignment }
         end
 
-        # @return [Array]
-        #
-        # @api public
-        def to_ary
-          @alignments
-        end
-
-        # @return [Array[Alignment]]
-        #
-        # @api public
-        def to_a
-          @alignments
-        end
-
-        # @return [Boolean]
-        #
-        # @api public
-        def empty?
-          to_ary.empty?
-        end
-
-        # Aligns table header
+        # Align table header
         #
         # @return [Array[String]]
         #
@@ -115,11 +65,7 @@ module TTY
             column_width = options[:column_widths][index]
             alignment = Alignment.new self[index]
 
-            if index == row.size - 1
-              line << alignment.format(cell, column_width)
-            else
-              line << alignment.format(cell, column_width, ' ')
-            end
+            line << alignment.format(cell, column_width)
           end
           line
         end

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

@@ -6,36 +6,32 @@ module TTY
 
       # A class responsible for shortening text.
       class Truncation
+        include Unicode
 
-        def truncate(string, width, options={})
-          trailing = options.fetch :trailing, '…'
-
+        # Shorten given string with traling character.
+        #
+        # @param [String] string
+        #   the string to truncate
+        # @param [Integer] width
+        #   the maximum width
+        # @param [String] trailing
+        #   the trailing character
+        #
+        # @return [String]
+        #
+        # @api public
+        def truncate(string, width, 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
+              ( 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

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

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    module Operation
+
+      # A class responsible for wrapping text.
+      class Wrapped
+        include Unicode
+
+        # Wrap a long string according to the width.
+        #
+        # @param [String] string
+        #   the string to wrap
+        # @param [Integer] width
+        #   the maximum width
+        # @param [Boolean] addnewline
+        #   add new line add the end
+        #
+        # @api public
+        def wrap(string, width)
+          as_unicode do
+            chars = string.chars.to_a
+            return string if chars.length <= width
+            idx = width
+            return chars[0, idx].join + "\n" + wrap(chars[idx..-1].join, width)
+          end
+        end
+
+      end # Wrapped
+    end # Operation
+  end # Table
+end # TTY
+

data/lib/tty/table/renderer.rb

@@ -29,13 +29,15 @@ module TTY
     module Renderer
       extend TTY::Delegatable
 
+      autoload :ASCII,   'tty/table/renderer/ascii'
       autoload :Basic,   'tty/table/renderer/basic'
       autoload :Color,   'tty/table/renderer/color'
       autoload :Unicode, 'tty/table/renderer/unicode'
 
-      RENDERER_DELEGATED_METHODS = [ :render, :extract_column_widths, :total_width]
+      RENDERER_DELEGATED_METHODS = [ :render, :total_width]
 
       RENDERER_MAPPER = {
+        :ascii   => TTY::Table::Renderer::ASCII,
         :basic   => TTY::Table::Renderer::Basic,
         :color   => TTY::Table::Renderer::Color,
         :unicode => TTY::Table::Renderer::Unicode
@@ -45,24 +47,19 @@ module TTY
       #
       # @api private
       def initialize(options={})
-        super
-        self.renderer = RENDERER_MAPPER[:"#{options[:renderer]}"].new
+        super()
       end
 
       # Determine renderer class based on string name
       #
-      # @param [TTY::Table::Renderer] renderer
-      #   the renderer used for displaying table
+      # @param [Symbol] renderer
+      #   the renderer used for displaying table out of [:basic, :color, :unicode]
       #
       # @return [TTY::Table::Renderer]
       #
       # @api private
-      def pick_renderer(renderer)
-        if renderer
-          RENDERER_MAPPER[renderer].new
-        else
-          self.renderer
-        end
+      def pick_renderer(type=nil)
+        type ? RENDERER_MAPPER[type].new : self.renderer
       end
 
       # Return the default renderer

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

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    module Renderer
+      class ASCII < Basic
+
+        def render(table, border=nil)
+          super table, TTY::Table::Border::ASCII
+        end
+
+      end # ASCII
+    end # Renderer
+  end # Table
+end # TTY

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

@@ -19,6 +19,14 @@ module TTY
         # @api public
         attr_reader :table
 
+
+        # Table border to be rendered
+        #
+        # @return [TTY::Table::Border]
+        #
+        # @api private
+        attr_reader :border_class
+
         TABLE_DELEGATED_METHODS = [:column_widths, :alignments]
 
         delegatable_method :table, *TABLE_DELEGATED_METHODS
@@ -77,13 +85,15 @@ module TTY
         # @return [String] string representation of table
         #
         # @api public
-        def render(table)
+        def render(table, border_class=Border::Null)
           @table = table
+          @border_class = border_class
+
           return if table.to_a.empty?
           # setup(options)
           body = []
           unless table.length.zero?
-            extract_column_widths
+            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
@@ -94,38 +104,8 @@ module TTY
           body.compact.join("\n")
         end
 
-        # Calcualte total table width
-        #
-        # @return [Integer]
-        #
-        # @api public
-        def total_width
-          column_widths.reduce(:+)
-        end
-
         private
 
-        # Calcualte maximum column widths
-        #
-        # @return [Array] column widths
-        #
-        # @api private
-        def extract_column_widths
-          return column_widths unless column_widths.empty?
-          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 = data.map { |row|
-              row[index] ? (row[index].to_s.size) : 0
-            }.max
-            maximas << maximum
-          end
-          table.column_widths = maximas
-        end
-
         # Format the header
         #
         # @return [Array[String]]
@@ -136,7 +116,8 @@ module TTY
           if header
             aligned = alignments.align_header header,
                                               :column_widths => column_widths
-            [aligned.join]
+            border = border_class.new(aligned)
+            [border.top_line, border.row_line].compact
           else
             []
           end
@@ -150,7 +131,13 @@ module TTY
         def render_rows
           aligned = alignments.align_rows table.to_a,
                                           :column_widths => column_widths
-          aligned.map { |row| row.join }
+
+          first_row_border = border_class.new(aligned.first)
+          aligned_border   = aligned.map { |row| border_class.new(row).row_line }
+
+          [ table.header ? first_row_border.separator : first_row_border.top_line,
+            aligned_border,
+            first_row_border.bottom_line ].compact
         end
 
       end # Basic

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

@@ -5,8 +5,8 @@ module TTY
     module Renderer
       class Unicode < Basic
 
-        def initialize
-
+        def render(table, border=nil)
+          super table, TTY::Table::Border::Unicode
         end
 
       end # Unicode

data/lib/tty/vector.rb

@@ -0,0 +1,117 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+
+  # This class represents a mathematical vector.
+  class Vector
+    include Enumerable, Equatable, Conversion
+
+    attr_reader :elements
+    protected :elements
+
+    # Utility method to instantiate a Vector
+    #
+    # @param [Array] *array
+    #
+    # @return [Vector]
+    #
+    # @api public
+    def self.[](*array)
+      new convert_to_array(array)
+    end
+
+    # Instantiate a Vector
+    #
+    # @param [Array] array
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def initialize(array=[])
+      @elements = convert_to_array(array)
+    end
+
+    # Return element at index.
+    #
+    # @param [Integer] indx
+    #   index of an element
+    #
+    # @return [Object]
+    #   a value of an element
+    #
+    # @api public
+    def [](indx)
+      elements[i]
+    end
+    alias at      []
+    alias element []
+
+    # Set a value of the element for the given index.
+    #
+    # @param [Integer] indx
+    #   an index of an element
+    #
+    # @param [Object] value
+    #   a value to be set
+    #
+    # @return [Object]
+    #
+    # @api public
+    def []=(indx, value)
+      elements[index] = value
+    end
+    alias set_element []=
+
+    # Iterate over each element in the vector
+    #
+    # @example
+    #   vec = Vector[1,2,3]
+    #   vec.each { |element| ... }
+    #
+    # @return [self]
+    #
+    # @api public
+    def each(&block)
+      return to_enum(:each) unless block_given?
+      to_ary.each(&block)
+      self
+    end
+
+    # Convert to array
+    #
+    #  @return [Array]
+    #
+    # @api public
+    def to_ary
+      elements
+    end
+
+    # Check if there are not elements.
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def empty?
+      to_ary.empty?
+    end
+
+    # Check number of elements.
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def size
+      to_ary.size
+    end
+
+    # Return the vector elements in an array.
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_a
+      elements.dup
+    end
+
+  end # Vector
+end # TTY