bmg 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e90b71aeb478997a7f9efcea3a18cec7ad3fac3
-  data.tar.gz: 9ebdd9b06a635ef12cef5d7c35d4746a56932bba
+  metadata.gz: c6fe9a06a0c6fbf5f5f0523b3ade5d59ac077c3b
+  data.tar.gz: 3d0dd15b128fe42a6eb603b922de1c8889d266c8
 SHA512:
-  metadata.gz: a662b415f76df21dfad0d4e4b6f7c9dece45c994a7200c4d547f21007fd8158812a0e8c0fb263f0e4d3da597d334e03ed8394a28b052927f7f58081bf65ee392
-  data.tar.gz: 520d850977384a3cff1aa7e8fe58f52ea34e9f7f8caa0d9ec1f4849a92bab50814bbdaeb4ad8b0cd551ab8b3424d1d57f42fbab51bbe22fa7f6824e5aa610159
+  metadata.gz: e608c650a868dc5d4870a6847675dbae8742525a53e255732c6634c85b911f31528d7a57cbd580eb74c3f85610590abfb0e792532a71dee23cf61b20e15aa713
+  data.tar.gz: 1b082e58ffce43e55e85ff36753b0d2d5e579e947a44010dd85a839e82ca4f6a371cb882ae32bc6b34e159936e0f21e1e8f8e944ef4ada4d43ff92ee48fa9b3d

data/lib/bmg/reader/excel.rb

@@ -14,7 +14,7 @@ module Bmg
 
       def each
         require 'roo'
-        xlsx = Roo::Spreadsheet.open(@path)
+        xlsx = Roo::Spreadsheet.open(@path, @options)
         headers = nil
         xlsx.sheet(0)
           .each

data/lib/bmg/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -89,18 +89,6 @@ files:
 - lib/bmg/reader/excel.rb
 - lib/bmg/relation.rb
 - lib/bmg/version.rb
-- spec/unit/operator/test_allbut.rb
-- spec/unit/operator/test_autosummarize.rb
-- spec/unit/operator/test_autowrap.rb
-- spec/unit/operator/test_project.rb
-- spec/unit/operator/test_rename.rb
-- spec/unit/reader/example.csv
-- spec/unit/reader/example.numbers
-- spec/unit/reader/example.xlsx
-- spec/unit/reader/test_csv.rb
-- spec/unit/reader/test_excel.rb
-- spec/unit/spec_helper.rb
-- spec/unit/test_relation.rb
 - tasks/gem.rake
 - tasks/test.rake
 homepage: http://github.com/enspirit/bmg
@@ -123,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Bmg is Alf's successor.

data/spec/unit/operator/test_allbut.rb

@@ -1,18 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

data/spec/unit/operator/test_project.rb

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

data/spec/unit/operator/test_rename.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-module Bmg
-  module Operator
-    describe Rename do
-
-      it 'works' do
-        rename = Rename.new [{ a: 1, b: 2 }], :a => :x
-        expect(rename.to_a).to eql([{ x: 1, b: 2 }])
-      end
-
-    end
-  end
-end

data/spec/unit/reader/example.csv

@@ -1,3 +0,0 @@
-id;name
-1;Bernard Lambeau
-2;"Yoann;Guyot"

data/spec/unit/reader/test_csv.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Bmg
-  module Reader
-    describe Csv do
-
-      it 'works' do
-        file = Path.dir/("example.csv")
-        csv = Csv.new(file)
-        expect(csv.to_a).to eql([
-          {id: "1", name: "Bernard Lambeau"},
-          {id: "2", name: "Yoann;Guyot"}
-        ])
-      end
-
-    end
-  end
-end

data/spec/unit/reader/test_excel.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Bmg
-  module Reader
-    describe Csv do
-
-      it 'works' do
-        file = Path.dir/("example.xlsx")
-        xlsx = Excel.new(file, skip: 1)
-        expect(xlsx.to_a).to eql([
-          {id: 1, name: "Bernard Lambeau"},
-          {id: 2, name: "Yoann Guyot"}
-        ])
-      end
-
-    end
-  end
-end

data/spec/unit/spec_helper.rb

@@ -1,11 +0,0 @@
-require 'rspec'
-require 'bmg'
-require 'path'
-
-module SpecHelper
-
-end
-
-RSpec.configure do |c|
-  c.include SpecHelper
-end

data/spec/unit/test_relation.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-module Bmg
-  describe Relation do
-
-    shared_examples_for "an operator method" do
-
-      it 'returns a relation' do
-        expect(subject).to be_a(Relation)
-      end
-
-    end
-
-    describe 'allbut' do
-      let(:relation) {
-        Relation.new([
-          { a: 1, b: 2 },
-          { a: 1, b: 4 },
-          { a: 3, b: 4 }
-        ])
-      }
-
-      subject {
-        relation.allbut([:b])
-      }
-
-      it_behaves_like "an operator method"
-
-      it 'returns the exected result' do
-        expect(subject.to_a).to eql([
-          { a: 1 },
-          { a: 3 }
-        ])
-      end
-    end
-
-    describe 'autosummarize' do
-      let(:relation) {
-        Relation.new([
-          { a: 1, x: 2 },
-          { a: 1, x: 4 }
-        ])
-      }
-
-      subject {
-        relation.autosummarize([:a], x: Operator::Autosummarize::DistinctList.new)
-      }
-
-      it_behaves_like "an operator method"
-
-      it 'returns the exected result' do
-        expect(subject.to_a).to eql([
-          { a: 1, x: [2, 4] }
-        ])
-      end
-    end
-
-    describe 'autowrap' do
-      let(:relation) {
-        Relation.new([
-          { a: 1, b_x: 2, b_y: 3 },
-          { a: 2, b_x: 4, b_y: 1 }
-        ])
-      }
-
-      subject {
-        relation.autowrap
-      }
-
-      it_behaves_like "an operator method"
-
-      it 'returns the exected result' do
-        expect(subject.to_a).to eql([
-          { a: 1, b: { x: 2, y: 3 } },
-          { a: 2, b: { x: 4, y: 1 } }
-        ])
-      end
-
-      it 'passes the options' do
-        expect(relation.autowrap(split: ".").to_a).to eql([
-          { a: 1, b_x: 2, b_y: 3 },
-          { a: 2, b_x: 4, b_y: 1 }
-        ])
-      end
-    end
-
-    describe 'project' do
-      let(:relation) {
-        Relation.new([
-          { a: 1, b: 2 },
-          { a: 1, b: 4 },
-          { a: 3, b: 4 }
-        ])
-      }
-
-      subject {
-        relation.project([:b])
-      }
-
-      it_behaves_like "an operator method"
-
-      it 'returns the exected result' do
-        expect(subject.to_a).to eql([
-          { b: 2 },
-          { b: 4 }
-        ])
-      end
-    end
-
-    describe 'rename' do
-      let(:relation) {
-        Relation.new([
-          { a: 1, b: 2 },
-          { a: 2, b: 4 }
-        ])
-      }
-
-      subject {
-        relation.rename(b: :c)
-      }
-
-      it_behaves_like "an operator method"
-
-      it 'returns the exected result' do
-        expect(subject.to_a).to eql([
-          { a: 1, c: 2 },
-          { a: 2, c: 4 }
-        ])
-      end
-    end
-
-  end # describe Relation
-end # module Bmg