bmg 0.18.11 → 0.18.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eda140880e29f5e083ad334176579ed2dfad9090
-  data.tar.gz: 444a8cc5f96b80ba3bbf6d807be1438c2d26abd7
+  metadata.gz: 14260453d9c3f5d24b5ef6975072e452af309485
+  data.tar.gz: f6de19178d2b4404c9fbe248d42f9c596cee410e
 SHA512:
-  metadata.gz: 96ecc393e90d3ae413655d70c4b1676fa2f9831e519ef61cbd25139b873efcd75a825745cce0597e083fc59bc331b08d30b5717b1e5b42adacb5297147a044bd
-  data.tar.gz: dc687db5b22f9f3fc53b2ccf0916722065ca7d25b8ad04b0a042c6d79fd66f40c22f2d05461da8019db8b70f54c4c104658f3dce3862f9a37b2af44c6ee25d61
+  metadata.gz: e53da5df4abb7095036dc275948a70e4af9f1945e2fd446244e765d7fead1258a9e564d9076baa3efc4ee29566810a5176c76d2c3c953de906a7ff36a3a86dff
+  data.tar.gz: a6f0cb03795e5b954563f774bc65c7879a78049928d06da935017a8dfcdb2bdd563c4ab08922cb95f774d68714ab108bb480d0722249ec5e6cc67fed5ed0064a

data/lib/bmg/algebra.rb

@@ -12,6 +12,7 @@ module Bmg
     protected :_allbut
 
     def autowrap(options = {})
+      return self if self.type.identity_autowrap?(options)
       _autowrap self.type.autowrap(options), options
     end
 
@@ -20,12 +21,12 @@ module Bmg
     end
     protected :_autowrap
 
-    def autosummarize(by = [], summarization = {})
-      _autosummarize type = self.type.autosummarize(by, summarization), by, summarization
+    def autosummarize(by = [], summarization = {}, options = {})
+      _autosummarize self.type.autosummarize(by, summarization, options), by, summarization, options
     end
 
-    def _autosummarize(type, by, summarization)
-      Operator::Autosummarize.new(type, self, by, summarization)
+    def _autosummarize(type, by, summarization, options)
+      Operator::Autosummarize.new(type, self, by, summarization, options)
     end
     protected :_autosummarize
 

data/lib/bmg/operator/autosummarize.rb

@@ -11,16 +11,22 @@ module Bmg
     class Autosummarize
       include Operator::Unary
 
-      def initialize(type, operand, by, sums)
+      DEFAULT_OPTIONS = {
+        default: :same
+      }
+
+      def initialize(type, operand, by, sums, options = {})
         @type = type
         @operand = operand
         @by = by
         @sums = sums.each_with_object({}){|(k,v),h| h[k] = to_summarizer(v) }
+        @options = DEFAULT_OPTIONS.merge(options)
+        @algo = build_algo
       end
 
     protected
 
-      attr_reader :by, :sums
+      attr_reader :by, :sums, :options
 
     public
 
@@ -45,17 +51,17 @@ module Bmg
         h = {}
         @operand.each do |tuple|
           key = key(tuple)
-          h[key] ||= init(key, tuple)
-          h[key] = sum(h[key], tuple)
+          h[key] ||= @algo.init(tuple)
+          h[key] = @algo.sum(h[key], tuple)
         end
         h.each_pair do |k,v|
-          h[k] = term(v)
+          h[k] = @algo.term(v)
         end
         h.values.each(&bl)
       end
 
       def to_ast
-        [:autosummarize, operand.to_ast, by.dup, sums.dup]
+        [:autosummarize, operand.to_ast, by.dup, sums.dup, options.dup]
       end
 
     public ### for internal reasons
@@ -73,7 +79,7 @@ module Bmg
         else
           op = operand
           op = op.restrict(bottom)
-          op = op.autosummarize(by, sums)
+          op = op.autosummarize(by, sums, options)
           op = op.restrict(top)
           op
         end
@@ -87,46 +93,86 @@ module Bmg
 
     private
 
+      def build_algo
+        case default = @options[:default]
+        when :same  then Check.new(sums)
+        when :first then Trust.new(sums)
+        else
+          raise ArgumentError, "Unknown default summarizer: `#{default}`"
+        end
+      end
+
       # Returns the tuple determinant.
       def key(tuple)
         @by.map{|by| tuple[by] }
       end
 
