alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-io/test_reader.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader do
-
-    subject{ Reader }
-    it { should respond_to(:rash) }
-
-    describe "rash on a real IO" do
-      subject{ Reader.rash($stdin) }
-      it{ should be_a(Reader::Rash) }
-    end
-
-    describe "reader" do
-
-      specify "when associated" do
-        r = Reader.reader('suppliers.rash')
-        r.should be_a(Reader::Rash)
-      end
-
-      specify "when not associated" do
-        lambda{ Reader.reader('.noone') }.should raise_error
-      end
-
-      specify "when an IO" do
-        Reader.reader($stdin).should be_a(Reader::Rash)
-      end
-
-      specify "with options" do
-        r = Reader.reader('suppliers.rash', {:hello => "world"})
-        r.options.should == {:hello => "world"}
-      end
-
-    end
-
-  end
-end

data/spec/unit/alf-io/test_renderer.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renderer do
-
-    subject{ Renderer }
-
-    let(:input){ [{:a => 1}] }
-
-    it { should respond_to(:rash) }
-    it { should respond_to(:text) }
-    it { should respond_to(:csv)  }
-    it { should respond_to(:yaml) }
-
-    describe 'renderer' do
-      subject{ Renderer.renderer(:rash, []) }
-
-      it{ should be_a(Renderer) }
-    end
-
-    describe 'rash' do
-      subject{ Renderer.rash(input) }
-
-      it{ should be_a(Renderer::Rash) }
-    end
-
-    describe 'rash --pretty' do
-      subject{ Renderer.rash(input, {pretty: true}) }
-
-      it{ should be_a(Renderer::Rash) }
-
-      it 'should have correct options' do
-        subject.options.should eq(pretty: true)
-      end
-    end
-
-    describe 'text' do
-      subject{ Renderer.text(input) }
-
-      it{ should be_a(Renderer::Text) }
-    end
-
-  end
-end

