alf 0.9.2 → 0.9.3

data/spec/integration/command/unwrap/unwrap_0.cmd

@@ -0,0 +1 @@
+alf --text unwrap            suppliers -- loc_and_status

data/spec/integration/command/unwrap/unwrap_0.stdout

@@ -0,0 +1,9 @@
++------+-------+---------+--------+
+| :sid | :name | :status | :city  |
++------+-------+---------+--------+
+| S1   | Smith |      20 | London |
+| S2   | Jones |      10 | Paris  |
+| S3   | Blake |      30 | Paris  |
+| S4   | Clark |      20 | London |
+| S5   | Adams |      30 | Athens |
++------+-------+---------+--------+

data/spec/integration/command/wrap/wrap_0.cmd

@@ -0,0 +1 @@
+alf --text wrap              suppliers -- city status loc_and_status

data/spec/integration/command/wrap/wrap_0.stdout

@@ -0,0 +1,9 @@
++------+-------+--------------------------------+
+| :sid | :name | :loc_and_status                |
++------+-------+--------------------------------+
+| S1   | Smith | {:city=>"London", :status=>20} |
+| S2   | Jones | {:city=>"Paris", :status=>10}  |
+| S3   | Blake | {:city=>"Paris", :status=>30}  |
+| S4   | Clark | {:city=>"London", :status=>20} |
+| S5   | Adams | {:city=>"Athens", :status=>30} |
++------+-------+--------------------------------+

data/spec/integration/semantics/test_join.alf

@@ -0,0 +1,9 @@
+(specify "(join xxx, DUM) is DUM",
+  (rel_equal DUM, (join :suppliers, DUM)))
+(specify "(join DUM, xxx) is DUM",
+  (rel_equal DUM, (join DUM, :suppliers)))
+
+(specify "(join DEE, xxx) is xxx",
+  (rel_equal :suppliers, (join DEE, :suppliers)))
+(specify "(join xxx, DEE) is xxx",
+  (rel_equal :suppliers, (join :suppliers, DEE)))

data/spec/integration/semantics/test_rank.alf

@@ -0,0 +1,34 @@
+input = rel(
+  {:id => 1, :weight => 10.0},
+  {:id => 2, :weight => 12.0},
+  {:id => 3, :weight => 12.0}
+)
+
+(specify "rank should respect < by default",
+  (rel_equal \
+    (rel (tuple :id => 1, :weight => 10.0, :rank => 0),
+         (tuple :id => 2, :weight => 12.0, :rank => 1),
+         (tuple :id => 3, :weight => 12.0, :rank => 1)),
+    (rank input, [:weight])))
+
+(specify "rank should support a strict order",
+  (rel_equal \
+    (rel (tuple :id => 1, :weight => 10.0, :rank => 0),
+         (tuple :id => 2, :weight => 12.0, :rank => 1),
+         (tuple :id => 3, :weight => 12.0, :rank => 2)),
+    (rank input, [:weight, :id])))
+      
+(specify "rank should support a reverse order",
+  (rel_equal \
+    (rel (tuple :id => 1, :weight => 10.0, :rank => 2),
+         (tuple :id => 2, :weight => 12.0, :rank => 0),
+         (tuple :id => 3, :weight => 12.0, :rank => 0)),
+    (rank input, [[:weight, :desc]])))
+
+(specify "rank should allow specifying a name",
+  (rel_equal \
+    (rel (tuple :id => 1, :weight => 10.0, :pos => 0),
+         (tuple :id => 2, :weight => 12.0, :pos => 1),
+         (tuple :id => 3, :weight => 12.0, :pos => 1)),
+    (rank input, [:weight], :pos)))
+      

