tty 0.1.2 → 0.1.3

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

@@ -1,294 +0,0 @@
-# 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
-
-        # Table to be rendered
-        #
-        # @return [TTY::Table]
-        #
-        # @api public
-        attr_reader :table
-        # private :table
-
-        # Table border to be rendered
-        #
-        # @return [TTY::Table::Border]
-        #
-        # @api private
-        attr_accessor :border_class
-
-        # The table enforced column widths
-        #
-        # @return [Array]
-        #
-        # @api public
-        attr_writer :column_widths
-
-        # The table column alignments
-        #
-        # @return [Array]
-        #
-        # @api private
-        attr_accessor :column_aligns
-
-        # The table operations applied to rows
-        #
-        # @api public
-        attr_reader :operations
-
-        # A callable object used for formatting field content
-        #
-        # @api public
-        attr_accessor :filter
-
-        # The table column span behaviour. When true the column's line breaks
-        # cause the column to span multiple rows. By default set to false.
-        #
-        # @return [Boolean]
-        #
-        # @api public
-        attr_accessor :multiline
-
-        # The table indentation value
-        #
-        # @return [Integer]
-        #
-        # @api public
-        attr_accessor :indent
-
-        # The table totabl width
-        #
-        # @return [Integer]
-        #
-        # @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.
-        #
-        # @return [Integer]
-        #
-        # @api public
-        attr_accessor :resize
-
-        # The table padding settings
-        #
-        # @return [TTY::Table::Padder]
-        #
-        # @api public
-        attr_reader :padding
-
-        # Initialize a Renderer
-        #
-        # @param [Hash] options
-        # @option options [String] :column_aligns
-        #   used to format table individual column alignment
-        # @option options [String] :column_widths
-        #   used to format table individula column width
-        # @option options [Integer] :indent
-        #   indent the first column by indent value
-        # @option options [Integer,Array] :padding
-        #   add padding to table fields
-        #
-        # @return [TTY::Table::Renderer::Basic]
-        #
-        # @api private
-        def initialize(table, options = {})
-          @table         = assert_table_type(table)
-          @multiline     = options.fetch(:multiline) { false }
-          @operations    = TTY::Table::Operations.new(table)
-          @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, _| val } }
-          @width         = options.fetch(:width) { TTY::Screen.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[:padding])
-        end
-
-        # Parses supplied column widths, if not present
-        # calculates natural widths.
-        #
-        # @return [Array[Integer]]
-        #
-        # @api public
-        def column_widths
-          @column_widths = ColumnSet.widths_from(table, @column_widths)
-        end
-
-        # Store border characters, style and separator for the table rendering
-        #
-        # @param [Hash, Table::BorderOptions] options
-        #
-        # @yield [Table::BorderOptions]
-        #   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
-
-        # Initialize and add operations
-        #
-        # @api private
-        def add_operations
-          operations.add(:alignment,  Operation::AlignmentSet.new(column_aligns,
-                                                                  column_widths))
-          operations.add(:filter,     Operation::Filter.new(filter))
-          operations.add(:truncation, Operation::Truncation.new(column_widths))
-          operations.add(:wrapping,   Operation::Wrapped.new(column_widths, padding))
-          operations.add(:padding,    Operation::Padding.new(padding, multiline))
-        end
-
-        # Initializes indentation
-        #
-        # @return [TTY::Table::Indentation]
-        #
-        # @api private
-        def indentation
-          @indentation ||= TTY::Table::Indentation.new(self)
-        end
-
-        # Delegate indentation insertion
-        #
-        # @api public
-        def insert_indent(line)
-          indentation.insert_indent(line)
-        end
-
-        # Return column contraints
-        #
-        # @api private
-        def columns_constraints
-          TTY::Table::Columns.new(self)
-        end
-
-        # Sets the output padding,
-        #
-        # @param [Integer] value
-        #   the amount of padding, not allowed to be zero
-        #
-        # @api public
-        def padding=(value)
-          @padding = TTY::Table::Padder.parse(value)
-        end
-
-        # Renders table
-        #
-        # @return [String] string representation of table
-        #
-        # @api public
-        def render
-          return if table.empty?
-
-          operations.run_operations(:escape) unless multiline
-          columns_constraints.enforce
-          add_operations
-          ops = [:alignment]
-          ops << :padding unless padding.empty?
-          multiline ? ops << :wrapping : ops << :truncation
-          ops << :filter
-          operations.run_operations(*ops)
-
-          render_data.compact.join("\n")
-        end
-
-        private
-
-        # Render table data
-        #
-        # @api private
-        def render_data
-          first_row        = table.first
-          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
-
-          insert_indent(bottom_line) if bottom_line
-
-          [header, rows_with_border, bottom_line].compact
-        end
-
-        # Format the header if present
-        #
-        # @param [TTY::Table::Row, TTY::Table::Header] row
-        #   the first row in the table
-        #
-        # @param [TTY::Table::Border] data_boder
-        #   the border for this table
-        #
-        # @return [String]
-        #
-        # @api private
-        def render_header(row, data_border)
-          top_line = data_border.top_line
-          if row.is_a?(TTY::Table::Header)
-            header = [top_line, data_border.row_line(row), data_border.separator]
-            insert_indent(header.compact)
-          else
-            top_line
-          end
-        end
-
-        # Format the rows
-        #
-        # @param [TTY::Table::Border] data_boder
-        #   the border for this table
-        #
-        # @return [Arrays[String]]
-        #
-        # @api private
-        def render_rows(data_border)
-          rows = table.rows
-          size = rows.size
-          rows.each_with_index.map do |row, index|
-            render_row(row, data_border, size != (index += 1))
-          end
-        end
-
-        # Format a single row with border
-        #
-        # @param [Array] row
-        #   a row to decorate
-        #
-        # @param [TTY::Table::Border] data_boder
-        #   the border for this table
-        #
-        # @param [Boolean] is_last_row
-        #
-        # @api private
-        def render_row(row, data_border, is_last_row)
-          separator = data_border.separator
-          row_line  = data_border.row_line(row)
-
-          if (border.separator == TTY::Table::Border::EACH_ROW) && is_last_row
-            insert_indent([row_line, separator])
-          else
-            insert_indent(row_line)
-          end
-        end
-      end # Basic
-    end # Renderer
-  end # Table
-end # TTY

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