data/spec/unit/alf-lang/functional/test_aggregation.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe "Aggregation methods" do
-      include Functional
-
-      let(:input){[
-        {:tested => 1,  :other => "b"},
-        {:tested => 30, :other => "a"},
-      ]}
-
-      let(:expected){[
-        {:tested => 30, :other => "a", :upcase => "A"},
-      ]}
-
-      context 'on sum' do
-        it "should have sum with immediate block" do
-          sum{|t| t.qty }.should be_a(Aggregator::Sum)
-        end
-
-        it "should have sum with a Proc" do
-          sum(->(t){ qty }).should be_a(Aggregator::Sum)
-        end
-      end
-
-      context 'on concat' do
-        it "should have concat with immediate block" do
-          concat{|t| t.name }.should be_a(Aggregator::Concat)
-        end
-
-        it "should have sum with a Proc" do
-          agg = concat(->(t){ t.name }, between: ', ')
-          agg.should be_a(Aggregator::Concat)
-          agg.options[:between].should eq(', ')
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/functional/test_relation.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe "Relation(...) literal" do
-      include Functional
-
-      describe 'on a single tuple' do
-        subject{ Relation(name: "Jones") }
-
-        it{ should eq(Alf::Relation.coerce([{name: "Jones"}])) }
-      end
-
-      describe 'on an array of tuples' do
-        subject{ Relation([{name: "Jones"}, {name: "Smith"}])}
-
-        it{ should eq(Alf::Relation.coerce([{name: "Jones"}, {name: "Smith"}])) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/functional/test_tuple.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe "Tuple(...) literal" do
-      include Functional
-
-      subject{ Tuple(h) }
-
-      describe 'on an empty tuple' do
-        let(:h){ {} }
-        it{ should eq(Tuple::EMPTY) }
-      end
-
-      describe 'on an valid tuple' do
-        let(:h){ {:name => "Alf"} }
-        it{ should eq(Tuple(name: "Alf")) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/object_oriented/test_rendering_methods.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe ObjectOriented do
-      include ObjectOriented.new(supplier_names_relation)
-
-      Renderer.each do |name,_,clazz|
-
-        describe "#to_#{name}" do
-          subject{ :"to_#{name}" }
-          it 'should exist' do
-            meths = ObjectOriented.instance_methods.map(&:to_sym)
-            meths.should include(subject)
-          end
-
-          it 'returns a string by default' do
-            send(subject).should be_a(String)
-          end
-
-          it 'renders the values at first glance' do
-            send(subject).should =~ /Adams/
-          end
-
-          it 'returns the passed IO if any' do
-            io = StringIO.new
-            send(subject, io).should eq(io)
-          end
-
-          it 'supports options' do
-            io = StringIO.new
-            send(subject, {:sort => [:name]}, io).should eq(io)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-lang/object_oriented/test_to_array.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe ObjectOriented, 'to_array' do
-      include ObjectOriented.new(supplier_names_relation)
-
-      let(:ordering){ Ordering.coerce([[:name, :desc]]) }
-
-      context 'with a block' do
-        it 'yields the block with a ToArray' do
-          seen = nil
-          to_array{|x| seen = x}
-          seen.should be_a(Engine::ToArray)
-        end
-
-        it 'returns the block result' do
-          to_array{|x| 12}.should eq(12)
-        end
-
-        it 'sets the ordering correctly' do
-          to_array(:sort => ordering){|x|
-            x.ordering.should eq(ordering)
-          }
-        end
-      end
-
-      context 'without a block' do
-        it 'returns an array' do
-          to_array.should be_a(Array)
-        end
-
-        it 'respect the specified ordering' do
-          expected = supplier_names.sort.reverse
-          got      = to_array(:sort => ordering).map{|t| t[:name]}
-          got.should eq(expected)
-
-          expected = supplier_names.sort
-          got      = to_array(:sort => [:name]).map{|t| t[:name]}
-          got.should eq(expected)
-        end
-      end
-
-    end
-  end # module Lang
-end # module Alf

data/spec/unit/alf-lang/object_oriented/test_to_rash.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe ObjectOriented, 'to_rash' do
-
-      include ObjectOriented.new(supplier_names_relation)
-
-      subject{
-        to_rash(options).each_line.map do |line|
-          ::Kernel.eval(line)
-        end
-      }
-
-      before do
-        subject.should be_a(Array)
-        subject.each{|t| t.should be_a(Hash)}
-      end
-
-      after do
-        Relation(subject).should eq(_self_operand)
-      end
-
-      context 'when an ordering is specified' do
-        let(:ordering){ [[:name, :desc]] }
-        let(:options){ {:sort => ordering} }
-        it 'respects it' do
-          expected = supplier_names.sort.reverse
-          subject.map{|t| t[:name]}.should eq(expected)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/object_oriented/test_tuple_extract.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe ObjectOriented, 'tuple_extract' do
-
-      def subject(&bl)
-        rel.extend(ObjectOriented.new(rel))
-        rel.tuple_extract(&bl)
-      end
-
-      context 'on a singleton' do
-        let(:rel)     { [{name: "Jones"}] }
-        let(:expected){ Tuple(name: "Jones") }
-
-        it 'returns the tuple' do
-          subject.should eq(expected)
-        end
-
-        it 'is aliased as tuple!' do
-          rel.extend(ObjectOriented.new(rel))
-          rel.tuple!.should eq(expected)
-        end
-      end
-
-      context 'on an empty relation' do
-        let(:rel){ [] }
-
-        it 'raises a NoSuchTupleError without block' do
-          lambda{
-            subject
-          }.should raise_error(NoSuchTupleError)
-        end
-
-        it 'yields if a block' do
-          subject{ {id: 12} }.should eq(Tuple(id: 12))
-        end
-      end
-
-      context 'on a relation with more than one tuple' do
-        let(:rel){ [{name: "Jones"}, {name: "Smith"}] }
-
-        it 'raises a NoSuchTupleError' do
-          lambda{
-            subject
-          }.should raise_error(NoSuchTupleError)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/parser/lispy/test_connection_bang.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    module Parser
-      describe Lispy, 'connection!' do
-
-        context 'when bound' do
-          let(:lispy){ Lispy.new([], 12) }
-
-          it 'allows obtaining its connection' do
-            lispy.connection!.should eq(12)
-          end
-        end
-
-        context 'when unbound' do
-          let(:lispy){ Lispy.new }
-
-          it 'raises when connection is used without being bound' do
-            lambda{
-              lispy.connection!
-            }.should raise_error(UnboundError)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-lang/parser/lispy/test_parse.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    module Parser
-      describe Lispy do
-
-        context 'when unbound' do
-          let(:lispy){ Lispy.new }
-
-          it 'allows parsing predicate expressions' do
-            p = lispy.parse{ eq(:x, 1) & neq(:y, 2) }
-            p.should be_a(Alf::Predicate)
-          end
-
-          it 'allows parsing relational expressions' do
-            p = lispy.parse{ project(:suppliers, [:sid]) }
-            p.should be_a(Algebra::Project)
-          end
-        end
-
-        context 'when bound' do
-          let(:lispy){ Lispy.new([], 12) }
-
-          it 'allows parsing predicate expressions' do
-            p = lispy.parse{ eq(:x, 1) & neq(:y, 2) }
-            p.should be_a(Alf::Predicate)
-          end
-
-          it 'deeply binds parsed relational expressions' do
-            p = lispy.parse{ project(:suppliers, [:sid]) }
-            p.should be_a(Algebra::Project)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-lang/parser/lispy/test_to_s.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    module Parser
-      describe Lispy, 'to_s' do
-
-        let(:lispy){ Lispy.new }
-
-        subject{ lispy.to_s }
-
-        it{ should eq("Lispy()") }
-
-      end
-    end
-  end
-end

data/spec/unit/alf-lang/parser/safer/safe.txt

@@ -1,5 +0,0 @@
-project(:suppliers, [:sid])
-Tuple(sid: 1)
-Relation(sid: 1)
-DEE
-DUM

data/spec/unit/alf-lang/parser/safer/test_parse.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    module Parser
-      describe Safer, "test_parse" do
-
-        let(:viewpoint) do
-          Module.new{
-            def suppliers
-              Algebra::Operand::Named.new(:suppliers)
-            end
-          }
-        end
-
-        let(:parser){ Safer.new([viewpoint]) }
-
-        context 'with a ruby block' do
-          subject{ parser.parse{} }
-
-          it 'raises a SecurityError' do
-            lambda{
-              subject
-            }.should raise_error(SecurityError, /Parsing of ruby blocks forbidden/)
-          end
-        end
-
-        context 'with a symbol' do
-          let(:op){ Algebra::Operand::Named.new(:suppliers) }
-          subject{ parser.parse(:suppliers) }
-
-          it 'passes and returns the operand' do
-            subject.should eq(op)
-          end
-        end
-
-        context 'with an operand' do
-          let(:op){ Algebra::Operand::Named.new(:suppliers) }
-          subject{ parser.parse(op) }
-
-          it 'returns it immediately' do
-            subject.should be(op)
-          end
-        end
-
-        context 'with an attempt attack based on a symbol' do
-          subject{ parser.parse(:"send(:suppliers)") }
-
-          it 'fails with a security error' do
-            lambda{
-              subject
-            }.should raise_error(SecurityError, /Forbidden/)
-          end
-        end
-
-        (Path.dir/'safe.txt').each_line do |line|
-          context "on '#{line.strip}'" do
-            subject{ parser.parse(line.strip) }
-
-            it 'succeeds' do
-              lambda{
-                subject
-              }.should_not raise_error
-            end
-          end
-        end
-
-        (Path.dir/'unsafe.txt').each_line do |line|
-          context "on '#{line.strip}'" do
-            subject{ parser.parse(line.strip) }
-
-            it 'raises a SecurityError' do
-              lambda{
-                subject
-              }.should raise_error(SecurityError, /Forbidden/)
-            end
-          end
-        end
-
-      end
-    end
-  end
-end