alf 0.12.2 → 0.13.0

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

@@ -1,57 +0,0 @@
-require 'spec_helper'
-module Alf
-  shared_examples_for "A valid Logs::Reader instance" do
-
-    specify{ reader.should be_a(::Alf::Logs::Reader) }
-
-    it "should yield a pseudo-relation" do
-      reader.all?{|tuple| tuple.is_a?(Hash)}.should be_true
-    end
-
-  end
-  describe Logs::Reader do
-
-    let(:input){ _("apache_combined.log", __FILE__) }
-
-    describe "when called on a reader directly" do
-      let(:reader){
-        ::Alf::Logs::Reader.new(input)
-      }
-      it_should_behave_like "A valid Logs::Reader instance"
-    end
-
-    describe "when called through registered one" do
-      let(:reader){
-        ::Alf::Reader.reader(input)
-      }
-      it_should_behave_like "A valid Logs::Reader instance"
-    end
-
-    describe "when called through factory method" do
-      let(:reader){
-        ::Alf::Reader.logs(input)
-      }
-      it_should_behave_like "A valid Logs::Reader instance"
-    end
-
-    describe "the auto-detect feature" do
-      let(:reader){ ::Alf::Logs::Reader.new(file,nil,:file_format => nil) }
-      let(:relation){ reader.to_rel }
-
-      context "on postgresql.log" do
-        pending("postgresql log format seems broken") {
-          let(:file){ _("postgresql.log", __FILE__) }
-          it_should_behave_like "A valid Logs::Reader instance"
-          specify{ relation.should_not be_empty }
-        }
-      end
-
-      context "on apache_combined.log" do
-        let(:file){ _("apache_combined.log", __FILE__) }
-        it_should_behave_like "A valid Logs::Reader instance"
-        specify{ relation.should_not be_empty }
-      end
-    end # auto-detect
-
-  end
-end

