bmg 0.23.3 → 0.23.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b89960dcbdf37657c8c0dea35e8f735c71175e61363a122b5a249e4a3bd232e
-  data.tar.gz: 93f21f3f85bf21466a280b67e6cf339ae1498ed165cf40fcbd38ac88bd1f2970
+  metadata.gz: cb0b47d8dbd6924eb1f4fb7e773635a5d1fc83fc09b09c60ead3ac913bbd2051
+  data.tar.gz: ad0919fc045b59b5299254d0f476b31390069b6d39e086334cd55790eedf56e0
 SHA512:
-  metadata.gz: 043731637cf8c164225db38e9f47c2d9bf68a35598ea37947dede59c031c99e550f0dcfe5ac20503942d0a43b5036749b9d158140f59d1e463594a2fe20a1236
-  data.tar.gz: ad41145f3411f1e4cf28e293ef53faee512c9808cbc0e7a091a2da3366b665dadea628eacbf684e5c24d1ea4c3c97df8c5e783f59597d6a385119a14f8acab8c
+  metadata.gz: 1fa7c3dfa036762e82dd86275c522af811eba747901f288e8b1804388ddee0094350374795527b0884cf8d5355eea649f9c3ce4a66ec7c9742eeaef5fff81a16
+  data.tar.gz: 5cee0487c9e70df6a049791ef48d93fda5ff516d769b7f8d25f9ea6f29d9d780bec8aebca78a8e88e435113acde6860fc1c7dbbbb2c9bb7f70edf88d22bfe739

data/README.md

