bmg 0.1.0

data/lib/bmg/operator/rename.rb

@@ -0,0 +1,45 @@
+module Bmg
+  module Operator
+    #
+    # Rename operator.
+    #
+    # Rename some attribute of input tuples, according to a renaming Hash.
+    #
+    # Example:
+    #
+    #   [{ a: 1, b: 2 }] rename {:b => :c} => [{ a: 1, c: 2 }]
+    #
+    # Keys of the renaming Hash SHOULD be existing attributes of the
+    # input tuples. Values of the renaming Hash SHOULD NOT be existing
+    # attributes of the input tuples.
+    #
+    class Rename
+      include Operator
+
+      def initialize(operand, renaming)
+        @operand = operand
+        @renaming = renaming
+      end
+
+      def each
+        @operand.each do |tuple|
+          yield rename(tuple)
+        end
+      end
+
+    private
+
+      def rename(tuple)
+        tuple.each_with_object({}){|(k,v),h|
+          h[rename_key(k)] = v
+          h
+        }
+      end
+
+      def rename_key(k)
+        @renaming[k] || k
+      end
+
+    end # class Rename
+  end # module Operator
+end # module Bmg

data/lib/bmg/reader.rb

@@ -0,0 +1,11 @@
+module Bmg
+  module Reader
+
+    def to_a
+      to_enum(:each).to_a
+    end
+
+  end
+end
+require_relative "reader/csv"
+require_relative "reader/excel"

data/lib/bmg/reader/csv.rb

@@ -0,0 +1,56 @@
+module Bmg
+  module Reader
+    class Csv
+      include Reader
+
+      DEFAULT_OPTIONS = {
+        :headers => true,
+        :return_headers => false
+      }
+
+      def initialize(path, options = {})
+        @path = path
+        @options = DEFAULT_OPTIONS.merge(options)
+        @options[:col_sep] ||= infer_col_sep
+        @options[:quote_char] ||= infer_quote_char
+      end
+
+      def each
+        require 'csv'
+        ::CSV.foreach(@path, @options) do |row|
+          yield tuple(row)
+        end
+      end
+
+    private
+
+      def tuple(row)
+        row.to_hash.each_with_object({}){|(k,v),h| h[k.to_sym] = v }
+      end
+
+      def infer_col_sep
+        sniff(text_portion, [",","\t",";"], ",")
+      end
+
+      def infer_quote_char
+        sniff(text_portion, ["'","\""], "\"")
+      end
+
+      def text_portion
+        @text_portion ||= File.foreach(@path).first(10).join("\n")
+      end
+
+      # Finds the best candidate among `candidates` for a separator
+      # found in `str`. If none is found, returns `default`.
+      def sniff(str, candidates, default)
+        snif = {}
+        candidates.each {|delim|
+          snif[delim] = str.count(delim)
+        }
+        snif = snif.sort {|a,b| b[1] <=> a[1] }
+        snif.size > 0 ? snif[0][0] : default
+      end
+
+    end # class Csv
+  end # module Reader
+end # module Bmg

data/lib/bmg/reader/excel.rb

@@ -0,0 +1,35 @@
+module Bmg
+  module Reader
+    class Excel
+      include Reader
+
+      DEFAULT_OPTIONS = {
+        skip: 0
+      }
+
+      def initialize(path, options = {})
+        @path = path
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def each
+        require 'roo'
+        xlsx = Roo::Spreadsheet.open(@path)
+        headers = nil
+        xlsx.sheet(0)
+          .each
+          .drop(@options[:skip])
+          .each_with_index
+          .each do |row, i|
+            if i==0
+              headers = row.map(&:to_sym)
+            else
+              tuple = (0...headers.size).each_with_object({}){|i,t| t[headers[i]] = row[i] }
+              yield(tuple)
+            end
+          end
+      end
+
+    end # class Excel
+  end # module Reader
+end # module Bmg

data/lib/bmg/relation.rb

@@ -0,0 +1,34 @@
+module Bmg
+  class Relation
+    include Enumerable
+
+    def initialize(operand)
+      @operand = operand
+    end
+
+    def each(&bl)
+      @operand.each(&bl)
+    end
+
+    def allbut(butlist = [])
+      Relation.new Operator::Allbut.new(@operand, butlist)
+    end
+
+    def autowrap(options = {})
+      Relation.new Operator::Autowrap.new(@operand, options)
+    end
+
+    def autosummarize(by = [], summarization = {})
+      Relation.new Operator::Autosummarize.new(@operand, by, summarization)
+    end
+
+    def project(attrlist = [])
+      Relation.new Operator::Project.new(@operand, attrlist)
+    end
+
+    def rename(renaming = {})
+      Relation.new Operator::Rename.new(@operand, renaming)
+    end
+
+  end # class Relation
+end # module Bmg

