tty-table 0.1.0

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    module Operation
+      # A class responsible for escaping special chars in a table field
+      #
+      # @api private
+      class Escape
+
+        # Escape special characters in a table field
+        #
+        # @param [TTY::Table::Field] field
+        #
+        # @param [Integer] row
+        #   the field row index
+        #
+        # @param [Integer] col
+        #   the field column index
+        #
+        # @api public
+        def call(field, row, col)
+          field.value = field.value.to_s.gsub(/(\t|\r|\n)/) do |val|
+            val.dump.gsub('"', '')
+          end
+        end
+      end # Escape
+    end # Operation
+  end # Table
+end # TTY

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    module Operation
+      # A class responsible for transforming table field
+      #
+      # @api private
+      class Filter
+        # Initialize a Filter
+        #
+        # @api public
+        def initialize(filter)
+          @filter = filter
+        end
+
+        # Apply filer to the provided table field
+        #
+        # @param [TTY::Table::Field] field
+        #
+        # @param [Integer] row
+        #   the field row index
+        #
+        # @param [Integer] col
+        #   the field column index
+        #
+        # @api public
+        def call(field, row, col)
+          field.value = @filter.call(field.value, row, col)
+        end
+      end # Filter
+    end # Operation
+  end # Table
+end # TTY

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

@@ -0,0 +1,95 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    module Operation
+
+      # A class responsible for padding field with whitespace
+      class Padding
+
+        attr_reader :padding_top
+
+        attr_reader :padding_right
+
+        attr_reader :padding_bottom
+
+        attr_reader :padding_left
+
+        attr_reader :padding_width
+
+        attr_reader :multiline
+
+        # Initialize a Padding operation
+        #
+        # @param [TTY::Table::Padder]
+        #
+        # @api public
+        def initialize(padding, multiline)
+          @padding_top    = "\n" * padding.top
+          @padding_right  = ' '  * padding.right
+          @padding_bottom = "\n" * padding.bottom
+          @padding_left   = ' '  * padding.left
+          @padding_width  = padding.left + padding.right
+          @multiline      = multiline
+        end
+
+        # Apply padding to a field
+        #
+        # @param [TTY::Table::Field] field
+        #   the table field
+        #
+        # @param [Integer] row
+        #   the field row index
+        #
+        # @param [Integer] col
+        #   the field column index
+        #
+        # @return [TTY::Table::Field]
+        #
+        # @api public
+        def call(field, row, col)
+          text      = field.value.to_s
+
+          text = multiline ?  pad_multi_line(text) : pad_single_line(text)
+          text.insert(0, padding_top).insert(-1, padding_bottom)
+
+          field.value = text
+        end
+
+        # Apply padding to multi line text
+        #
+        # @param [String] text
+        #
+        # @return [String]
+        #
+        # @api private
+        def pad_multi_line(text)
+          text.split("\n", -1).map { |part| pad_around(part) }.join("\n")
+        end
+
+        # Apply padding to single line text
+        #
+        # @param [String] text
+        #
+        # @return [String]
+        #
+        # @api private
+        def pad_single_line(text)
+          pad_around(text.strip)
+        end
+
+        # Apply padding to left and right side of string
+        #
+        # @param [String] text
+        #
+        # @return [String]
+        #
+        # @api private
+        def pad_around(text)
+          text.insert(0, padding_left).insert(-1, padding_right)
+        end
+
+      end # Padding
+    end # Operation
+  end # Table
+end # TTY

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    module Operation
+      # A class responsible for shortening text.
+      #
+      # @api private
+      class Truncation
+
+        attr_reader :widths
+
+        # Initialize a Truncation
+        #
+        # @api public
+        def initialize(widths)
+          @widths = widths
+        end
+
+        # Apply truncation to a field
+        #
+        # @param [TTY::Table::Field] field
+        #   the table field
+        #
+        # @param [Integer] row
+        #   the field row index
+        #
+        # @param [Integer] col
+        #   the field column index
+        #
+        # @return [TTY::Table::Field]
+        #
+        # @api public
+        def call(field, row, col)
+          width       = widths[col] || field.width
+          field.value = Verse.truncate(field.value, width)
+        end
+      end # Truncation
+    end # Operation
+  end # Table
+end # TTY

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    module Operation
+      # A class responsible for wrapping text.
+      #
+      # @api private
+      class Wrapped
+        attr_reader :widths
+
+        attr_reader :padding
+
+        # Initialize a Wrapped
+        #
+        # @api public
+        def initialize(widths, padding)
+          @widths  = widths
+          @padding = padding.padding
+        end
+
+        # Apply wrapping to a field
+        #
+        # @param [TTY::Table::Field] field
+        #   the table field
+        #
+        # @param [Integer] row
+        #   the field row index
+        #
+        # @param [Integer] col
+        #   the field column index
+        #
+        # @return [Array[String]]
+        #
+        # @api public
+        def call(field, row, col)
+          width = widths[col] || field.width
+          field.value = Verse.wrap(field.value, width, padding: padding)
+        end
+      end # Wrapped
+    end # Operation
+  end # Table
+end # TTY