@@ -1,12 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module TTY
-  class Table
-    class Renderer
-      class Color < Basic
-
-
-      end # Color
-    end # Renderer
-  end # Table
-end # TTY

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-module TTY
-  class Table
-    class Renderer
-      # Unicode representation of table renderer
-      #
-      # @api private
-      class Unicode < Basic
-        # 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
-end # TTY

data/lib/tty/table/renderer.rb

@@ -1,101 +0,0 @@
-# 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'
-      autoload :Color,   'tty/table/renderer/color'
-      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
-      }
-
-      # 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
-      #
-      # @return [TTY::Table::Renderer]
-      #
-      # @api private
-      def self.select(type)
-        RENDERER_MAPPER[type || :basic]
-      end
-
-      # Raises an error if provided border class is of wrong type or has invalid
-      # implementation
-      #
-      # @raise [TypeError]
-      #   raised when providing wrong class for border
-      #
-      # @raise [NoImplementationError]
-      #   raised when border class does not implement core methods
-      #
-      # @api public
-      def self.assert_border_class(border_class)
-        return unless border_class
-        unless border_class <= TTY::Table::Border
-          fail TypeError,
-               "#{border_class} should inherit from TTY::Table::Border"
-        end
-        unless border_class.characters
-          fail NoImplementationError,
-               "#{border_class} should implement def_border"
-        end
-      end
-
-      # Add custom border for the renderer
-      #
-      # @param [TTY::Table::Border] border_class
-      #
-      # @param [TTY::Table] table
-      #
-      # @param [Hash] options
-      #
-      # @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 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)
-      end
-
-      # Render a given table and return the string representation.
-      #
-      # @param [TTY::Table] table
-      #   the table to be rendered
-      #
-      # @param [Hash] options
-      #   the options to render the table with
-      # @option options [String] :renderer
-      #   used to format table output
-      #
-      # @return [String]
-      #
-      # @api public
-      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/row.rb

@@ -1,217 +0,0 @@
-# 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.
-    #
-    # Used internally by {Table} to store row represenation by converting
-    # {Array} into {Row} instance.
-    #
-    # @api private
-    class Row < Vector
-      include Equatable
-      extend Forwardable
-
-      # The row attributes that describe each element
-      #
-      # @return [Array]
-      #
-      # @api private
-      attr_reader :attributes
-
-      # The row data
-      #
-      # @return [Hash]
-      #
-      # @api private
-      attr_reader :data
-
-      # The row fields
-      #
-      # @api public
-      attr_reader :fields
-
-      def_delegators :to_ary, :join
-
-      # 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     = coerce_to_fields(data)
-        when Hash
-          @data       = data.dup
-          @fields     = coerce_to_fields(@data.values)
-          @attributes = (header || data.keys).to_a
-        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)
-        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|
-            fail UnknownAttributeError, "the attribute #{name} is unkown"
-          end.value
-        end
-      end
-
-      # Lookup attribute without evaluation
-      #
-      # @api public
-      def call(attribute)
-        data[attributes[attribute]]
-      end
-
-      # Set value at index
-      #
-      # @example
-      #   row[attribute] = value
-      #
-      # @api public
-      def []=(attribute, value)
-        case attribute
-        when Integer
-          data[attributes[attribute]] = to_field(value)
-        else
-          data[attribute] = to_field(value)
-          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
-
-      # Find maximum row height
-      #
-      # @return [Integer]
-      #
-      # @api public
-      def height
-        fields.map(&:height).max
-      end
-
-      # 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) { |_, 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
-
-      # Map field values
-      #
-      # @api public
-      def map!(&block)
-        data.values_at(*attributes).each do |field|
-          field.value = block.call(field)
-        end
-      end
-
-      # String representation of a row with its fields
-      #
-      # @api public
-      def inspect
-        "#<#{self.class.name} fields=#{to_a}>"
-      end
-    end # Row
-  end # Table
-end # TTY

data/lib/tty/table/transformation.rb

@@ -1,39 +0,0 @@
-# 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
-      #
-      # @return [Object]
-      #
-      # @api public
-      def self.extract_tuples(args)
-        rows   = args.pop
-        header = args.size.zero? ? nil : args.first
-        if rows.first.is_a?(Hash)
-          header, rows = group_header_and_rows(rows)
-        end
-        { header: header, rows: rows }
-      end
-
-      # Group hash keys into header and values into rows
-      #
-      # @params [Hash] value
-      #
-      # @api public
-      def self.group_header_and_rows(value)
-        header = value.map(&:keys).flatten.uniq
-        rows   = value.reduce([]) { |arr, el| arr + el.values }
-        [header, rows]
-      end
-    end # Transformation
-  end # Table
-end # TTY