data/lib/bmg/version.rb

@@ -0,0 +1,8 @@
+module Bmg
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+  end
+  VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
+end

data/spec/unit/operator/test_allbut.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Bmg
+  module Operator
+    describe Allbut do
+
+      it 'works' do
+        allbut = Allbut.new [{ a: 1, b: 2 }], [:b]
+        expect(allbut.to_a).to eql([{ a: 1 }])
+      end
+
+      it 'removes duplicates' do
+        allbut = Allbut.new [{ a: 1, b: 2 }, { a: 1, b: 3 }], [:b]
+        expect(allbut.to_a).to eql([{ a: 1 }])
+      end
+
+    end
+  end
+end

data/spec/unit/operator/test_autosummarize.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+module Bmg
+  module Operator
+    describe Autosummarize do
+
+      context 'with empty by and no sums' do
+        let(:by)  { [] }
+        let(:sums){ {} }
+
+        it 'filters same tuples' do
+          autosummarize = Autosummarize.new [
+            { a: 1 },
+            { a: 1 }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([{ a: 1 }])
+        end
+      end
+
+      context 'with a determinant and no sums' do
+        let(:by)  { [:a] }
+        let(:sums){ {} }
+
+        it 'applies Same to every unknown dependent' do
+          autosummarize = Autosummarize.new [
+            { a: 1, b: 2 },
+            { a: 1, b: 2 },
+            { a: 2, b: 2 },
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { a: 1, b: 2 },
+            { a: 2, b: 2 }
+          ])
+        end
+      end
+
+      context 'with a by and a DistinctList without comparator' do
+        let(:by)  { [ :id ] }
+        let(:sums){ { :a => Autosummarize::DistinctList.new } }
+
+        it 'groups as expected' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: 1 },
+            { id: 1, a: 2 },
+            { id: 2, a: 1 },
+            { id: 1, a: 2 }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: [1, 2] },
+            { id: 2, a: [1] },
+          ])
+        end
+
+        it 'ignores nulls' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: 1   },
+            { id: 1, a: nil }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: [1] },
+          ])
+        end
+
+        it 'can be used to mimic the Group operator' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: { x: 1, y: 2 } },
+            { id: 1, a: { x: 2, y: 2 } },
+            { id: 2, a: { x: 1, y: 2 } },
+            { id: 1, a: { x: 1, y: 2 } }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: [{ x: 1, y: 2 }, { x: 2, y: 2 }] },
+            { id: 2, a: [{ x: 1, y: 2 }] },
+          ])
+        end
+
+        it 'supports the :group shortcut' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: 1 },
+            { id: 1, a: 2 },
+            { id: 2, a: 1 },
+            { id: 1, a: 2 }
+          ], by, { :a => :group }
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: [1, 2] },
+            { id: 2, a: [1] },
+          ])
+        end
+
+      end
+
+      context 'with a by and a DistinctList with a comparator' do
+        let(:by)  { [ :id ] }
+        let(:sums){ { :a => Autosummarize::DistinctList.new{|x,y| y <=> x } } }
+
+        it 'groups as expected' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: 1 },
+            { id: 1, a: 2 },
+            { id: 2, a: 1 },
+            { id: 1, a: 2 }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: [2, 1] },
+            { id: 2, a: [1] },
+          ])
+        end
+      end
+
+      context 'with a YByX ignoring nulls' do
+        let(:by)  { [ :id ] }
+        let(:sums){ { :a => Autosummarize::YByX.new(:y, :x) } }
+
+        it 'groups as expected and ignores nulls' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: { x: "foo", y: "bar" } },
+            { id: 1, a: { x: "foo", y: "baz" } },
+            { id: 1, a: { x: "gri", y: "gra" } },
+            { id: 1, a: { x: "gro", y: nil   } },
+            { id: 1, a: { x: nil,   y: "gru" } },
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: { "foo" => "baz", "gri" => "gra" } }
+          ])
+        end
+      end
+
+      context 'with a YByX preserving nulls' do
+        let(:by)  { [ :id ] }
+        let(:sums){ { :a => Autosummarize::YByX.new(:y, :x, true) } }
+
+        it 'groups as expected and ignores nulls' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: { x: "foo", y: "bar" } },
+            { id: 1, a: { x: "foo", y: "baz" } },
+            { id: 1, a: { x: "gri", y: "gra" } },
+            { id: 1, a: { x: "gro", y: nil   } },
+            { id: 1, a: { x: nil,   y: "gru" } },
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: { "foo" => "baz", "gri" => "gra", "gro" => nil } }
+          ])
+        end
+      end
+
+      context 'with a by and a YsByX and no sorter' do
+        let(:by)  { [ :id ] }
+        let(:sums){ { :a => Autosummarize::YsByX.new(:y, :x) } }
+
+        it 'filters same tuples' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: { x: 1, y: 3 } },
+            { id: 1, a: { x: 1, y: 2 } },
+            { id: 2, a: { x: 1, y: 1 } },
+            { id: 1, a: { x: 2, y: 7 } }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: { 1 => [3, 2], 2 => [7] } },
+            { id: 2, a: { 1 => [1] } }
+          ])
+        end
+      end
+
+      context 'with a by and a YsByX and a sorter' do
+        let(:by)  { [ :id ] }
+        let(:sums){ { :a => Autosummarize::YsByX.new(:y, :x){|u,v| u[:y] <=> v[:y] } } }
+
+        it 'filters same tuples' do
+          autosummarize = Autosummarize.new [
+            { id: 1, a: { x: 1, y: 3 } },
+            { id: 1, a: { x: 1, y: 2 } },
+            { id: 2, a: { x: 1, y: 1 } },
+            { id: 1, a: { x: 2, y: 7 } }
+          ], by, sums
+          expect(autosummarize.to_a).to eql([
+            { id: 1, a: { 1 => [2, 3], 2 => [7] } },
+            { id: 2, a: { 1 => [1] } }
+          ])
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/operator/test_autowrap.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+module Bmg
+  module Operator
+    describe 'Autowrap' do
+
+      context 'when called in default mode' do
+
+        it 'works as an array by default' do
+          autowrap = Autowrap.new [{ a: 1, b: 2 }]
+          expect(autowrap.to_a).to eql([{ a: 1, b: 2 }])
+        end
+
+        it 'wrap levels 1' do
+          autowrap = Autowrap.new [{ a: 1, b_x: 2, b_y: 3 }]
+          expect(autowrap.to_a).to eql([{ a: 1, b: { x: 2, y: 3 } }])
+        end
+
+        it 'wrap levels 2' do
+          autowrap = Autowrap.new [{ a: 1, b_x_u: 2, b_y_v: 3, b_y_w: 4 }]
+          expect(autowrap.to_a).to eql([{ a: 1, b: { x: { u: 2 }, y: { v: 3, w: 4 } } }])
+        end
+
+        it 'keeps LEFT JOIN nils unchanged' do
+          autowrap = Autowrap.new [{ a: 1, b_x: nil, b_y: nil }]
+          expect(autowrap.to_a).to eql([{ a: 1, b: { x: nil, y: nil } }])
+        end
+
+      end
+
+      context 'when specifying the separator to use' do
+
+        it 'works as expected' do
+          autowrap = Autowrap.new [{ :a => 1, :"b.x.u" => 2, "b.y.v" => 3, "b.y.w" => 4 }], split: '.'
+          expect(autowrap.to_a).to eql([{ a: 1, b: { x: { u: 2 }, y: { v: 3, w: 4 } } }])
+        end
+
+      end
+
+      context 'when called with a Proc post processor' do
+
+        let(:post) {
+          ->(t,_){ t.delete(:user) if t[:user][:id].nil?; t }
+        }
+
+        it 'wrap levels 2' do
+          aw = Autowrap.new [
+            { user_id: 1, user_name: "foo", foo: "bar" },
+            { user_id: nil, user_name: nil, foo: "baz" }
+          ], postprocessor: post
+          expected = [
+            { user: {id: 1, name: "foo"}, foo: "bar" },
+            { foo: "baz" }
+          ]
+          expect(aw.to_a).to eql(expected)
+        end
+
+      end
+
+      context 'when called with :delete post processor' do
+
+        it 'automatically removes the results of nil LEFT JOINs' do
+          autowrap = Autowrap.new [{ a: 1, b_x: nil, b_y: nil }], postprocessor: :delete
+          expect(autowrap.to_a).to eql([{ a: 1 }])
+        end
+
+      end
+
+      context 'when called with :nil post processor' do
+
+        it 'sets the results of nil LEFT JOINs to nil' do
+          autowrap = Autowrap.new [{ a: 1, b_x: nil, b_y: nil }], postprocessor: :nil
+          expect(autowrap.to_a).to eql([{ a: 1, b: nil }])
+        end
+
+      end
+
+      context 'when called with a Hash post processor' do
+
+        it 'sets the results of nil LEFT JOINs to nil' do
+          autowrap = Autowrap.new [{ a: 1, b_x: nil, b_y: nil, c_x: nil, c_y: nil, d_x: nil }], postprocessor: { b: :nil, c: :delete }
+          expect(autowrap.to_a).to eql([{ a: 1, b: nil, d: { x: nil } }])
+        end
+
+      end
+
+    end
+  end
+end