@@ -22,6 +22,7 @@ further down this README.
   * [Connecting to SQL databases](#connecting-to-sql-databases)
   * [Reading data files](#reading-data-files-json-csv-yaml-text-xls--xlsx)
   * [Connecting to Redis databases](#connecting-to-redis-databases)
+  * [The Generator](#the-generator)
   * [Your own relations](#your-own-relations)
 * [The Database abstraction](#the-database-abstraction)
 * [List of supported operators](#supported-operators)
@@ -238,6 +239,42 @@ and is optional.
 The redis relvars support basic algorithms for insert/update/delete.
 No optimization is currently supported.
 
+### The Generator
+
+Somewhat similar to PostgreSQL's `generate_series`, Bmg supports the generation
+of relations. Unlike PostgreSQL though, the result is a Relation that can be
+"chained" as any other relation, not a sequence of scalars :
+
+```ruby
+r = Bmg
+  .generate(1, 10, :step => 2, :as => :index)
+  .restrict(:index => 5)
+```
+
+If you don't specify the `:as` option, the attribute name will be `:i`.
+
+The step can be negative :
+
+```ruby
+Bmg.generate(10, 1, :step => -2, :as => :index)
+```
+
+The step can also be computed :
+
+```ruby
+Bmg.generate(1, 100, :step => ->(current){ current * 2 })
+```
+
+Last but not least, you can use any ordinal data type. For instance, the
+following code will work and generate all months from May to December 2025
+(under the assumption that ActiveRecord's `next_month` is available).
+
+```ruby
+min = Date.new(2025,5,1)
+max = Date.new(2025,12,1)
+Bmg.generate(min, max, :step => ->(current){ current.next_month })
+```
+
 ### Your own relations
 
 As noted earlier, Bmg has a simple relation interface where you only have to
@@ -353,6 +390,7 @@ r.transform(:to_s)                           # all-attrs transformation
 r.transform(&:to_s)                          # similar, but Proc-driven
 r.transform(:foo => :upcase, ...)            # specific-attrs tranformation
 r.transform([:to_s, :upcase])                # chain-transformation
+r.undress()                                  # convert all values to a scalar (number, string, bool, object, array)
 r.ungroup([:a, :b, ...])                     # ungroup relation-valued attributes within parent tuple
 r.ungroup(:a)                                # shortcut over ungroup([:a])
 r.union(right)                               # set union

data/lib/bmg/algebra.rb

@@ -184,6 +184,15 @@ module Bmg
     end
     protected :_transform
 
+    def undress(options = {})
+      _undress self.type.undress(options), options
+    end
+
+    def _undress(type, options)
+      Operator::Undress.new(type, self, options)
+    end
+    protected :_undress
+
     def ungroup(attrs)
       _ungroup self.type.ungroup(attrs), attrs
     end

data/lib/bmg/operator/generator.rb

@@ -0,0 +1,68 @@
+module Bmg
+  module Operator
+    #
+    # Generator operator.
+    #
+    # Generates a relation. Most inspired by PostgreSQL's generate_series.
+    #
+    class Generator
+      include Operator::Zeroary
+
+      DEFAULT_OPTIONS = {
+        :as => :i,
+        :step => 1,
+      }
+
+      def initialize(type, from, to, options = {})
+        options = { step: options } unless options.is_a?(Hash)
+        @type = type
+        @from = from
+        @to = to
+        @options = DEFAULT_OPTIONS.merge(options)
+        raise ArgumentError, "from, to and step must be defined" if from.nil? || to.nil? || step.nil?
+      end
+      attr_reader :from, :to, :options
+
+      def each
+        return to_enum unless block_given?
+
+        current = from
+        as = options[:as]
+
+        until overflowed?(current)
+          yield({ as => current })
+          current = next_of(current)
+        end
+      end
+
+    private
+
+      def step
+        @step ||= options[:step]
+      end
+
+      def positive_step?
+        !step.is_a?(Numeric) || step > 0
+      end
+
+      def next_of(current)
+        step.is_a?(Proc) ? step.call(current) : current + step
+      end
+
+      def overflowed?(current)
+        positive_step? ? current > to : current < to
+      end
+
+    protected ### inspect
+
+      def operands
+        []
+      end
+
+      def args
+        [ from, to, options ]
+      end
+
+    end # class Generator
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/shared/zeroary.rb

@@ -0,0 +1,24 @@
+module Bmg
+  module Operator
+    module Zeroary
+      include Operator
+
+      def bind(binding)
+        dup
+      end
+
+    protected
+
+      attr_accessor :operand
+
+      def _visit(parent, visitor)
+        visitor.call(self, parent)
+      end
+
+      def operands
+        []
+      end
+
+    end # module Zeroary
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/undress.rb

@@ -0,0 +1,66 @@
+module Bmg
+  module Operator
+    #
+    # Undress operator.
+    #
+    # Transform all values to keep only integer, strings & booleans
+    #
+    class Undress
+      include Operator::Unary
+
+      DEFAULT_OPTIONS = {}
+
+      def initialize(type, operand, options = {})
+        @type = type
+        @operand = operand
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+    protected
+
+      attr_reader :options
+
+    public
+
+      def each
+        return to_enum unless block_given?
+
+        @operand.each do |tuple|
+          yield undress(tuple)
+        end
+      end
+
+      def to_ast
+        [ :transform, operand.to_ast, transformation.dup ]
+      end
+
+    protected ### inspect
+
+      def args
+        [ ]
+      end
+
+    private
+
+      def undress(value)
+        case value
+        when ->(v) { v.respond_to?(:undress) }
+          value.undress
+        when Hash
+          value.each_with_object({}) do |(k,v), undressed|
+            undressed[k] = undress(v)
+          end
+        when Relation
+          Relation.new value.map{|tuple| undress(tuple) }
+        when Date, Time
+          value.iso8601
+        when Array
+          value.map{|v| undress(v) }
+        else
+          value
+        end
+      end
+
+    end # class Undress
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator.rb

@@ -17,15 +17,20 @@ module Bmg
 
     def inspect
       str = "(#{self.class.name.split('::').last.downcase}\n"
-      str << operands.map{|op| op.inspect.gsub(/^/m, "  ") }.join("\n")
-      str << "\n"
-      str << args.map{|a| a.inspect.gsub(/^/m, "  ") }.join("\n")
+      unless operands.empty?
+        str << operands.map{|op| op.inspect.gsub(/^/m, "  ") }.join("\n")
+        str << "\n"
+      end
+      unless args.empty?
+        str << args.map{|a| a.inspect.gsub(/^/m, "  ") }.join("\n")
+      end
       str << ")"
       str
     end
 
   end # module Operator
 end # module Bmg
+require_relative 'operator/shared/zeroary'
 require_relative 'operator/shared/unary'
 require_relative 'operator/shared/binary'
 require_relative 'operator/shared/nary'
@@ -48,6 +53,9 @@ require_relative 'operator/restrict'
 require_relative 'operator/rxmatch'
 require_relative 'operator/summarize'
 require_relative 'operator/transform'
+require_relative 'operator/undress'
 require_relative 'operator/ungroup'
 require_relative 'operator/union'
 require_relative 'operator/unwrap'
+
+require_relative 'operator/generator'

data/lib/bmg/relation.rb

@@ -2,17 +2,13 @@ module Bmg
   module Relation
     include Enumerable
     include Algebra
+    extend Factory
 
     def self.new(operand, type = Type::ANY)
       raise ArgumentError, "Missing type" if type.nil?
       operand.is_a?(Relation) ? operand : Bmg.in_memory(operand, type)
     end
 
-    def self.empty(type = Type::ANY)
-      raise ArgumentError, "Missing type" if type.nil?
-      Relation::Empty.new(type)
-    end
-
     def bind(binding)
       self
     end

data/lib/bmg/support/factory.rb

@@ -0,0 +1,53 @@
+module Bmg
+  module Factory
+    def empty(type = Type::ANY)
+      raise ArgumentError, "Missing type" if type.nil?
+      Relation::Empty.new(type)
+    end
+
+    def mutable(enumerable, type = Type::ANY)
+      Relation::InMemory::Mutable.new(type, enumerable).spied(Bmg.main_spy)
+    end
+
+    def in_memory(enumerable, type = Type::ANY)
+      Relation::InMemory.new(type, enumerable).spied(Bmg.main_spy)
+    end
+
+    def generate(from, to, options = {})
+      type = Type::ANY.with_attrlist([options[:as] || Operator::Generator::DEFAULT_OPTIONS[:as]])
+      Operator::Generator.new(type, from, to, options)
+    end
+
+    def text_file(path, options = {}, type = Type::ANY)
+      Reader::TextFile.new(type, path, options).spied(Bmg.main_spy)
+    end
+
+    def csv(path, options = {}, type = Type::ANY)
+      Reader::Csv.new(type, path, options).spied(Bmg.main_spy)
+    end
+
+    def json_file(path, options = {}, type = Type::ANY)
+      in_memory(path.load.map{|tuple| TupleAlgebra.symbolize_keys(tuple) })
+    end
+
+    def json(*args, &bl)
+      json_file(*args, &bl)
+    end
+
+    def yaml_file(path, options = {}, type = Type::ANY)
+      in_memory(path.load.map{|tuple| TupleAlgebra.symbolize_keys(tuple) })
+    end
+
+    def yaml(*args, &bl)
+      yaml_file(*args, &bl)
+    end
+
+    def excel_file(path, options = {}, type = Type::ANY)
+      Reader::Excel.new(type, path, options).spied(Bmg.main_spy)
+    end
+
+    def excel(*args, &bl)
+      excel_file(*args, &bl)
+    end
+  end
+end

data/lib/bmg/support/tuple_transformer.rb

@@ -49,6 +49,11 @@ module Bmg
           with.inject(tuple){|dup,on|
             transform_tuple(dup, on)
           }
+        when Type
+          unless with.knows_types?
+            raise ArgumentError, "Heading must specify the attribute types`"
+          end
+          transform_tuple(tuple, with.heading)
         else
           raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
         end
@@ -78,6 +83,18 @@ module Bmg
           with.call(value)
         when Hash
           with[value]
+        when Type
+          unless with.knows_types?
+            raise ArgumentError, "Heading must specify the attribute types`"
+          end
+          case value
+          when Hash
+            transform_tuple(value, with.heading)
+          when Enumerable
+            Relation.new(value.map{|t| transform_tuple(t, with.heading) })
+          else
+            raise ArgumentError, "Unexpected value `#{value.inspect}`"
+          end
         else
           raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
         end

data/lib/bmg/support.rb

@@ -3,3 +3,4 @@ require_relative 'support/tuple_transformer'
 require_relative 'support/keys'
 require_relative 'support/ordering'
 require_relative 'support/output_preferences'
+require_relative 'support/factory'

data/lib/bmg/type.rb

@@ -9,6 +9,10 @@ module Bmg
 
     ANY = Type.new
 
+    def self.for_heading(heading)
+      Type.new.with_heading(heading)
+    end
+
   public ## type checking
 
     attr_writer :typechecked
@@ -41,6 +45,22 @@ module Bmg
       }
     end
 
+  public ## heading
+
+    attr_accessor :heading
+    protected :heading=
+
+    def with_heading(heading)
+      dup.tap{|x|
+        x.heading = heading
+        x.attrlist = heading.keys
+      }
+    end
+
+    def knows_types?
+      !@heading.nil?
+    end
+
   public ## attrlist
 
     attr_accessor :attrlist
@@ -201,6 +221,17 @@ module Bmg
       self
     end
 
+    def minus(other)
+      union_compatible!(other, "Minus")
+      dup.tap{|x|
+        # 1. attributes do not change
+        # 2. predicate does not change, we can't strengthen it in any way but it
+        #    does not become weaker either
+        # 3. we can safely keep all existing keys, but it's not obvious we can
+        #    gain some new ones
+      }
+    end
+
     def not_matching(right, on)
       join_compatible!(right, on) if typechecked? && knows_attrlist?
       self
@@ -278,6 +309,12 @@ module Bmg
       }
     end
 
+    def undress(options)
+      dup.tap{|x|
+        x.predicate = Predicate.tautology
+      }
+    end
+
     def ungroup(attrlist)
       known_attributes!(attrlist) if typechecked? && knows_attrlist?
       dup.tap{|x|
@@ -296,17 +333,6 @@ module Bmg
       }
     end
 
-    def minus(other)
-      union_compatible!(other, "Minus")
-      dup.tap{|x|
-        # 1. attributes do not change
-        # 2. predicate does not change, we can't strengthen it in any way but it
-        #    does not become weaker either
-        # 3. we can safely keep all existing keys, but it's not obvious we can
-        #    gain some new ones
-      }
-    end
-
     def unwrap(attrlist)
       known_attributes!(attrlist) if typechecked? && knows_attrlist?
       dup.tap{|x|

data/lib/bmg/version.rb

@@ -2,7 +2,7 @@ module Bmg
   module Version
     MAJOR = 0
     MINOR = 23
-    TINY  = 3
+    TINY  = 5
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/bmg/writer/text.rb

@@ -0,0 +1,200 @@
+module Bmg
+  module Writer
+    class Text
+      include Writer
+
+      TupleLike    = lambda{|t| t.is_a?(Hash) || (defined?(OpenStruct) && t.is_a?(OpenStruct)) }
+      RelationLike = lambda{|r| r.is_a?(Relation) || (r.is_a?(Enumerable) && r.all?{|t| TupleLike === t }) }
+
+      module Utils
+
+        def max(x, y)
+          return y if x.nil?
+          return x if y.nil?
+          x > y ? x : y
+        end
+      end
+      include Utils
+
+      class Cell
+        include Utils
+
+        def initialize(renderer, value)
+          @renderer = renderer
+          @value = value
+        end
+
+        def min_width
+          @min_width ||= rendering_lines.inject(0) do |maxl,line|
+            max(maxl,line.size)
+          end
+        end
+
+        def rendering_lines(size = nil)
+          if size.nil?
+            text_rendering.split(/\n/)
+          elsif @value.is_a?(Numeric)
+            rendering_lines(nil).map{|l| "%#{size}s" % l}
+          else
+            rendering_lines(nil).map{|l| "%-#{size}s" % l}
+          end
+        end
+
+        def text_rendering
+          @text_rendering ||= case (value = @value)
+            when NilClass
+              "[nil]"
+            when Symbol
+              value.inspect
+            when Float
+              (@renderer.text_options[:float_format] || "%.3f") % value
+            when Hash
+              value.inspect
+            when RelationLike
+              @renderer.render(value, "")
+            when Array
+              array_rendering(value)
+            when Time, DateTime
+              value.to_s
+            else
+              value.to_s
+          end
+        end
+
+        def array_rendering(value)
+          if TupleLike === value.first
+            @renderer.render(value, "")
+          elsif value.empty?
+            "[]"
+          else
+            values = value.map{|x| Cell.new(x).text_rendering}
+            if values.inject(0){|memo,s| memo + s.size} < 20
+              "[" + values.join(", ") + "]"
+            else
+              "[" + values.join(",\n ") + "]"
+            end
+          end
+        end
+
+      end # class Cell
+
+      class Row
+        include Utils
+
+        def initialize(renderer, values)
+          @renderer = renderer
+          @cells = values.map{|v| Cell.new(renderer, v) }
+        end
+
+        def min_widths
+          @cells.map{|cell| cell.min_width}
+        end
+
+        def rendering_lines(sizes = min_widths)
+          nb_lines = 0
+          by_cell = @cells.zip(sizes).map do |cell,size|
+            lines = cell.rendering_lines(size)
+            nb_lines = max(nb_lines, lines.size)
+            lines
+          end
+          grid = (0...nb_lines).map do |line_i|
+            "| " + by_cell.zip(sizes).map{|cell_lines, size|
+              cell_lines[line_i] || " "*size
+            }.join(" | ") + " |"
+          end
+          grid.empty? ? ["|  |"] : grid
+        end
+
+      end # class Row
+
+      class Table
+        include Utils
+
+        def initialize(renderer, records, attributes)
+          @renderer = renderer
+          @header = Row.new(renderer, attributes.map(&:to_s))
+          @rows = records.map{|r| Row.new(renderer, r) }
+        end
+        attr_reader :renderer, :header, :rows
+
+        def sizes
+          @sizes ||= rows.inject(header.min_widths) do |memo,row|
+            memo.zip(row.min_widths).map{|x,y| max(x,y)}
+          end
+        end
+
+        def sep
+          @sep ||= '+-' << sizes.map{|s| '-' * s}.join('-+-') << '-+'
+        end
+
+        def each_line(pretty = renderer.text_options[:pretty])
+          if pretty && trim = renderer.text_options[:trim_at]
+            each_line(false) do |line|
+              yield(line[0..trim])
+            end
+          else
+            yield(sep)
+            yield(header.rendering_lines(sizes).first)
+            yield(sep)
+            rows.each do |row|
+              row.rendering_lines(sizes).each do |line|
+                yield(line)
+              end
+            end
+            yield(sep)
+          end
+        end
+
+        def each
+          return to_enum unless block_given?
+          each_line do |line|
+            yield(line.strip << "\n")
+          end
+        end
+
+        def to_s
+          each.each_with_object(""){|line,buf| buf << line}
+        end
+
+      end # class Table
+
+
+      DEFAULT_OPTIONS = {
+      }
+
+      def initialize(text_options = {}, output_preferences = nil)
+        @text_options = DEFAULT_OPTIONS.merge(text_options)
+        @output_preferences = OutputPreferences.dress(output_preferences)
+      end
+      attr_reader :text_options, :output_preferences
+
+      def call(relation, output = "")
+        each_line(relation) do |str|
+          output << str
+        end
+        output
+      end
+      alias :render :call
+
+    private
+
+      def each_line(relation, &bl)
+        input    = relation
+        input    = [input.to_hash] if TupleLike === input
+        relation = input.to_a
+        attrs    = relation.inject([]){|memo,t| (memo | t.keys) }
+        records  = relation.map{|t| attrs.map{|a| t[a]} }
+        table    = Table.new(self, records, attrs)
+        table.each(&bl)
+      end
+
+    end # class Text
+  end # module Writer
+  module Relation
+
+    def to_text(options = {}, preferences = {}, output = "")
+      Writer::Text.new(options, preferences).render(self, output)
+    end
+
+  end # module Relation
+end # module Bmg

data/lib/bmg/writer.rb

@@ -25,4 +25,5 @@ module Bmg
 
   end # module Writer
 end # module Bmg
+require_relative 'writer/text'
 require_relative 'writer/csv'

data/lib/bmg.rb

@@ -4,51 +4,6 @@ require 'forwardable'
 require 'set'
 module Bmg
 
-  def mutable(enumerable, type = Type::ANY)
-    Relation::InMemory::Mutable.new(type, enumerable).spied(main_spy)
-  end
-  module_function :mutable
-
-  def in_memory(enumerable, type = Type::ANY)
-    Relation::InMemory.new(type, enumerable).spied(main_spy)
-  end
-  module_function :in_memory
-
-  def text_file(path, options = {}, type = Type::ANY)
-    Reader::TextFile.new(type, path, options).spied(main_spy)
-  end
-  module_function :text_file
-
-  def csv(path, options = {}, type = Type::ANY)
-    Reader::Csv.new(type, path, options).spied(main_spy)
-  end
-  module_function :csv
-
-  def json(path, options = {}, type = Type::ANY)
-    in_memory(path.load.map{|tuple| TupleAlgebra.symbolize_keys(tuple) })
-  end
-  module_function :json
-
-  def yaml(path, options = {}, type = Type::ANY)
-    in_memory(path.load.map{|tuple| TupleAlgebra.symbolize_keys(tuple) })
-  end
-  module_function :yaml
-
-  def excel(path, options = {}, type = Type::ANY)
-    Reader::Excel.new(type, path, options).spied(main_spy)
-  end
-  module_function :excel
-
-  def main_spy
-    @main_spy
-  end
-  module_function :main_spy
-
-  def main_spy=(spy)
-    @main_spy = spy
-  end
-  module_function :main_spy=
-
   require_relative 'bmg/version'
   require_relative 'bmg/error'
   require_relative 'bmg/support'
@@ -69,6 +24,19 @@ module Bmg
 
   require_relative 'bmg/database'
 
+  def main_spy
+    @main_spy
+  end
+  module_function :main_spy
+
+  def main_spy=(spy)
+    @main_spy = spy
+  end
+  module_function :main_spy=
+
+  # Add all factory methods
+  extend Factory
+
   # Deprecated
   Leaf = Relation::InMemory
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.23.3
+  version: 0.23.5
 platform: ruby
 authors:
 - Bernard Lambeau
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2025-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -128,6 +128,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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'
 description: Bmg is Alf's relational algebra for ruby, but much simpler and lighter
   than Alf itself
 email: blambeau@gmail.com
@@ -153,6 +167,7 @@ files:
 - lib/bmg/operator/autowrap.rb
 - lib/bmg/operator/constants.rb
 - lib/bmg/operator/extend.rb
+- lib/bmg/operator/generator.rb
 - lib/bmg/operator/group.rb
 - lib/bmg/operator/image.rb
 - lib/bmg/operator/join.rb
@@ -167,8 +182,10 @@ files:
 - lib/bmg/operator/shared/binary.rb
 - lib/bmg/operator/shared/nary.rb
 - lib/bmg/operator/shared/unary.rb
+- lib/bmg/operator/shared/zeroary.rb
 - lib/bmg/operator/summarize.rb
 - lib/bmg/operator/transform.rb
+- lib/bmg/operator/undress.rb
 - lib/bmg/operator/ungroup.rb
 - lib/bmg/operator/union.rb
 - lib/bmg/operator/unwrap.rb
@@ -296,6 +313,7 @@ files:
 - lib/bmg/summarizer/value_by.rb
 - lib/bmg/summarizer/variance.rb
 - lib/bmg/support.rb
+- lib/bmg/support/factory.rb
 - lib/bmg/support/keys.rb
 - lib/bmg/support/ordering.rb
 - lib/bmg/support/output_preferences.rb
@@ -305,6 +323,7 @@ files:
 - lib/bmg/version.rb
 - lib/bmg/writer.rb
 - lib/bmg/writer/csv.rb
+- lib/bmg/writer/text.rb
 - lib/bmg/writer/xlsx.rb
 - lib/bmg/xlsx.rb
 - tasks/gem.rake
@@ -313,7 +332,7 @@ homepage: http://github.com/enspirit/bmg
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -329,7 +348,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.27
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Bmg is Alf's successor.
 test_files: []