data/spec/unit/alf-sequel/test_environment.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-require "sequel"
-module Alf
-  describe Sequel::Environment do
-    
-    let(:rel) {Alf::Relation[
-      {: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'}
-    ]}
-
-    let(:file){ _("alf.db", __FILE__) }
-
-    def uri
-      protocol = defined?(JRUBY_VERSION) ? "jdbc:sqlite" : "sqlite"
-      "#{protocol}://#{file}"
-    end
-
-    before(:all){
-      unless File.exists?(file) 
-        FileUtils.rm_rf file
-        db = ::Sequel.connect(uri)
-        db.create_table(:suppliers){
-          primary_key :sid
-          String  :sid
-          String  :name
-          Integer :status
-          String  :city
-        }
-        rel.each{|tuple| db[:suppliers].insert(tuple)}
-      end
-    }
-
-    describe "recognizes?" do
-
-      it "should recognize sqlite files" do
-        Sequel::Environment.recognizes?([file]).should be_true
-      end
-
-      it "should recognize database uris" do
-        Sequel::Environment.recognizes?(["postgres://localhost/database"]).should be_true
-        Sequel::Environment.recognizes?([uri]).should be_true
-      end
-
-      it "should not be too permissive" do
-        Sequel::Environment.recognizes?(["nosuchone.db"]).should be_false
-        Sequel::Environment.recognizes?([nil]).should be_false
-      end
-
-    end # recognizes?
-
-    it "should let Environment autodetect sqlite files" do
-      Environment.autodetect(file).should be_a(Sequel::Environment)
-    end
-
-    describe "dataset" do
-
-      let(:env) { Sequel::Environment.new(file) }
-
-      it "should serve iterators" do
-        env.dataset(:suppliers).should be_a(Alf::Iterator)
-      end
-
-      it "should be the correct relation" do
-        env.dataset(:suppliers).to_rel.should eq(rel)
-      end
-
-    end # dataset
-
-  end
-end

data/spec/unit/alf-shell/doc_manager/dynamic.md

@@ -1 +0,0 @@
-#(command_name)

data/spec/unit/alf-shell/doc_manager/example.md

@@ -1 +0,0 @@
-  !(alf autonum suppliers -- unique_id)

data/spec/unit/alf-shell/doc_manager/example_1.txt

@@ -1,11 +0,0 @@
-  $ alf autonum suppliers -- unique_id
-  
-    +------+-------+---------+--------+------------+
-    | :sid | :name | :status | :city  | :unique_id |
-    +------+-------+---------+--------+------------+
-    | S1   | Smith |      20 | London |          0 |
-    | S2   | Jones |      10 | Paris  |          1 |
-    | S3   | Blake |      30 | Paris  |          2 |
-    | S4   | Clark |      20 | London |          3 |
-    | S5   | Adams |      30 | Athens |          4 |
-    +------+-------+---------+--------+------------+

data/spec/unit/alf-shell/doc_manager/static.md

@@ -1 +0,0 @@
-Hello

data/spec/unit/alf-shell/doc_manager/test_call.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Shell
-    describe DocManager, ".call" do
-
-      let(:dm){ @dm ||= DocManager.new }
-      let(:cmd){ Alf::Shell::Show }
-      subject{ 
-        dm.call(cmd, opts) 
-      }
-
-      describe "without options" do
-        let(:opts){ {} }
-
-        describe "on a static file" do
-          before{ 
-            def dm.find_file(cmd); 
-              File.expand_path('../static.md', __FILE__)
-            end 
-          }
-          it { should eq("Hello\n") }
-        end
-
-        describe "on a dynamic file" do
-          before{ 
-            def dm.find_file(cmd); 
-              File.expand_path('../dynamic.md', __FILE__)
-            end 
-          }
-          it { should eq("show\n") }
-        end
-
-        unless RUBY_VERSION < "1.9"
-          describe "on an example file" do
-            before{ 
-              def dm.find_file(cmd); 
-                File.expand_path('../example.md', __FILE__)
-              end 
-            }
-            it { should eq(File.read(File.expand_path('../example_1.txt', __FILE__))) }
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-shell/main/test_class_methods.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Shell
-    describe Main::ClassMethods do
-
-      specify "relational_operators" do
-        Shell::Main.relational_operators.should_not be_empty
-        Shell::Main.relational_operators.each do |cmd|
-          cmd.should_not be_command
-          cmd.should be_operator
-          cmd.should respond_to(:run)
-        end
-      end
-
-      specify "experimental_operators" do
-        Shell::Main.experimental_operators.should_not be_empty
-        Shell::Main.experimental_operators.each do |cmd|
-          cmd.should_not be_command
-          cmd.should be_operator
-          cmd.should respond_to(:run)
-        end
-      end
-
-      specify "non_relational_operators" do
-        Shell::Main.non_relational_operators.should_not be_empty
-        Shell::Main.non_relational_operators.each do |cmd|
-          cmd.should_not be_command
-          cmd.should be_operator
-          cmd.should respond_to(:run)
-        end
-      end
-
-      specify "other_non_relational_commands" do
-        Shell::Main.other_non_relational_commands.should_not be_empty
-        Shell::Main.other_non_relational_commands.each do |cmd|
-          cmd.should be_command
-          cmd.should_not be_operator
-          cmd.should respond_to(:run)
-        end
-      end
-        
-    end # Main::ClassMethods
-  end # module Shell
-end # module Alf

data/spec/unit/alf-shell/operator/test_autonum.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Autonum do
-
-    let(:input){ [] }
-    subject{ Autonum.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::NonRelational::Autonum)
-      subject.operands.should eq([input])
-    end
-
-    context "with default attribute name" do
-      let(:argv){ [input] }
-      specify{
-        subject.as.should eq(:autonum)
-      }
-    end
-
-    context "with explicit attribute name" do
-      let(:argv){ [input, "--", "unique"] }
-      specify{
-        subject.as.should eq(:unique)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_clip.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Clip do
-
-    let(:input){ [] }
-    subject{ Clip.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::NonRelational::Clip)
-      subject.attributes.should eq(Alf::AttrList[:a, :b])
-      subject.operands.should eq([input])
-    end
-
-    context "--no-allbut" do
-      let(:argv){ [input, "--", "a", "b"] }
-      specify{
-        subject.allbut.should be_false
-      }
-    end
-
-    context "--allbut" do
-      let(:argv){ [input, "--allbut", "--", "a", "b"] }
-      specify{
-        subject.allbut.should be_true
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_coerce.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Coerce do
-
-    let(:input){ [] }
-    subject{ Coerce.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::NonRelational::Coerce)
-      subject.operands.should eq([input])
-    end
-
-    context "a typical coercion" do
-      let(:argv){ [input] + %w{-- a Integer b Float} }
-      specify{
-        subject.heading.should eq(Alf::Heading[:a => Integer, :b => Float])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_compact.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Compact do
-
-    let(:input){ [] }
-    subject{ Compact.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [input] }
-      specify{
-        subject.should be_a(Alf::Operator::NonRelational::Compact)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_defaults.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Defaults do
-
-    let(:input){ [] }
-    subject{ Defaults.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::NonRelational::Defaults)
-      subject.defaults.should eq(Alf::TupleComputation[:a => Alf::TupleExpression["1"], :c => Alf::TupleExpression["'blue'"]])
-      subject.operands.should eq([input])
-    end
-
-    context "--no-strict" do
-      let(:argv){ [input] + %w{-- a 1 c 'blue'} }
-      specify{
-        subject.strict.should eq(false)
-      }
-    end
-
-    context "--strict" do
-      let(:argv){ [input] + %w{--strict -- a 1 c 'blue'} }
-      specify{
-        subject.strict.should eq(true)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_extend.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Extend do
-
-    let(:input){ [] }
-    subject{ Extend.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Extend)
-      subject.operands.should eq([input])
-    end
-
-    context "a typical config" do
-      let(:argv){ [input] + %w{-- big} + ["tested > 10"] }
-      specify{
-        subject.ext.should eq(Alf::TupleComputation[:big => Alf::TupleExpression["tested > 10"]])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_generator.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Generator do
-
-    subject{ Generator.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::NonRelational::Generator)
-      subject.operands.should eq([])
-    end
-
-    context "with empty args" do
-      let(:argv){ %w{} }
-      specify{
-        subject.size.should eq(10)
-        subject.as.should eq(:num)
-      }
-    end
-
-    context "with a size" do
-      let(:argv){ %w{-- 2} }
-      specify{
-        subject.size.should eq(2)
-        subject.as.should eq(:num)
-      }
-    end
-
-    context "with a size and a name" do
-      let(:argv){ %w{-- 2 -- generated} }
-      specify{
-        subject.size.should eq(2)
-        subject.as.should eq(:generated)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_group.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Group do
-
-    let(:input){ [] }
-    subject{ Group.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Group)
-      subject.operands.should eq([input])
-    end
-
-    context "--no-allbut" do
-      let(:argv){ [input, "--", "time", "b", "--", "as"] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[:time, :b])
-        subject.as.should eq(:as)
-        subject.allbut.should eq(false)
-      }
-    end
-
-    context "--allbut" do
-      let(:argv){ [input, "--allbut", "--","a", "--", "as"] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[:a])
-        subject.as.should eq(:as)
-        subject.allbut.should eq(true)
-      }
-    end
-
-  end
-end