alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-engine/test_type_safe.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe TypeSafe do
-
-      let(:heading){ Heading.new(name: String, status: Fixnum) }
-      let(:cog){ TypeSafe.new(tuples, TypeCheck.new(heading, false)) }
-
-      context 'when all valid tuples' do
-        let(:tuples){
-          [ {name: "Smith", status: 20}, {name: "Jones"} ]
-        }
-
-        it 'simply let the tuples pass' do
-          cog.to_a.should eq(tuples)
-        end
-      end
-
-      context 'when at least one invalid tuple' do
-        let(:tuples){
-          [ {name: "Smith", status: 20}, {name: "Jones", status: "40"} ]
-        }
-
-        it 'raises a TypeCheckError' do
-          lambda{
-            cog.to_a
-          }.should raise_error(TypeCheckError, /Jones/)
-        end
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_ungroup.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Ungroup do
-
-      let(:input){[
-        {:city => "London", :suppliers => [
-                              {:name => "Smith"},
-                              {:name => "Blake"}
-                            ]},
-        {:city => "Paris", :suppliers => [
-                              {:name => "Jones"}
-                            ]},
-      ]}
-
-      let(:expected){[
-        {:name => "Smith", :city => "London"},
-        {:name => "Blake", :city => "London"},
-        {:name => "Jones", :city => "Paris"},
-      ]}
-
-      it 'should ungroup specified attribute' do
-        Ungroup.new(input, :suppliers).to_a.should eq(expected)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_unwrap.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Unwrap do
-
-      let(:input) {[
-        {:wrapped => {:a => "a", :b => "b"}, :c => "c"}
-      ]}
-
-      let(:expected) {[
-        {:a => "a", :b => "b", :c => "c"},
-      ]}
-
-      it "should unwrap as expected" do
-        Unwrap.new(input, :wrapped).to_a.should eq(expected)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-engine/test_wrap.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Wrap do
-
-      let(:input) {[
-        {:a => "a", :b => "b", :c => "c"},
-      ]}
-
-      let(:expected) {[
-        {:wrapped => {:a => "a", :b => "b"}, :c => "c"}
-      ]}
-
-      it "should wrap as expected" do
-        wrap = Wrap.new(input, AttrList[:a, :b], :wrapped, false)
-        wrap.to_a.should eq(expected)
-      end
-
-      it "should support allbut wrapping" do
-        wrap = Wrap.new(input, AttrList[:c], :wrapped, true)
-        wrap.to_a.should eq(expected)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-io/reader/class/test_by_mime_type.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader, ".by_mime_type" do
-
-    let(:io){ StringIO.new("") }
-
-    context 'when mime type is unrecognized' do
-      subject{
-        Reader.by_mime_type("no/suchone", io)
-      }
-
-      it 'should raise an error' do
-        lambda{
-          subject
-        }.should raise_error(UnsupportedMimeTypeError, /No reader for `no\/suchone`/)
-      end
-    end
-
-    context 'when such mime type is registered' do
-      subject{
-        Reader.by_mime_type("text/csv", io)
-      }
-
-      it{ should be_a(Reader::CSV) }
-
-      it 'should be wired correctly' do
-        subject.input.should be(io)
-      end
-    end
-
-  end
-end

data/spec/unit/alf-io/reader/input.csv

@@ -1,3 +0,0 @@
-size
-10
-20

data/spec/unit/alf-io/reader/input.rash

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

data/spec/unit/alf-io/reader/input.ruby

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

