fat_table 0.4.2 → 0.5.1

data/lib/fat_table/table.rb

@@ -62,9 +62,14 @@ module FatTable
     # :category: Constructors
 
     # Return an empty FatTable::Table object.
-    def initialize
+    def initialize(*heads)
       @columns = []
       @boundaries = []
+      unless heads.empty?
+        heads.each do |h|
+          @columns << Column.new(header: h)
+        end
+      end
     end
 
     # :category: Constructors
@@ -205,6 +210,7 @@ module FatTable
           end
           result << hsh.to_h
         end
+        result.normalize_boundaries
         result
       end
 
@@ -253,6 +259,7 @@ module FatTable
           hash_row = Hash[headers.zip(row)]
           result << hash_row
         end
+        result.normalize_boundaries
         result
       end
 
@@ -262,6 +269,7 @@ module FatTable
                   skip_blanks: true).each do |row|
           result << row.to_h
         end
+        result.normalize_boundaries
         result
       end
 
@@ -334,8 +342,11 @@ module FatTable
     # Set the column type for Column with the given +key+ as a String type,
     # but only if empty.  Otherwise, we would have to worry about converting
     # existing items in the column to String.  Perhaps that's a TODO.
-    def set_column_to_string_type(key)
-      column(key).force_to_string_type
+    def force_string!(*keys)
+      keys.each do |h|
+        column(h).force_string!
+      end
+      self
     end
 
     # :category: Attributes
@@ -523,6 +534,46 @@ module FatTable
       groups
     end
 
+    # Return the number of groups in the table.
+    def number_of_groups
+      boundaries.size
+    end
+
+    # Return the range of row indexes for boundary number +k+
+    def group_row_range(k)
+      last_k = boundaries.size - 1
+      if k < 0 || k > last_k
+        raise ArgumentError, "boundary number '#{k}' out of range in boundary_row_range"
+      end
+
+      if boundaries.empty?
+        (0..size-1)
+      elsif boundaries.size == 1
+        (0..boundaries.first)
+      else
+        # Keep index at or above zero
+        if k.zero?
+          (0..boundaries[k])
+        else
+          (boundaries[k-1]+1..boundaries[k])
+        end
+      end
+    end
+
+    # Return an Array of Column objects for header +col+ representing a
+    # sub-column for each group in the table under that header.
+    def group_cols(col)
+      normalize_boundaries
+      cols = []
+      (0..boundaries.size - 1).each do |k|
+        range = group_row_range(k)
+        tab_col = column(col)
+        gitems = tab_col.items[range]
+        cols << Column.new(header: col, items: gitems, type: tab_col.type)
+      end
+      cols
+    end
+
     # :category: Operators
 
     # Return this table mutated with all groups removed. Useful after something
@@ -545,8 +596,6 @@ module FatTable
       end
     end
 
-    protected
-
     # :stopdoc:
 
     # Make sure size - 1 is last boundary and that they are unique and sorted.
@@ -558,6 +607,8 @@ module FatTable
       boundaries
     end
 
+    protected
+
     # Concatenate the array of argument bounds to this table's boundaries, but
     # increase each of the indexes in bounds by shift. This is used in the
     # #union_all method.
@@ -604,16 +655,32 @@ module FatTable
     # After sorting, the output Table will have group boundaries added after
     # each row where the sort key changes.
     def order_by(*sort_heads)
-      sort_heads = [sort_heads].flatten
-      rev_heads = sort_heads.select { |h| h.to_s.ends_with?('!') }
-      sort_heads = sort_heads.map { |h| h.to_s.sub(/\!\z/, '').to_sym }
-      rev_heads = rev_heads.map { |h| h.to_s.sub(/\!\z/, '').to_sym }
+      # Sort the rows in order and add to new_rows.
+      key_hash = partition_sort_keys(sort_heads)
       new_rows = rows.sort do |r1, r2|
-        key1 = sort_heads.map { |h| rev_heads.include?(h) ? r2[h] : r1[h] }
-        key2 = sort_heads.map { |h| rev_heads.include?(h) ? r1[h] : r2[h] }
-        key1 <=> key2
+        # Set the sort keys based on direction
+        key1 = []
+        key2 = []
+        key_hash.each_pair do |h, dir|
+          if dir == :forward
+            key1 << r1[h]
+            key2 << r2[h]
+          else
+            key1 << r2[h]
+            key2 << r1[h]
+          end
+        end
+        # Make any booleans comparable with <=>
+        key1 = key1.map_booleans
+        key2 = key2.map_booleans
+
+        # If there are any nils, <=> will return nil, and we have to use the
+        # special comparison method, compare_with_nils, instead.
+        result = (key1 <=> key2)
+        result.nil? ? compare_with_nils(key1, key2) : result
       end
