tabulo 2.6.0

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake-version"
+require "yard"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+RakeVersion::Tasks.new do |v|
+  v.copy "lib/tabulo/version.rb"
+  v.copy "README.md", all: true
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.options = ["--markup-provider=redcarpet", "--markup=markdown"]
+end

data/VERSION

@@ -0,0 +1 @@
+2.6.0

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-dinky

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tabulo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tabulo.rb

@@ -0,0 +1,10 @@
+require "tabulo/deprecation"
+require "tabulo/exceptions"
+require "tabulo/util"
+require "tabulo/table"
+require "tabulo/version"
+require "tabulo/row"
+require "tabulo/cell_data"
+require "tabulo/cell"
+require "tabulo/column"
+require "tabulo/border"

data/lib/tabulo/border.rb

@@ -0,0 +1,164 @@
+module Tabulo
+
+  # @!visibility private
+  class Border
+
+    Style = Struct.new(
+        :corner_top_left, :corner_top_right, :corner_bottom_right, :corner_bottom_left,
+        :edge_top, :edge_right, :edge_bottom, :edge_left,
+        :tee_top, :tee_right, :tee_bottom, :tee_left,
+        :divider_vertical, :divider_horizontal, :intersection)
+
+    STYLES = {
+      ascii:
+        Style.new(
+          "+", "+", "+", "+",
+          "-", "|", "-", "|",
+          "+", "+", "+", "+",
+          "|", "-", "+",
+        ),
+      classic:
+        Style.new(
+          "+", "+", "", "",
+          "-", "|", "", "|",
+          "+", "+", "", "+",
+          "|", "-", "+",
+        ),
+      reduced_ascii:
+        Style.new(
+          "", "", "", "",
+          "-", "", "-", "",
+          " ", "", " ", "",
+          " ", "-", " ",
+        ),
+      reduced_modern:
+        Style.new(
+          "", "", "", "",
+          "─", "", "─", "",
+          " ", "", " ", "",
+          " ", "─", " ",
+        ),
+      markdown:
+        Style.new(
+          "", "", "", "",
+          "", "|", "", "|",
+          "", "|", "", "|",
+          "|", "-", "|",
+        ),
+      modern:
+        Style.new(
+          "┌", "┐", "┘", "└",
+          "─", "│", "─", "│",
+          "┬", "┤", "┴", "├",
+          "│", "─", "┼",
+        ),
+      blank:
+        Style.new(
+          "", "", "", "",
+          "", "", "", "",
+          "", "", "", "",
+          "", "", "",
+        ),
+    }
+
+    # @!visibility private
+    def self.from(initializer, styler = nil)
+      new(**options(initializer).merge(styler: styler))
+    end
+
+    # @!visibility private
+    def horizontal_rule(column_widths, position = :bottom)
+      left, center, right, segment =
+        case position
+        when :title_top
+          [@corner_top_left, @edge_top, @corner_top_right, @edge_top]
+        when :title_bottom
+          [@tee_left, @tee_top, @tee_right, @edge_top]
+        when :top
+          [@corner_top_left, @tee_top, @corner_top_right, @edge_top]
+        when :middle
+          [@tee_left, @intersection, @tee_right, @divider_horizontal]
+        when :bottom
+          [@corner_bottom_left, @tee_bottom, @corner_bottom_right, @edge_bottom]
+        end
+      segments = column_widths.map { |width| segment * width }
+
+      # Prevent weird bottom edge of title if segments empty but right/left not empty, as in
+      # Markdown border.
+      left = right = "" if segments.all?(&:empty?)
+
+      style("#{left}#{segments.join(center)}#{right}")
+    end
+
+    # @!visibility private
+    def join_cell_contents(cells)
+      styled_divider_vertical = style(@divider_vertical)
+      styled_edge_left = style(@edge_left)
+      styled_edge_right = style(@edge_right)
+      styled_edge_left + cells.join(styled_divider_vertical) + styled_edge_right
+    end
+
+    private
+
+    def self.options(kind)
+      opts = STYLES[kind]
+      return opts.to_h if opts
+      raise InvalidBorderError
+    end
+
+    # @param [nil, #to_proc] styler (nil) A lambda or other callable object taking
+    #   a single parameter, representing a section of the table's borders (which for this purpose
+    #   include any horizontal and vertical lines inside the table), and returning a string.
+    #   If passed <tt>nil</tt>, then no additional styling will be applied to borders. If passed a
+    #   callable, then that callable will be called for each border section, with the
+    #   resulting string rendered in place of that border. The extra width of the string returned by the
+    #   {styler} is not taken into consideration by the internal table rendering calculations
+    #   Thus it can be used to apply ANSI escape codes to border characters, to colour the borders
+    #   for example, without breaking the table formatting.
+    # @return [Border] a new {Border}
+    def initialize(
+      corner_top_left: "",
+      corner_top_right: "",
+      corner_bottom_right: "",
+      corner_bottom_left: "",
+      edge_top: "",
+      edge_right: "",
+      edge_bottom: "",
+      edge_left: "",
+      tee_top: "",
+      tee_right: "",
+      tee_bottom: "",
+      tee_left: "",
+      divider_vertical: "",
+      divider_horizontal: "",
+      intersection: "",
+      styler: nil)
+
+      @corner_top_left = corner_top_left
+      @corner_top_right = corner_top_right
+      @corner_bottom_right = corner_bottom_right
+      @corner_bottom_left = corner_bottom_left
+
+      @edge_top = edge_top
+      @edge_right = edge_right
+      @edge_bottom = edge_bottom
+      @edge_left = edge_left
+
+      @tee_top = tee_top
+      @tee_right = tee_right
+      @tee_bottom = tee_bottom
+      @tee_left = tee_left
+
+      @divider_vertical = divider_vertical
+      @divider_horizontal = divider_horizontal
+
+      @intersection = intersection
+
+      @styler = styler
+    end
+
+    def style(s)
+      (@styler && !s.empty?) ? @styler.call(s) : s
+    end
+  end
+end