-      # Returns the initial tuple to use for a given determinant.
-      def init(key, tuple)
-        tuple.each_with_object({}){|(k,v),h|
-          h.merge!(k => summarizer(k).init(v))
-        }
-      end
-
-      # Returns the summarizer to use for a given key.
-      def summarizer(k)
-        @sums[k] || Same.new
-      end
-
-      # Sums `tuple` on `memo`, returning the new tuple to use as memo.
-      def sum(memo, tuple)
-        tuple.each_with_object(memo.dup){|(k,v),h|
-          h.merge!(k => summarizer(k).sum(h[k], v))
-        }
-      end
-
-      # Terminates the summarization of a given tuple.
-      def term(tuple)
-        tuple.each_with_object({}){|(k,v),h|
-          h.merge!(k => summarizer(k).term(v))
-        }
-      end
-
       def to_summarizer(x)
         case x
-        when :same  then Same.new
-        when :group then DistinctList.new
+        when :same  then Same::INSTANCE
+        when :group then DistinctList::INSTANCE
         else
           x
         end
       end
 
+      class Check
+        def initialize(sums)
+          @sums = sums
+        end
+        attr_reader :sums
+
+        def summarizer(k)
+          @sums[k] ||= Same::INSTANCE
+        end
+
+        def init(tuple)
+          tuple.each_with_object({}){|(k,v),h|
+            h.merge!(k => summarizer(k).init(v))
+          }
+        end
+
+        def sum(memo, tuple)
+          tuple.each_with_object(memo.dup){|(k,v),h|
+            h.merge!(k => summarizer(k).sum(h[k], v))
+          }
+        end
+
+        def term(tuple)
+          tuple.each_with_object({}){|(k,v),h|
+            h.merge!(k => summarizer(k).term(v))
+          }
+        end
+      end # class Check
+
+      class Trust
+        def initialize(sums)
+          @sums = sums
+        end
+        attr_reader :sums
+
+        # Returns the initial tuple to use for a given determinant.
+        def init(tuple)
+          sums.each_with_object(tuple.dup){|(attribute,summarizer),new_tuple|
+            new_tuple[attribute] = summarizer.init(tuple[attribute])
+          }
+        end
+
+        # Sums `tuple` on `memo`, returning the new tuple to use as memo.
+        def sum(memo, tuple)
+          sums.each_with_object(memo.dup){|(attribute,summarizer),new_tuple|
+            new_tuple[attribute] = summarizer.sum(memo[attribute], tuple[attribute])
+          }
+        end
+
+        # Terminates the summarization of a given tuple.
+        def term(tuple)
+          sums.each_with_object(tuple.dup){|(attribute,summarizer),new_tuple|
+            new_tuple[attribute] = summarizer.term(tuple[attribute])
+          }
+        end
+      end # class Trust
+
       #
       # Summarizes by enforcing that the same dependent is observed for a given
       # determinant, returning the dependent as summarization.
@@ -138,7 +184,7 @@ module Bmg
         end
 
         def sum(v1, v2)
-          raise "Same values expected, got `#{v1}` vs. `#{v2}`" unless v1 == v2
+          raise TypeError, "Same values expected, got `#{v1}` vs. `#{v2}`" unless v1 == v2
           v1
         end
 
@@ -151,6 +197,7 @@ module Bmg
         end
         alias :to_s :inspect
 
+        INSTANCE = new
       end # class Same
 
       #
@@ -183,6 +230,7 @@ module Bmg
         end
         alias :to_s :inspect
 
+        INSTANCE = new
       end # class DistinctList
 
       #

data/lib/bmg/operator/autowrap.rb

@@ -26,6 +26,12 @@ module Bmg
         :split => "_"
       }
 
+      class << self
+        def separator(options)
+          options[:split] || DEFAULT_OPTIONS[:split]
+        end
+      end
+
       def initialize(type, operand, options = {})
         @type = type
         @operand = operand

data/lib/bmg/operator/page.rb

@@ -32,7 +32,8 @@ module Bmg
       def each(&bl)
         return to_enum unless block_given?
         page_size = options[:page_size]
-        @operand.to_a
+        @operand
+          .to_a
           .sort(&comparator)
           .drop(page_size * (page_index-1))
           .take(page_size)
@@ -46,7 +47,7 @@ module Bmg
     protected ### inspect
 
       def comparator
-        Ordering.new(@ordering).comparator
+        @comparator ||= Ordering.new(@ordering).comparator
       end
 
       def args

data/lib/bmg/reader/csv.rb

@@ -10,20 +10,18 @@ module Bmg
       }
 
       def initialize(type, path_or_io, options = {})
-        @type = type
+        require 'csv'
+
         @path_or_io = path_or_io
-        @options = DEFAULT_OPTIONS.merge(options)
-        if @options[:smart] && !@path_or_io.is_a?(IO)
-          @options[:col_sep] ||= infer_col_sep
-          @options[:quote_char] ||= infer_quote_char
-        end
+        @options = handle_options(options)
+        @type = handle_type(type)
       end
 
       def each
         return to_enum unless block_given?
