alf 0.12.2 → 0.13.0

data/spec/unit/alf-core/operator/signature/test_to_lispy.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator
-    describe Signature, '#to_lispy' do
-
-      subject{ signature.to_lispy }
-
-      describe "on a nullary signature" do
-        let(:clazz){ Operator::NonRelational::Generator }
-
-        describe "on an empty signature" do
-          let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("(generator)") }
-        end
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("(generator {allbut: Boolean})") }
-        end
-
-      end # nullary signature
-
-      describe "on a monadic operator" do
-        let(:clazz){ Operator::NonRelational::Coerce }
-
-        describe "on an empty signature" do
-          let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("(coerce operand)") }
-        end
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("(coerce operand, {allbut: Boolean})") }
-        end
-
-        describe "on an option-only signature with multiple options" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-              s.option :newname, AttrName
-            end
-          }
-          it{ should eq("(coerce operand, {allbut: Boolean, newname: AttrName})") }
-        end
-
-        describe "on a signature with one argument only" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :by, AttrList
-            end
-          }
-          it{ should eq("(coerce operand, by:AttrList)") }
-        end
-
-        describe "on a signature with multiple arguments" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :by, AttrList
-              s.argument :order, Ordering
-            end
-          }
-          it{ should eq("(coerce operand, by:AttrList, order:Ordering)") }
-        end
-
-        describe "on a full signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :by, AttrList
-              s.argument :order, Ordering
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("(coerce operand, by:AttrList, order:Ordering, {allbut: Boolean})") }
-        end
-
-      end
-
-      describe "on a dyadic operator" do
-        let(:clazz){ Operator::Relational::Join }
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("(join left, right, {allbut: Boolean})") }
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/signature/test_to_shell.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator
-    describe Signature, '#to_shell' do
-
-      subject{ signature.to_shell }
-
-      describe "on a nullary signature" do
-        let(:clazz){ Operator::NonRelational::Generator }
-
-        describe "on an empty signature" do
-          let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("alf generator") }
-        end
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("alf generator [--allbut]") }
-        end
-
-      end # nullary signature
-
-      describe "on a monadic operator" do
-        let(:clazz){ Operator::NonRelational::Coerce }
-
-        describe "on an empty signature" do
-          let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("alf coerce [OPERAND]") }
-        end
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("alf coerce [--allbut] [OPERAND]") }
-        end
-
-        describe "on an option-only signature with multiple options" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-              s.option :newname, AttrName
-            end
-          }
-          it{ should eq("alf coerce [--allbut] [--newname=NEWNAME] [OPERAND]") }
-        end
-
-        describe "on a signature with one argument only" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :proj, AttrList
-            end
-          }
-          it{ should eq("alf coerce [OPERAND] -- PROJ") }
-        end
-
-        describe "on a signature with multiple arguments" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :proj, AttrList
-              s.argument :ordering, Ordering
-            end
-          }
-          it{ should eq("alf coerce [OPERAND] -- PROJ -- ORDERING") }
-        end
-
-        describe "on a full signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :proj, AttrList
-              s.argument :ordering, Ordering
-              s.option :allbut, Boolean
-              s.option :newname, AttrName
-            end
-          }
-          it{ should eq("alf coerce [--allbut] [--newname=NEWNAME] [OPERAND] -- PROJ -- ORDERING") }
-        end
-
-      end
-
-      describe "on a dyadic operator" do
-        let(:clazz){ Operator::Relational::Join }
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("alf join [--allbut] [LEFT] RIGHT") }
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/test_non_relational.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Operator::NonRelational do
-    
-    specify "each" do
-      x = []
-      Operator::NonRelational.each{|m| x << m}
-      x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
-        Alf::Operator::NonRelational::Autonum,
-        Alf::Operator::NonRelational::Clip,
-        Alf::Operator::NonRelational::Coerce,
-        Alf::Operator::NonRelational::Compact,
-        Alf::Operator::NonRelational::Defaults,
-        Alf::Operator::NonRelational::Generator,
-        Alf::Operator::NonRelational::Sort,
-      ]
-    end
-    
-  end
-end

data/spec/unit/alf-core/operator/test_relational.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Operator::Relational do
-    
-    specify "each" do
-      x = []
-      Operator::Relational.each{|m| x << m}
-      x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
-        Alf::Operator::Relational::Extend,
-        Alf::Operator::Relational::Group,
-        Alf::Operator::Relational::Heading,
-        Alf::Operator::Relational::Intersect,
-        Alf::Operator::Relational::Join,
-        Alf::Operator::Relational::Matching,
-        Alf::Operator::Relational::Minus,
-        Alf::Operator::Relational::NotMatching,
-        Alf::Operator::Relational::Project,
-        Alf::Operator::Relational::Quota,
-        Alf::Operator::Relational::Rank,
-        Alf::Operator::Relational::Rename,
-        Alf::Operator::Relational::Restrict,
-        Alf::Operator::Relational::Summarize,
-        Alf::Operator::Relational::Ungroup,
-        Alf::Operator::Relational::Union,
-        Alf::Operator::Relational::Unwrap,
-        Alf::Operator::Relational::Wrap,
-      ]
-    end
-    
-  end
-end

data/spec/unit/alf-core/reader/input.rb