data/lib/tty/table/operations.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class holding table field operations.
+    #
+    # @api private
+    class Operations
+      # The table
+      #
+      # @api private
+      attr_reader :table
+      private :table
+
+      # Available operations
+      #
+      # @return [Hash]
+      #
+      # @api public
+      attr_reader :operations
+
+      # Initialize Operations
+      #
+      # @param [TTY::Table] table
+      #   the table to perform operations on
+      #
+      # @return [Object]
+      #
+      # @api public
+      def initialize(table)
+        @table      = table
+        @operations = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      # Add operation
+      #
+      # @param [Symbol] operation_type
+      #   the operation type
+      # @param [Object] object
+      #   the callable object
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def add(operation_type, object)
+        operations[operation_type] << object
+      end
+
+      # Apply operations to a table row
+      #
+      # @param [Array[Symbol]] types
+      #  the operation types
+      # @param [Hash] options
+      #   the options for the row
+      #
+      # @return [TTY::Table]
+      #
+      # @api public
+      def run_operations(*args)
+        operation_types = args
+        table.each_with_index do |val, row, col|
+          operation_types.each do |type|
+            operations[type].each { |op| op.call(val, row, col) }
+          end
+        end
+      end
+    end # Operations
+  end # Table
+end # TTY

data/lib/tty/table/options.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require 'delegate'
+
+module TTY
+  class Table
+
+    # Structure for holding table options with indifferent access
+    class Options < DelegateClass(Hash)
+
+      def initialize(hash={}, &block)
+        super(&block)
+
+        hash.each do |key, value|
+          self[convert_key(key)] = valu
+        end
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+
+    end # Options
+
+  end # Table
+end # TTY

data/lib/tty/table/orientation/horizontal.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class representing table orientation
+    class Orientation
+      # A class responsible for horizontal table transformation
+      class Horizontal < Orientation
+        # Rotate table horizontally
+        #
+        # @param [Table] table
+        #
+        # @return [nil]
+        #
+        # @api public
+        def transform(table)
+          table.rotate_horizontal
+        end
+
+        # Slice vertical table data into horizontal
+        #
+        # @param [Table] table
+        #
+        # @api public
+        def slice(table)
+          head, body, array_h, array_b = 4.times.map { [] }
+          index         = 0
+          first_column  = 0
+          second_column = 1
+
+          (0...table.original_columns * table.original_rows).each do |col_index|
+            row      = table.rows[index]
+            array_h += [row[first_column]]
+            array_b += [row[second_column]]
+
+            if col_index % table.original_columns == 2
+              head << array_h
+              body << array_b
+              array_h, array_b = [], []
+            end
+            index += 1
+          end
+          [head, body]
+        end
+      end # Horizontal
+    end # Orientation
+  end # Table
+end # TTY

data/lib/tty/table/orientation/vertical.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class representing table orientation
+    class Orientation
+      # A class responsible for vertical table transformation
+      class Vertical < Orientation
+        # Rotate table vertically
+        #
+        # @param [Table] table
+        #
+        # @return [nil]
+        #
+        # @api public
+        def transform(table)
+          table.rotate_vertical
+        end
+
+        # Slice horizontal table data into vertical
+        #
+        # @param [Table] table
+        #
+        # @api public
+        def slice(table)
+          header   = table.header
+          row_size = table.row_size
+
+          head = header ? header : (0..row_size).map { |n| (n + 1).to_s }
+
+          (0...row_size).reduce([]) do |array, index|
+            array + head.zip(table.rows[index]).map { |row| table.to_row(row) }
+          end
+        end
+      end # Vertical
+    end # Orientation
+  end # Table
+end # TTY