-        require 'csv'
-        with_io do |io|
-          ::CSV.new(io, **csv_options).each do |row|
+
+        with_csv do |csv|
+          csv.each do |row|
             yield tuple(row)
           end
         end
@@ -44,33 +42,70 @@ module Bmg
         row.to_hash.each_with_object({}){|(k,v),h| h[k.to_sym] = v }
       end
 
+      def handle_type(type)
+        return type if type.knows_attrlist?
+
+        type.with_attrlist(infer_attrlist)
+      end
+
+      def infer_attrlist
+        with_csv do |csv|
+          csv.each do |row|
+            return tuple(row).keys
+          end
+        end
+      end
+
+      def handle_options(options)
+        options = DEFAULT_OPTIONS.merge(options)
+        if options[:smart] && !@path_or_io.is_a?(IO)
+          options[:col_sep] ||= infer_col_sep
+          options[:quote_char] ||= infer_quote_char(options[:col_sep])
+        end
+        options
+      end
+
       def infer_col_sep
         sniff(text_portion, [",","\t",";"], ",")
       end
 
-      def infer_quote_char
-        sniff(text_portion, ["'","\""], "\"")
+      def infer_quote_char(col_sep)
+        sniff(text_portion, ['"',"'"], '"'){|quote|
+          /#{quote}#{col_sep}#{quote}|^#{quote}|#{quote}$/
+        }
       end
 
       def text_portion
-        @text_portion ||= with_io{|io| io.readlines(10).join("\n") }
+        @text_portion ||= with_io{|io| io.readlines(50).join("\n") }
       end
 
       def with_io(&bl)
         case @path_or_io
         when IO, StringIO
+          @path_or_io.rewind if @path_or_io.respond_to?(:rewind)
           bl.call(@path_or_io)
         else
           File.open(@path_or_io, "r", &bl)
         end
       end
 
+      def with_csv(&bl)
+        with_io do |io|
+          yield ::CSV.new(io, **csv_options)
+        end
+      end
+
       # Finds the best candidate among `candidates` for a separator
       # found in `str`. If none is found, returns `default`.
-      def sniff(str, candidates, default)
+      def sniff(str, candidates, default, &bl)
         snif = {}
         candidates.each {|delim|
-          snif[delim] = str.count(delim)
+          counter = bl ? bl.call(delim) : delim
+          snif[delim] = if counter.is_a?(Regexp)
+            str.scan(counter).length
+          else
+            str.count(counter)
+          end
         }
         snif = snif.sort {|a,b| b[1] <=> a[1] }
         snif.size > 0 ? snif[0][0] : default

data/lib/bmg/reader/excel.rb

@@ -10,32 +10,27 @@ module Bmg
       }
 
       def initialize(type, path, options = {})
-        @type = type
+        require 'roo'
         @path = path
         @options = DEFAULT_OPTIONS.merge(options)
+        @type = type.knows_attrlist? ? type : type.with_attrlist(infer_attrlist)
       end
 
       def each
         return to_enum unless block_given?
-        require 'roo'
-        xlsx = Roo::Spreadsheet.open(@path, @options)
-        headers = nil
-        xlsx.sheet(@options[:sheet])
-          .each
-          .drop(@options[:skip])
-          .each_with_index
-          .each do |row, i|
-            if i==0
-              headers = row.map{|c| c.to_s.strip.to_sym }
-            else
-              init = init_tuple(i)
-              tuple = (0...headers.size)
-                .each_with_object(init){|i,t|
-                  t[headers[i]] = row[i]
-                }
-              yield(tuple)
-            end
-          end
+
+        headers = type.attrlist
+        headers = headers[1..-1] if generate_row_num?
+        start_at = @options[:skip] + 2
+        end_at = spreadsheet.last_row
+        (start_at..end_at).each do |i|
+          row = spreadsheet.row(i)
+          init = init_tuple(i - start_at + 1)
+          tuple = (0...headers.size).each_with_object(init){|i,t|
+            t[headers[i]] = row[i]
+          }
+          yield(tuple)
+        end
       end
 
       def to_ast
@@ -49,17 +44,37 @@ module Bmg
 
     private
 
-      def init_tuple(i)
+      def spreadsheet
+        @spreadsheet ||= Roo::Spreadsheet
+          .open(@path, @options)
+          .sheet(@options[:sheet])
+      end
+
+      def infer_attrlist
+        row = spreadsheet.row(1+@options[:skip])
+        attrlist = row.map{|c| c.to_s.strip.to_sym }
+        attrlist.unshift(row_num_name) if generate_row_num?
+        attrlist
+      end
+
+      def generate_row_num?
+        !!@options[:row_num]
+      end
+
+      def row_num_name
         case as = @options[:row_num]