-      # Add the new rows to the table, but mark a group boundary at the points
+
+      # Add the new_rows to the table, but mark a group boundary at the points
       # where the sort key changes value.  NB: I use self.class.new here
       # rather than Table.new because if this class is inherited, I want the
       # new_tab to be an instance of the subclass.  With Table.new, this
@@ -623,7 +690,8 @@ module FatTable
       last_key = nil
       new_rows.each_with_index do |nrow, k|
         new_tab << nrow
-        key = nrow.fetch_values(*sort_heads)
+        # key = nrow.fetch_values(*sort_heads)
+        key = nrow.fetch_values(*key_hash.keys)
         new_tab.mark_boundary(k - 1) if last_key && key != last_key
         last_key = key
       end
@@ -631,6 +699,33 @@ module FatTable
       new_tab
     end
 
+    # :category: Operators
+
+    # Return a new Table sorting the rows of this Table on an any expression
+    # +expr+ that is valid with the +select+ method, except that they
+    # expression may end with an exclamation mark +!+ to indicate a reverse
+    # sort.  The new table will have an additional column called +sort_key+
+    # populated with the result of evaluating the given expression and will be
+    # sorted (or reverse sorted) on that column.
+    #
+    #   tab.order_with('date.year') => table sorted by date's year
+    #   tab.order_with('date.year!') => table reverse sorted by date's year
+    #
+    # After sorting, the output Table will have group boundaries added after
+    # each row where the sort key changes.
+    def order_with(expr)
+      unless expr.is_a?(String)
+        raise "must call FatTable::Table\#order_with with a single string expression"
+      end
+      rev = false
+      if expr.match?(/\s*!\s*\z/)
+        rev = true
+        expr = expr.sub(/\s*!\s*\z/, '')
+      end
+      sort_sym = rev ? :sort_key! : :sort_key
+      dup.select(*headers, sort_key: expr).order_by(sort_sym)
+    end
+
     # :category: Operators
     #
     # Return a Table having the selected column expressions. Each expression can
@@ -744,7 +839,15 @@ module FatTable
         ev.eval_before_hook(locals: old_row)
         # Compute the new row.
         new_row = {}
-        cols.each do |k|
+        # Allow the :omni col to stand for all columns if it is alone and
+        # first.
+        cols_to_include =
+          if cols.size == 1 && cols.first.as_sym == :omni
+            headers
+          else
+            cols
+          end
+        cols_to_include.each do |k|
           h = k.as_sym
           msg = "Column '#{h}' in select does not exist"
           raise UserError, msg unless column?(h)
@@ -910,36 +1013,6 @@ module FatTable
       set_operation(other, :difference, distinct: false)
     end
 
-    private
-
-    # Apply the set operation given by ~oper~ between this table and the other
-    # table given in the first argument.  If distinct is true, eliminate
-    # duplicates from the result.
-    def set_operation(other, oper = :+, distinct: true, add_boundaries: true, inherit_boundaries: false)
-      unless columns.size == other.columns.size
-        msg = "can't apply set ops to tables with a different number of columns"
-        raise UserError, msg
-      end
-      unless columns.map(&:type) == other.columns.map(&:type)
-        msg = "can't apply a set ops to tables with different column types."
-        raise UserError, msg
-      end
-      other_rows = other.rows.map { |r| r.replace_keys(headers) }
-      result = empty_dup
-      new_rows = rows.send(oper, other_rows)
-      new_rows.each_with_index do |row, k|
-        result << row
-        result.mark_boundary if k == size - 1 && add_boundaries
-      end
-      if inherit_boundaries
-        result.boundaries = normalize_boundaries
-        other.normalize_boundaries
-        result.append_boundaries(other.boundaries, shift: size)
-      end
-      result.normalize_boundaries
-      distinct ? result.distinct : result
-    end
-
     public
 
     # An Array of symbols for the valid join types.
@@ -1507,5 +1580,75 @@ module FatTable
       yield fmt if block_given?
       fmt.output
     end