data/spec/unit/alf-io/reader/test_csv.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Reader
-    describe CSV do
-      it_should_behave_like "a Reader class"
-
-      describe "without options" do
-        let(:input){
-          StringIO.new << "size\n10\n20\n"
-        }
-        let(:expected){
-          [{:size => "10"}, {:size => "20"}]
-        }
-        subject{ reader.to_a }
-
-        describe "when called on a reader directly" do
-          let(:reader){
-            CSV.new(input)
-          }
-          it{ should eq(expected) }
-        end
-
-        describe "when called through registered one" do
-          let(:reader){
-            Reader.reader(Path.dir / 'input.csv')
-          }
-          it{ should eq(expected) }
-        end
-
-        describe "when called through factory method" do
-          let(:reader){
-            Reader.csv(input)
-          }
-          it{ should eq(expected) }
-        end
-      end
-
-      describe "with options" do
-        let(:input){
-          StringIO.new << "size;name\n10;blambeau\n20;mmathieu\n"
-        }
-        let(:options){
-          {:col_sep => ";"}
-        }
-        let(:expected){
-          [{:size => "10", :name => 'blambeau'}, {:size => "20", :name => 'mmathieu'}]
-        }
-        subject{ reader.to_a }
-
-        describe "when called on a reader directly" do
-          let(:reader){
-            CSV.new(input, options)
-          }
-          it{ should eq(expected) }
-        end
-
-        describe "when called through factory method" do
-          let(:reader){
-            Reader.csv(input, options)
-          }
-          it{ should eq(expected) }
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Reader#initialize" do
-
-    subject{ Reader.new(*args) }
-
-    let(:input){ nil }
-    let(:options){ nil }
-
-    let(:args){ [input, options].compact }
-
-    before do
-      subject.should be_a(Reader)
-    end
-
-    after do
-      subject.input.should eq(input)
-    end
-
-    context 'with empty default options' do
-
-      after do
-        subject.options.should eq(options || {})
-      end
-
-      context "with only a path as a String" do
-        let(:input){ "suppliers" }
-        it 'should set the path correctly' do
-          subject.path.should eq(Path("suppliers"))
-        end
-      end
-
-      context "with only a path as a Path" do
-        let(:input){ Path("suppliers") }
-        it 'should set the path correctly' do
-          subject.path.should eq(Path("suppliers"))
-        end
-      end
-
-      context "with a File" do
-        let(:input){ Path.here.open('r') }
-        it 'should set the path correctly' do
-          subject.path.should eq(Path.here)
-        end
-        after{ input.close rescue nil }
-      end
-    end
-
-    describe "on a subclass" do
-      class FooReader < Reader
-        DEFAULT_OPTIONS = {:from => :subclass}
-      end
-      subject{ FooReader.new(*args) }
-
-      let(:input){ "suppliers" }
-
-      describe "without option overriding" do
-        let(:options){ {:opts => true} }
-        it 'should merge options' do
-          subject.options.should eq(:opts => true, :from => :subclass)
-        end
-      end
-
-      describe "with option overriding" do
-        let(:options){ {:opts => true, :from => :overrided} }
-        it 'should override options' do
-          subject.options.should eq(:opts => true, :from => :overrided)
-        end
-      end
-
-    end
-
-  end
-end

data/spec/unit/alf-io/reader/test_json.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'json'
-module Alf
-  describe Reader::JSON do
-    it_should_behave_like "a Reader class"
-
-    let(:str)   { ::JSON.dump(input)   }
-    let(:io)    { StringIO.new(str)    }
-    let(:reader){ Reader::JSON.new(io) }
-
-    subject{ reader.to_a }
-
-    describe "when called on a JSON Array" do
-      let(:input){ [{:id => 1},{:id => 2}] }
-
-      it "read the lines as expected" do
-        subject.should eq(input)
-      end
-    end
-
-    describe "when called on a JSON Hash" do
-      let(:input){ {:id => 1} }
-
-      it "should yield the single Hash" do
-        subject.should eq([input])
-      end
-    end
-
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader::Rash do
-    it_should_behave_like "a Reader class"
-
-    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.rash', __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-io/reader/test_ruby.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader::Ruby do
-    it_should_behave_like "a Reader class"
-
-    let(:file){
-      File.expand_path('../input.ruby', __FILE__)
-    }
-    let(:reader){
-      Reader::Ruby.new(file)
-    }
-
-    let(:expected){
-      [
-        {:id => 1},
-        {:id => 2}
-      ]
-    }
-
-    it "should be enumerable" do
-      reader.to_a.should eq(expected)
-    end
-    
-  end
-end

data/spec/unit/alf-io/reader/test_yaml.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'json'
-module Alf
-  describe Reader::YAML do
-    it_should_behave_like "a Reader class"
-
-    let(:str)   { input.to_yaml        }
-    let(:io)    { StringIO.new(str)    }
-    let(:reader){ Reader::YAML.new(io) }
-
-    subject{ reader.to_a }
-
-    describe "when called on a Array" do
-      let(:input){ [{:id => 1},{:id => 2}] }
-
-      it "read the lines as expected" do
-        subject.should eq(input)
-      end
-    end
-
-    describe "when called on a Hash" do
-      let(:input){ {:id => 1} }
-
-      it "should yield the single Hash" do
-        subject.should eq([input])
-      end
-    end
-
-  end
-end

data/spec/unit/alf-io/renderer/class/test_by_mime_type.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renderer, ".by_mime_type" do
-
-    context 'when mime type is unrecognized' do
-      subject{
-        Renderer.by_mime_type("no/suchone", [{id: "csv", name: "CSV"}])
-      }
-
-      it 'should raise an error' do
-        lambda{
-          subject
-        }.should raise_error(UnsupportedMimeTypeError, /No renderer for `no\/suchone`/)
-      end
-    end
-
-    context 'when such mime type is registered' do
-      subject{
-        Renderer.by_mime_type("text/csv", [{id: "csv", name: "CSV"}], col_sep: ";")
-      }
-
-      it{ should be_a(Renderer::CSV) }
-
-      it 'should be wired correctly' do
-        subject.execute("").should eq("id;name\ncsv;CSV\n")
-      end
-    end
-
-  end
-end