data/lib/tabulo/cell.rb

@@ -0,0 +1,155 @@
+require "unicode/display_width"
+
+module Tabulo
+
+  # Represents a single cell within the body of a {Table}.
+  class Cell
+
+    # @return the underlying value for this Cell
+    attr_reader :value
+
+    # @!visibility private
+    def initialize(
+      alignment:,
+      cell_data:,
+      formatter:,
+      left_padding:,
+      padding_character:,
+      right_padding:,
+      styler:,
+      truncation_indicator:,
+      value:,
+      width:)
+
+      @alignment = alignment
+      @cell_data = cell_data
+      @formatter = formatter
+      @left_padding = left_padding
+      @padding_character = padding_character
+      @right_padding = right_padding
+      @styler = styler
+      @truncation_indicator = truncation_indicator
+      @value = value
+      @width = width
+    end
+
+    # @!visibility private
+    def height
+      subcells.size
+    end
+
+    # @!visibility private
+    def padded_truncated_subcells(target_height)
+      total_padding_amount = @left_padding + @right_padding
+      truncated = (height > target_height)
+      (0...target_height).map do |subcell_index|
+        append_truncator = (truncated && (total_padding_amount != 0) && (subcell_index + 1 == target_height))
+        padded_subcell(subcell_index, append_truncator)
+      end
+    end
+
+    # @return [String] the content of the Cell, after applying the formatter for this Column (but
+    #   without applying any wrapping or the styler).
+    def formatted_content
+      @formatted_content ||= apply_formatter
+    end
+
+    private
+
+    def apply_formatter
+      if @formatter.arity == 2
+        @formatter.call(@value, @cell_data)
+      else
+        @formatter.call(@value)
+      end
+    end
+
+    def apply_styler(content, line_index)
+      case @styler.arity
+      when 4
+        @styler.call(@value, content, @cell_data, line_index)
+      when 3
+        @styler.call(@value, content, @cell_data)
+      else
+        @styler.call(@value, content)
+      end
+    end
+
+    def subcells
+      @subcells ||= calculate_subcells
+    end
+
+    def padded_subcell(subcell_index, append_truncator)
+      lpad = @padding_character * @left_padding
+      rpad =
+        if append_truncator
+          styled_truncation_indicator(subcell_index) + padding(@right_padding - 1)
+        else
+          padding(@right_padding)
+        end
+      inner = subcell_index < height ? subcells[subcell_index] : padding(@width)
+      "#{lpad}#{inner}#{rpad}"
+    end
+
+    def padding(amount)
+      @padding_character * amount
+    end
+
+    def styled_truncation_indicator(line_index)
+      apply_styler(@truncation_indicator, line_index)
+    end
+
+    def calculate_subcells
+      line_index = 0
+      formatted_content.split($/, -1).flat_map do |substr|
+        subsubcells, subsubcell, subsubcell_width = [], String.new(""), 0
+
+        substr.scan(/\X/).each do |grapheme_cluster|
+          grapheme_cluster_width = Unicode::DisplayWidth.of(grapheme_cluster)
+          if subsubcell_width + grapheme_cluster_width > @width
+            subsubcells << style_and_align_cell_content(subsubcell, line_index)
+            subsubcell_width = 0
+            subsubcell.clear
+            line_index += 1
+          end
+
+          subsubcell << grapheme_cluster
+          subsubcell_width += grapheme_cluster_width
+        end
+
+        subsubcells << style_and_align_cell_content(subsubcell, line_index)
+        line_index += 1
+        subsubcells
+      end
+    end
+
+    def style_and_align_cell_content(content, line_index)
+      padding = Util.max(@width - Unicode::DisplayWidth.of(content), 0)
+      left_padding, right_padding =
+        case real_alignment
+        when :center
+          half_padding = padding / 2
+          [padding - half_padding, half_padding]
+        when :left
+          [0, padding]
+        when :right
+          [padding, 0]
+        end
+
+      "#{' ' * left_padding}#{apply_styler(content, line_index)}#{' ' * right_padding}"
+    end
+
+    def real_alignment
+      return @alignment unless @alignment == :auto
+
+      case @value
+      when Numeric
+        :right
+      when TrueClass, FalseClass
+        :center
+      else
+        :left
+      end
+    end
+  end
+end