@@ -1,2 +0,0 @@
-{:id => 1}
-{:id => 2}

data/spec/unit/alf-core/reader/test_alf_file.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader::AlfFile do
-    
-    class TestEnv < Alf::Environment
-      def dataset(name)
-        [{:status => 10},{:status => 30}]
-      end
-    end
-    
-    let(:io){ StringIO.new(expr) }
-    subject{ Reader::AlfFile.new(io, TestEnv.new).to_a }
-
-    describe "on pure functional expressions" do
-      let(:expr){ "(restrict :suppliers, lambda{status > 20})" }
-      it{ should == [{:status => 30}]}
-    end
-
-    describe "on impure functional expressions" do
-      let(:expr){
-      <<-EOF
-        xxx = (restrict :suppliers, lambda{status > 20})
-        (extend xxx, :rev => lambda{ -status })
-      EOF
-      }
-      it{ should == [{:status => 30, :rev => -30}]}
-    end
-      
-  end
-end

data/spec/unit/alf-core/reader/test_initialize.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Reader#initialize" do
-    
-    subject{ Reader.new(*args) }
-    
-    describe "with full args" do
-      let(:args){[
-        "suppliers", Environment.examples, {:opts => true}
-      ]}
-      specify {
-        subject.input.should eq("suppliers")
-        subject.environment.should be_a(Environment)
-        subject.options.should eq(:opts => true)
-      }
-    end
-    
-    describe "with only options" do
-      let(:args){[
-        {:opts => true}
-      ]}
-      specify {
-        subject.input.should be_nil
-        subject.environment.should be_nil
-        subject.options.should eq(:opts => true)
-      }
-    end
-
-    describe "on a subclass" do
-      class FooReader < Reader
-        DEFAULT_OPTIONS = {:from => :subclass}
-      end
-      subject{ FooReader.new(*args) }
-        
-      describe "without option overriding" do
-        let(:args){[
-          {:opts => true}
-        ]}
-        specify {
-          subject.input.should be_nil
-          subject.environment.should be_nil
-          subject.options.should eq(:opts => true, :from => :subclass)
-        }
-      end
-      
-      describe "with option overriding" do
-        let(:args){[
-          {:opts => true, :from => :overrided}
-        ]}
-        specify {
-          subject.input.should be_nil
-          subject.environment.should be_nil
-          subject.options.should eq(:opts => true, :from => :overrided)
-        }
-      end
-      
-    end
-    
-  end
-end

data/spec/unit/alf-core/reader/test_looks_a_path.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader, "looks_a_path?" do
-
-    it 'should recognize strings' do
-      Reader.send(:looks_a_path?, "path/to/a/file.rash").should be_true
-    end
-
-    it 'should recognize XXX#path' do
-      obj = Object.new
-      def obj.to_path; end
-      Reader.send(:looks_a_path?, obj).should be_true
-    end
-
-    it 'should not recognize StringIO' do
-      Reader.send(:looks_a_path?, StringIO.new("")).should be_false
-    end
-
-  end
-end

data/spec/unit/alf-core/reader/test_rash.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader::Rash do
-
-    let(:lines){ [{:id => 1},{:id => 2}]                 }
-    let(:str)  { lines.collect{|s| s.inspect}.join("\n") }
-    let(:io)   { StringIO.new(str) }
-
-    describe "when called on a StringIO" do
-      
-      let(:reader){ Reader::Rash.new(io) }
-  
-      it "should be enumerable" do
-        reader.to_a.should == lines
-      end
-
-    end
-    
-    describe "when called on a String" do
-      
-      let(:file){ File.expand_path('../input.rb', __FILE__) }
-      let(:reader){ Reader::Rash.new(file) }
-  
-      it "should be enumerable" do
-        reader.to_a.should == lines
-      end
-
-    end
-    
-  end
-end

data/spec/unit/alf-core/relation/test_coerce.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
-    
-    let(:tuples_by_sid){[
-      {:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'},
-      {:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'},
-      {:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
-    ]}
-    let(:rel){ Relation.new tuples_by_sid.to_set }
-    let(:tuples_by_name){ tuples_by_sid.sort{|t1,t2| t1[:name] <=> t2[:name]} }
-    
-    describe "coerce" do
-      
-      subject{ Relation.coerce(arg) }
-      
-      describe "with a Relation" do
-        let(:arg){ rel }
-        it{ should be_a(Relation) }
-        it{ should == rel } 
-      end
-    
-      describe "with a set of tuples" do
-        let(:arg){ tuples_by_name.to_set }
-        it{ should be_a(Relation) }
-        it{ should == rel }
-      end
-    
-      describe "with an array of tuples" do
-        let(:arg){ tuples_by_name }
-        it{ should be_a(Relation) }
-        it{ should == rel }
-      end
-      
-      describe "with an iterator" do
-        let(:arg){ Lispy.restrict(tuples_by_name, lambda{ true }) }
-        it{ should be_a(Relation) }
-        it{ should == rel }
-      end
-      
-      describe "with unrecognized arg" do
-        let(:arg){ nil }
-        specify{ lambda{ subject }.should raise_error(ArgumentError) } 
-      end
-      
-      it "should be semi-aliased as []" do
-        Alf::Relation[*tuples_by_name].should == rel
-      end
-
-    end # coerce
-      
-  end
-end