data/lib/tty/table/orientation.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class representing table orientation
+    #
+    # @api private
+    class Orientation
+      # The name for the orientation
+      #
+      # @api public
+      attr_reader :name
+
+      # Initialize an Orientation
+      #
+      # @api public
+      def initialize(name)
+        @name = name
+      end
+
+      # Coerce the name argument into an orientation
+      #
+      # @param [Symbol] name
+      #
+      # @api public
+      def self.coerce(name)
+        case name.to_s
+        when /h|horiz(ontal)?/i
+          Horizontal.new :horizontal
+        when /v|ert(ical)?/i
+          Vertical.new :vertical
+        else
+          fail InvalidOrientationError,
+               'orientation must be one of :horizontal, :vertical'
+        end
+      end
+
+      # Check if orientation is vertical
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def vertical?
+        name == :vertical
+      end
+
+      # Check if orientation is horizontal
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def horizontal?
+        name == :horizontal
+      end
+    end # Orientation
+  end # Table
+end # TTY

data/lib/tty/table/padder.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    # A class responsible for processing table field padding
+    #
+    # Used internally by {Table::Renderer}
+    #
+    # @api private
+    class Padder
+      include Equatable
+
+      # Padding for the table cells
+      #
+      # @return [Array[Integer]]
+      attr_reader :padding
+
+      # Initialize a Padder
+      #
+      # @api public
+      def initialize(padding)
+        @padding = padding
+      end
+
+      # Parse padding options
+      #
+      # Turn possible values into 4 element array
+      #
+      # @example
+      #   padder = TTY::Table::Padder.parse(5)
+      #   padder.padding # => [5, 5, 5, 5]
+      #
+      # @param [Object] value
+      #
+      # @return [TTY::Padder]
+      #   the new padder with padding values
+      #
+      # @api public
+      def self.parse(value = nil)
+        return value if value.is_a?(self)
+
+        new(convert_to_ary(value))
+      end
+
+      # Convert value to 4 element array
+      #
+      # @return [Array[Integer]]
+      #   the 4 element padding array
+      #
+      # @api private
+      def self.convert_to_ary(value)
+        if value.class <= Numeric
+          [value, value, value, value]
+        elsif value.nil?
+          []
+        elsif value.size == 2
+          [value[0], value[1], value[0], value[1]]
+        elsif value.size == 4
+          value
+        else
+          fail ArgumentError, 'Wrong :padding parameter, must be an array'
+        end
+      end
+
+      # Top padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def top
+        @padding[0].to_i
+      end
+
+      # Set top padding
+      #
+      # @param [Integer] val
+      #
+      # @return [nil]
+      #
+      # @api public
+      def top=(value)
+        @padding[0] = value
+      end
+
+      # Right padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def right
+        @padding[1].to_i
+      end
+
+      # Set right padding
+      #
+      # @param [Integer] val
+      #
+      # @api public
+      def right=(value)
+        @padding[1] = value
+      end
+
+      # Bottom padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def bottom
+        @padding[2].to_i
+      end
+
+      # Set bottom padding
+      #
+      # @param [Integer] value
+      #
+      # @return [nil]
+      #
+      # @api public
+      def bottom=(value)
+        @padding[2] = value
+      end
+
+      # Left padding
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def left
+        @padding[3].to_i
+      end
+
+      # Set left padding
+      #
+      # @param [Integer] value
+      #
+      # @return [nil]
+      #
+      # @api public
+      def left=(value)
+        @padding[3] = value
+      end
+
+      # Check if padding is set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        padding.empty?
+      end
+
+      # Check if vertical padding is applied
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def vertical?
+        top.nonzero? || bottom.nonzero?
+      end
+
+      # Check if horizontal padding is applied
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def horizontal?
+        left.nonzero? || right.nonzero?
+      end
+
+      # String represenation of this padder with padding values
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        inspect
+      end
+    end # Padder
+  end # Table
+end # TTY

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module TTY
+  class Table
+    class Renderer
+      class ASCII < Basic
+        # 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
+end # TTY