data/lib/tabulo/cell_data.rb

@@ -0,0 +1,14 @@
+module Tabulo
+
+  # Contains information about a particular {Cell} in the {Table}.
+  #
+  # @attr source [Object] The member of this {Cell}'s {Table}'s underlying enumerable from which
+  #   this {Cell}'s {Row} was derived.
+  # @attr row_index [Integer] The positional index of the {Cell}'s {Row}. The topmost {Row} of the
+  #   {Table} has index 0, the next has index 1, etc.. The header row(s) are not counted for the purpose
+  #   of this numbering.
+  # @attr column_index [Integer] The positional index of the {Cell}'s {Column}. The leftmost {Column}
+  #   of the {Table} has index 0, the next has index 1, etc..
+  CellData = Struct.new(:source, :row_index, :column_index)
+
+end

data/lib/tabulo/column.rb

@@ -0,0 +1,114 @@
+module Tabulo
+
+  # @!visibility private
+  class Column
+
+    attr_accessor :width
+    attr_reader :header
+    attr_reader :index
+    attr_reader :left_padding
+    attr_reader :right_padding
+
+    def initialize(
+      align_body:,
+      align_header:,
+      extractor:,
+      formatter:,
+      header:,
+      header_styler:,
+      index:,
+      left_padding:,
+      padding_character:,
+      right_padding:,
+      styler:,
+      truncation_indicator:,
+      width:)
+
+      @align_body = align_body
+      @align_header = align_header
+      @extractor = extractor
+      @formatter = formatter
+      @header = header
+      @index = index
+      @left_padding = left_padding
+      @right_padding = right_padding
+
+      @header_styler =
+        if header_styler
+          case header_styler.arity
+          when 3
+            -> (_, str, cell_data, line_index) { header_styler.call(str, cell_data.column_index, line_index) }
+          when 2
+            -> (_, str, cell_data) { header_styler.call(str, cell_data.column_index) }
+          else
+            -> (_, str) { header_styler.call(str) }
+          end
+        else
+          -> (_, str) { str }
+        end
+
+      @padding_character = padding_character
+      @styler = styler || -> (_, s) { s }
+      @truncation_indicator = truncation_indicator
+      @width = width
+    end
+
+    def header_cell
+      if @header_styler.arity >= 3
+        cell_data = CellData.new(nil, nil, @index)
+      end
+      Cell.new(
+        alignment: @align_header,
+        cell_data: cell_data,
+        formatter: -> (s) { s },
+        left_padding: @left_padding,
+        padding_character: @padding_character,
+        right_padding: @right_padding,
+        styler: @header_styler,
+        truncation_indicator: @truncation_indicator,
+        value: @header,
+        width: @width,
+      )
+    end
+
+    def body_cell(source, row_index:, column_index:)
+      if body_cell_data_required?
+        cell_data = CellData.new(source, row_index, @index)
+      end
+      Cell.new(
+        alignment: @align_body,
+        cell_data: cell_data,
+        formatter: @formatter,
+        left_padding: @left_padding,
+        padding_character: @padding_character,
+        right_padding: @right_padding,
+        styler: @styler,
+        truncation_indicator: @truncation_indicator,
+        value: body_cell_value(source, row_index: row_index, column_index: column_index),
+        width: @width,
+      )
+    end
+
+    def body_cell_value(source, row_index:, column_index:)
+      if @extractor.arity == 2
+        @extractor.call(source, row_index)
+      else
+        @extractor.call(source)
+      end
+    end
+
+    def padded_width
+      width + total_padding
+    end
+
+    def total_padding
+      @left_padding + @right_padding
+    end
+
+    private
+
+    def body_cell_data_required?
+      @cell_data_required ||= (@styler.arity == 3 || @formatter.arity == 2)
+    end
+  end
+end