data/spec/integration/test_command.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+describe "Alf's alf command / " do
+
+  Dir[_('command/**/*.cmd', __FILE__)].each do |input|
+    cmd = wlang(File.readlines(input).first, binding)
+    specify{ cmd.should =~ /^alf / }
+  
+    describe "#{File.basename(input)}: #{cmd}" do
+      let(:argv)     { Alf::Tools::parse_commandline_args(cmd)[1..-1] }
+      let(:stdout)   { File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stdout") }
+      let(:expected) { wlang(File.read(stdout), binding) }
+
+      before{ 
+        $oldstdout = $stdout 
+        $stdout = StringIO.new
+      }
+      after { 
+        $stdout = $oldstdout
+        $oldstdout = nil 
+      }
+      
+      specify{
+        begin 
+          dir = File.expand_path('../__database__', __FILE__)
+          main = Alf::Command::Main.new
+          main.environment = Alf::Environment.folder(dir)
+          main.run(argv, __FILE__)
+        rescue SystemExit
+          $stdout << SystemExit << "\n"
+        end
+        $stdout.string.should(eq(expected)) unless RUBY_VERSION < "1.9"
+      }
+    end
+  end
+    
+end

data/spec/integration/test_examples.rb

@@ -1,26 +1,15 @@
 require 'spec_helper'
-module Alf
-  describe "Alf's examples" do
-    
-    shared_examples_for "An example" do
-      
-      let(:env){ Environment.examples }
+Dir["#{File.expand_path('../../../examples', __FILE__)}/**/*.alf"].each do |file|
 
-      it "should work when executed with a Alf" do
-        lambda{ 
-          Alf.lispy(env).compile(File.read(subject)).to_a 
-        }.should_not raise_error
-      end
-      
-    end # An example
-    
-    
-    Dir["#{File.expand_path('../../../examples', __FILE__)}/**/*.alf"].each do |file|
-      describe file do
-        subject{ file }
-        it_should_behave_like "An example"
-      end
+  describe "Alf example: #{file}" do
+    let(:example_path){ file }
+    let(:example_dir) { File.dirname(file) }
+    let(:example_env) { Alf::Environment.folder(example_dir) }
+
+    it "should run without error" do
+      Alf.lispy(example_env).compile(File.read(example_path)).to_rel
     end
-    
+
   end
-end 
+
+end

data/spec/integration/test_semantics.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+describe "Alf's semantics tests" do
+  
+  module Helpers
+    
+    def rel_equal(x, y)
+      x = Alf::Environment.examples.dataset(x) if x.is_a?(Symbol)
+      y = Alf::Environment.examples.dataset(y) if y.is_a?(Symbol)
+      x.to_rel == y.to_rel
+    end
+    
+    def specify(message, x)
+      raise message unless x
+    end
+    
+  end
+  
+  shared_examples_for "A semantics spec file" do
+    
+    let(:lispy){
+      dir = File.expand_path('../__database__', __FILE__)
+      lispy = Alf.lispy(Alf::Environment.folder(dir))
+      lispy.ruby_extend(Helpers)
+    }
+
+    it "should work when executed with a Alf" do
+      lispy.compile(File.read(subject))
+    end
+    
+  end # An example
+  
+  
+  Dir["#{File.expand_path('../semantics', __FILE__)}/**/*.alf"].each do |file|
+    describe file do
+      subject{ file }
+      it_should_behave_like "A semantics spec file"
+    end
+  end
+  
+end

data/spec/regression/alf_file/__FILE__.alf

@@ -0,0 +1,2 @@
+suppliers = Reader.reader File.join(File.dirname(__FILE__), "suppliers.rash")
+(project suppliers, [:city])

data/spec/regression/alf_file/suppliers.rash

@@ -0,0 +1,5 @@
+{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
+{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
+{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
+{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/spec/regression/alf_file/test___FILE__.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  describe Reader::AlfFile do
+    subject{ 
+      Reader::AlfFile.new(File.expand_path("../__FILE__.alf", __FILE__), Environment.examples)
+    }
+    
+    specify {
+      subject.to_rel.should == Relation[
+        {:city => "London"},
+        {:city => "Paris"},
+        {:city => "Athens"}
+      ]
+    }
+    
+  end
+end

data/spec/regression/heading/test_heading_with_date.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'date'
+module Alf
+  describe Heading do
+  
+    describe "when attributes on Foo domain" do
+      subject{ Heading[{:date => Date.today}] }
+      it_should_behave_like "A value"
+    end
+    
+  end
+end

data/spec/regression/lispy/test_compile.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe "Lispy.compile" do
+  
+  it "should use a clean binding" do
+    p = Alf::Lispy.compile("lambda{ path }", "a path")
+    lambda{ p.call }.should raise_error(NameError)
+  end
+  
+  it "should resolve __FILE__ correctly" do
+    p = Alf::Lispy.compile("__FILE__", "a path")
+    p.should == "a path"
+  end
+  
+end

data/spec/regression/relation/test_relation_with_date.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'date'
+module Alf
+  describe Relation do
+  
+    describe "when attributes on Date domain" do
+      subject{ Relation[{:date => Date.today}] }
+      it_should_behave_like "A value"
+    end
+    
+  end
+end

data/spec/regression/restrict/test_restrict_with_keywords.rb

@@ -0,0 +1,17 @@
+require 'spec_helper' 
+module Alf
+  describe "(restrict xxx, :keyword => ...)" do
+    
+    it "should support using a keyword on Relation" do
+      rel = Relation[{:when => "now"}]
+      rel.restrict(:when => "now").should eq(rel)
+    end
+    
+    it "should support using a keyword on Lispy" do
+      Alf.lispy(Environment.examples).evaluate do
+        (restrict (extend :suppliers, {:when => lambda{"notnow"}}), {:when => "now"})
+      end.should eq(Relation::DUM)
+    end
+    
+  end
+end

data/spec/shared/a_value.rb

@@ -0,0 +1,12 @@
+shared_examples_for "A value" do
+  
+  it "should have a inspect/class.parse that lead to equal values" do
+    Kernel.eval(subject.inspect).should eq(subject)
+  end
+  
+  it "should act a valid Hash keys" do
+     dup = Kernel.eval(subject.inspect)
+     {subject => true, dup => false}.size.should == 1
+  end
+  
+end

data/spec/shared/an_operator_class.rb

@@ -0,0 +1,35 @@
+shared_examples_for "An operator class" do
+
+  it "should not have public set_args, _each and _prepare methods" do
+    operator_class.public_method_defined?(:set_args).should be_false
+    operator_class.public_method_defined?(:_each).should be_false
+    operator_class.public_method_defined?(:_prepare).should be_false
+  end
+
+  it "should have a public run method" do
+    operator_class.public_method_defined?(:run).should be_true
+  end
+  
+  it "should have a public pipe method" do
+    operator_class.public_method_defined?(:pipe).should be_true
+  end
+
+  it "should have a public each method" do
+    operator_class.public_method_defined?(:each).should be_true
+  end
+  
+  it "should have a unary? class method" do
+    operator_class.should respond_to(:unary?)
+  end
+
+  it "should have a binary? class method" do
+    operator_class.should respond_to(:binary?)
+  end
+  
+  it "should implement unary? and binary? accurately" do
+    operator_class.unary?.should_not eq(operator_class.binary?)
+    operator_class.unary?.should eq(operator_class.ancestors.include?(Alf::Operator::Unary))
+    operator_class.binary?.should eq(operator_class.ancestors.include?(Alf::Operator::Binary))
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,44 +1,22 @@
 $LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'alf'
+require "rspec"
 
 Alf::Lispy.extend(Alf::Lispy)
 
 def rel(*args)
   Alf::Relation.coerce(args)
 end
+def tuple(h)
+  h
+end
+def _(path, file)
+  File.expand_path("../#{path}", file)
+end
 
-shared_examples_for "An operator class" do
-
-  it "should not have public set_args, _each and _prepare methods" do
-    operator_class.public_method_defined?(:set_args).should be_false
-    operator_class.public_method_defined?(:_each).should be_false
-    operator_class.public_method_defined?(:_prepare).should be_false
-  end
-
-  it "should have a public run method" do
-    operator_class.public_method_defined?(:run).should be_true
-  end
-  
-  it "should have a public pipe method" do
-    operator_class.public_method_defined?(:pipe).should be_true
-  end
-
-  it "should have a public each method" do
-    operator_class.public_method_defined?(:each).should be_true
-  end
-  
-  it "should have a unary? class method" do
-    operator_class.should respond_to(:unary?)
-  end
-
-  it "should have a binary? class method" do
-    operator_class.should respond_to(:binary?)
-  end
-  
-  it "should implement unary? and binary? accurately" do
-    operator_class.unary?.should_not eq(operator_class.binary?)
-    operator_class.unary?.should eq(operator_class.ancestors.include?(Alf::Operator::Unary))
-    operator_class.binary?.should eq(operator_class.ancestors.include?(Alf::Operator::Binary))
-  end
-
+def wlang(str, binding)
+  str.gsub(/\$\(([\S]+)\)/){ Kernel.eval($1, binding) }
 end
+
+require 'shared/an_operator_class'
+require 'shared/a_value'

data/spec/unit/assumptions/test_file.rb

@@ -0,0 +1,17 @@
+require 'spec_helper' 
+describe "__FILE__" do
+
+  describe "when used with eval within same file" do
+    let(:src){ "__FILE__" }
+    subject{ Kernel.eval(src, binding, __FILE__) }
+    it { should == __FILE__ }
+  end
+  
+  describe "when used with eval from other file" do
+    let(:src){ "__FILE__" }
+    subject{ Kernel.eval(src, binding, "hello.rb") }
+    it { should == "hello.rb" }
+  end
+  
+  
+end

data/spec/unit/{test_assumptions.rb → assumptions/test_instance_eval.rb}

@@ -12,4 +12,4 @@ describe :instance_eval do
     it { should == 10 }
   end
 
-end
+end

data/spec/unit/assumptions/test_scoping.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+describe :clojures_and_scoping do
+
+  class Foo
+    
+    def a_method
+      :inside
+    end
+    
+    def evaluate(lamb)
+      if RUBY_VERSION <= "1.9"
+        self.instance_eval(&lamb)
+      else
+        self.instance_exec(&lamb)
+      end
+    end
+    
+  end
+  
+  specify "when no name clash" do
+    Foo.new.evaluate(lambda{ a_method }).should == :inside 
+  end
+  
+  specify "with name clash" do
+    a_method = :outside
+    Foo.new.evaluate(Proc.new{ a_method }).should == :outside 
+  end
+  
+end