+
+    private
+
+    # Apply the set operation given by ~oper~ between this table and the other
+    # table given in the first argument.  If distinct is true, eliminate
+    # duplicates from the result.
+    def set_operation(other, oper = :+, distinct: true, add_boundaries: true, inherit_boundaries: false)
+      unless columns.size == other.columns.size
+        msg = "can't apply set ops to tables with a different number of columns"
+        raise UserError, msg
+      end
+      unless columns.map(&:type) == other.columns.map(&:type)
+        msg = "can't apply a set ops to tables with different column types."
+        raise UserError, msg
+      end
+      other_rows = other.rows.map { |r| r.replace_keys(headers) }
+      result = empty_dup
+      new_rows = rows.send(oper, other_rows)
+      new_rows.each_with_index do |row, k|
+        result << row
+        result.mark_boundary if k == size - 1 && add_boundaries
+      end
+      if inherit_boundaries
+        result.boundaries = normalize_boundaries
+        other.normalize_boundaries
+        result.append_boundaries(other.boundaries, shift: size)
+      end
+      result.normalize_boundaries
+      distinct ? result.distinct : result
+    end
+
+    # Return a hash with the key being the header to sort on and the value
+    # being either :forward or :reverse to indicate the sort order on that
+    # key.
+    def partition_sort_keys(keys)
+      result = {}
+      [keys].flatten.each do |h|
+        if h.to_s.match?(/\s*!\s*\z/)
+          result[h.to_s.sub(/\s*!\s*\z/, '').to_sym] = :reverse
+        else
+          result[h] = :forward
+        end
+      end
+      result
+    end
+
+    # The <=> operator cannot handle nils without some help.  Treat a nil as
+    # smaller than any other value, but equal to other nils.  The two keys are assumed to be arrays of values to be
+    # compared with <=>.
+    def compare_with_nils(key1, key2)
+      result = nil
+      key1.zip(key2) do |k1, k2|
+        if k1.nil? && k2.nil?
+          result = 0
+          next
+        elsif k1.nil?
+          result = -1
+          break
+        elsif k2.nil?
+          result = 1
+          break
+        elsif (k1 <=> k2) == 0
+          next
+        else
+          result = (k1 <=> k2)
+          break
+        end
+      end
+      result
+    end
   end
 end

data/lib/fat_table/version.rb

@@ -2,5 +2,5 @@
 
 module FatTable
   # The current version of FatTable
-  VERSION = '0.4.2'
+  VERSION = '0.5.1'
 end

data/lib/fat_table.rb

@@ -19,9 +19,12 @@ module FatTable
 
   require 'fat_table/version'
   require 'fat_table/patches'
+  require 'ext/array'
   require 'fat_table/evaluator'
+  require 'fat_table/convert'
   require 'fat_table/column'
   require 'fat_table/table'
+  require 'fat_table/footer'
   require 'fat_table/formatters'
   require 'fat_table/db_handle'
   require 'fat_table/errors'
@@ -58,8 +61,8 @@ module FatTable
 
   # Return an empty FatTable::Table object. You can use FatTable::Table#add_row
   # or FatTable::Table#add_column to populate the table with data.
-  def self.new
-    Table.new
+  def self.new(*args)
+    Table.new(*args)
   end
 
   # Construct a FatTable::Table from the contents of a CSV file given by the

data/md/README.md

@@ -1109,8 +1109,7 @@ will raise an exception.
 
 -   **`first`:** the first non-nil item in the column,
 -   **`last`:** the last non-nil item in the column,
--   **`rng`:** form a string of the form `"#{first}..#{last}"` to show the range of
-    values in the column,
+-   **`range`:** form a Range ~~{min}..{max}~ to show the range of values in the column,
 -   **`sum`:** for `Numeric` and `String` columns, apply ’+’ to all the non-nil
     values,
 -   **`count`:** the number of non-nil values in the column,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_table
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.1
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-06 00:00:00.000000000 Z
+date: 2022-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -283,12 +297,24 @@ files:
 - TODO.org
 - bin/ft_console
 - bin/setup
+- examples/create_trans.sql
+- examples/quick.pdf
+- examples/quick.png
+- examples/quick.ppm
+- examples/quick.tex
+- examples/quick_small.png
+- examples/quicktable.tex
+- examples/trades.db
+- examples/trans.csv
 - fat_table.gemspec
+- lib/ext/array.rb
 - lib/fat_table.rb
 - lib/fat_table/column.rb
+- lib/fat_table/convert.rb
 - lib/fat_table/db_handle.rb
 - lib/fat_table/errors.rb
 - lib/fat_table/evaluator.rb
+- lib/fat_table/footer.rb
 - lib/fat_table/formatters.rb
 - lib/fat_table/formatters/aoa_formatter.rb
 - lib/fat_table/formatters/aoh_formatter.rb