-        when TrueClass
-          { :row_num => i }
-        when FalseClass
-          {}
-        when Symbol
-          { :"#{as}" => i }
+        when TrueClass  then :row_num
+        when Symbol     then as
+        else nil
         end
       end
 
+      def init_tuple(i)
+        return {} unless generate_row_num?
+
+        { row_num_name => i }
+      end
+
     end # class Excel
   end # module Reader
-end # module Bmg
+end # module Bmg

data/lib/bmg/relation/materialized.rb

@@ -5,6 +5,7 @@ module Bmg
 
       def initialize(operand)
         @operand = operand
+        @materialized = nil
       end
 
       def type
@@ -19,14 +20,14 @@ module Bmg
     public
 
       def _count
-        operand._count
+        _materialize._count
       end
 
     public
 
       def each(&bl)
-        @operand = Relation::InMemory.new(operand.type, operand.to_a) unless @operand.is_a?(Relation::InMemory)
-        @operand.each(&bl)
+        return to_enum unless block_given?
+        _materialize.each(&bl)
       end
 
       def to_ast
@@ -37,6 +38,14 @@ module Bmg
         []
       end
 
+    private
+
+      def _materialize
+        return @materialized if @materialized
+
+        @materialized = Relation::InMemory.new(operand.type, operand.to_a)
+      end
+
     end # class Materialized
   end # module Relation
 end # module Bmg

data/lib/bmg/relation/spied.rb

@@ -24,13 +24,27 @@ module Bmg
       protected :type=
 
       def each(&bl)
-        spy.call(self) if bl
-        operand.each(&bl)
+        return enum_for(:each) unless bl
+
+        if spy.respond_to?(:measure)
+          spy.measure(self) do
+            operand.each(&bl)
+          end
+        else
+          spy.call(self)
+          operand.each(&bl)
+        end
       end
 
       def count
-        spy.call(self) if bl
-        operand.count
+        if spy.respond_to?(:measure)
+          spy.measure(self) do
+            operand.count
+          end
+        else
+          spy.call(self)
+          operand.count
+        end
       end
 
       def to_ast

data/lib/bmg/support/ordering.rb

@@ -11,13 +11,26 @@ module Bmg
     end
 
     def comparator
-      @comparator ||= ->(t1, t2) {
-        attrs.each do |(attr,direction)|
-          c = t1[attr] <=> t2[attr]
-          return (direction == :desc ? -c : c) unless c==0
+      @comparator ||= ->(t1, t2) { compare_attrs(t1, t2) }
+    end
+
+    def compare_attrs(t1, t2)
+      attrs.each do |(attr,direction)|
+        a1, a2 = t1[attr], t2[attr]
+        if a1.nil? && a2.nil?
+          0
+        elsif a1.nil?
+          return direction == :desc ? -1 : 1
+        elsif a2.nil?
+          return direction == :desc ? 1 : -1
+        elsif a1.respond_to?(:<=>)
+          c = a1 <=> a2
+          unless c.nil? || c==0
+            return direction == :desc ? -c : c
+          end
         end
-        0
-      }
+      end
+      0
     end
 
   end # class Ordering

data/lib/bmg/type.rb

@@ -103,8 +103,15 @@ module Bmg
       }
     end
 
+    def identity_autowrap?(options)
+      return false unless knows_attrlist?
+
+      sep = Operator::Autowrap.separator(options)
+      self.attrlist.all?{|a| a.to_s.index(sep).nil? }
+    end
+
     def autowrap(options)
-      sep = options[:split] || Operator::Autowrap::DEFAULT_OPTIONS[:split]
+      sep = Operator::Autowrap.separator(options)
       splitter = ->(a){ a.to_s.split(sep).first }
       is_split = ->(a){ a.to_s.split(sep).size > 1 }
       dup.tap{|x|
@@ -115,7 +122,7 @@ module Bmg
       }
     end
 
-    def autosummarize(by, summarization)
+    def autosummarize(by, summarization, options)
       known_attributes!(by + summarization.keys) if typechecked? && knows_attrlist?
       dup.tap{|x|
         x.attrlist = nil

data/lib/bmg/version.rb

@@ -2,7 +2,7 @@ module Bmg
   module Version
     MAJOR = 0
     MINOR = 18
-    TINY  = 11
+    TINY  = 15
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.18.11
+  version: 0.18.15
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-11 00:00:00.000000000 Z
+date: 2022-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate