alf-core 0.15.0 → 0.16.0

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

@@ -1,68 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer
-    describe CSV do
-
-      context 'the class' do
-        subject{ CSV }
-
-        it_should_behave_like "a Renderer class"
-      end
-
-      context 'an instance on multiple tuples' do
-        let(:input){
-          [{:id => 1, :name => "Smith"}, {:id => 2, :name => "Jones"}]
-        }
-
-        subject{ renderer.execute(StringIO.new).string }
-
-        describe "without options" do
-          let(:renderer){ CSV.new(input) }
-          let(:expected){
-            "id,name\n1,Smith\n2,Jones\n"
-          }
-
-          it{ should eq(expected) }
-        end
-
-        describe "with options" do
-          let(:renderer){ CSV.new(input, options) }
-          let(:options){ {col_sep: ";"} }
-          let(:expected){
-            "id;name\n1;Smith\n2;Jones\n"
-          }
-
-          it{ should eq(expected) }
-        end
-      end
-
-      context 'an instance on a single tuples' do
-        subject{ renderer.execute(StringIO.new).string }
-
-        let(:input){
-          {:id => 1, :name => "Smith"}
-        }
-
-        describe "without options" do
-          let(:renderer){ CSV.new(input) }
-          let(:expected){
-            "id,name\n1,Smith\n"
-          }
-
-          it{ should eq(expected) }
-        end
-
-        describe "with options" do
-          let(:renderer){ CSV.new(input, options) }
-          let(:options){ {col_sep: ";"} }
-          let(:expected){
-            "id;name\n1;Smith\n"
-          }
-
-          it{ should eq(expected) }
-        end
-      end
-
-    end
-  end
-end

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

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

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer
-    describe JSON do
-
-      context 'the class' do
-        subject{ JSON }
-
-        it_should_behave_like "a Renderer class"
-      end
-
-      context "an instance on a Relation" do
-        subject{ JSON.new(input).execute("") }
-
-        let(:input){ Relation(id: [1, 2]) }
-
-        it 'outputs as expected' do
-          subject.should eq('[{"id":1},{"id":2}]' << "\n")
-        end
-
-        it 'allows roundtripping' do
-          Relation(::JSON.parse(subject)).should eq(input)
-        end
-      end
-
-      context "an instance on a Hash" do
-        subject{ JSON.new(input).execute("") }
-
-        let(:input){ {id: 1} }
-
-        it 'outputs as expected' do
-          subject.should eq('{"id":1}' << "\n")
-        end
-
-        it 'allows roundtripping' do
-          ::JSON.parse(subject).should eq({'id' => 1})
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer
-    describe Rash do
-
-      context 'the class' do
-        subject{ Rash }
-
-        it_should_behave_like "a Renderer class"
-      end
-
-      context 'an instance' do
-        subject{ Rash.new(input).execute("") }
-
-        context "when a Relation" do
-          let(:input){ Relation(id: [1, 2]) }
-          let(:expected){ "{:id => 1}\n{:id => 2}\n" }
-
-          it 'outputs as expected' do
-            subject.should eq(expected)
-          end
-        end
-
-        context "when a Hash" do
-          let(:input){ {id: 1} }
-          let(:expected){ "{:id => 1}\n" }
-
-          it 'outputs as expected' do
-            subject.should eq(expected)
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-io/renderer/test_text.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer
-    describe Text do
-
-      context 'the class' do
-        subject{ Text }
-
-        it_should_behave_like "a Renderer class"
-      end
-
-      describe "execute on a Relation" do
-        subject{ Text.new(input).execute("") }
-
-        let(:input){ Relation(id: [1, 2]) }
-        let(:expected){ "+-----+\n"\
-                        "| :id |\n"\
-                        "+-----+\n"\
-                        "|   1 |\n"\
-                        "|   2 |\n"\
-                        "+-----+\n"
-        }
-
-        it 'outputs as expected' do
-          subject.should eq(expected)
-        end
-      end
-
-      describe "execute on a Hash" do
-        subject{ Text.new(input).execute("") }
-
-        let(:input){ {id: 1} }
-        let(:expected){ "+-----+\n"\
-                        "| :id |\n"\
-                        "+-----+\n"\
-                        "|   1 |\n"\
-                        "+-----+\n"
-        }
-
-        it 'outputs as expected' do
-          subject.should eq(expected)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer
-    describe YAML do
-
-      subject{ YAML }
-
-      it_should_behave_like "a Renderer class"
-
-      describe "execute" do
-        subject{ YAML.new(input).execute("") }
-
-        let(:input){ Relation(id: [1, 2]) }
-
-        it 'outputs as expected' do
-          ::YAML.load(subject).should eq([{id: 1}, {id: 2}])
-        end
-      end
-
-      describe "when relation-valued attributes" do
-        subject{ YAML.new(input).execute("") }
-
-        let(:input){ Relation(sid: "S1", parts: Relation(pid: ["P1", "P2"])) }
-
-        it 'converts to arrays and hashes' do
-          subject.should_not =~ /Relation/
-          subject.should_not =~ /Tuple/
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-io/renderer/text/test_cell.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer::Text
-    describe Cell do
-     
-      let(:f){ Cell.new }
-
-      specify "text_rendering" do
-        Cell.new(100).text_rendering.should == "100"
-        Cell.new(:hello).text_rendering.should == ":hello"
-        Cell.new("hello").text_rendering.should == "hello"
-        Cell.new(10.0).text_rendering.should == "10.000"
-        Cell.new(10/3.0).text_rendering.should == "3.333"
-        Cell.new([]).text_rendering.should == "[]"
-        Cell.new([10/3.0, true]).text_rendering.should == "[3.333, true]"
-        Cell.new(10/3.0, {:float_format => "%.6f"}).text_rendering.should == "3.333333"
-      end
-
-      specify "min_width" do
-        Cell.new("").min_width.should == 0
-        Cell.new(10/3.0).min_width.should == 5
-        Cell.new("12\n5345").min_width.should == 4
-      end
-
-      specify "rendering_lines" do
-        Cell.new("").rendering_lines.should == []
-        Cell.new(10/3.0).rendering_lines.should == ["3.333"]
-        Cell.new([10/3.0,true]).rendering_lines.should == ["[3.333, true]"]
-        Cell.new("abc").rendering_lines(5).should == ["abc  "]
-        Cell.new(12).rendering_lines(5).should == ["   12"]
-      end
-
-    end
-  end
-end

data/spec/unit/alf-io/renderer/text/test_row.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer::Text
-    describe Row do
-     
-      let(:row){ Row.new(values) }
-
-      describe "when single values are used only" do
-
-        let(:values){ [ 10/3.0, true ] }
-        specify "rendering_lines" do
-          row.rendering_lines.should == ["| 3.333 | true |"]
-          row.rendering_lines([10,5]).should == ["|      3.333 | true  |"]
-        end
-
-      end
-
-      describe "when multiple-line values are used" do
-
-        let(:values){ [ 10/3.0, [1, 2, 3] ] }
-
-        specify "rendering_lines" do
-          row.rendering_lines.should == ["| 3.333 | [1, 2, 3] |"]
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-io/renderer/text/test_table.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Renderer::Text
-    describe Table do
-     
-      let(:columns){ [ :method, :total ] }
-      let(:table){ Table.new(records, columns) }
-
-      describe "on an empty table" do
-
-        let(:records){ [ ] }
-
-        specify "to_s" do
-          table.to_s.should == "+---------+--------+\n" +
-                               "| :method | :total |\n" +
-                               "+---------+--------+\n" +
-                               "+---------+--------+\n"
-        end
-
-      end
-
-      describe "when single values are used only" do
-
-        let(:records){ [ [:by_x, 10.0], [:by_y, 2.0] ] }
-
-        specify "to_s" do
-          table.to_s.should == "+---------+--------+\n" +
-                               "| :method | :total |\n" +
-                               "+---------+--------+\n" +
-                               "| :by_x   | 10.000 |\n" +
-                               "| :by_y   |  2.000 |\n" +
-                               "+---------+--------+\n"
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-io/shared_examples/a_reader_class.rb

@@ -1,19 +0,0 @@
-shared_examples_for "a Reader class" do
-
-  it 'should be a subclass of Reader' do
-    described_class.ancestors.should include(Alf::Reader)
-  end
-
-  it "has a default mime type" do
-    described_class.should respond_to(:mime_type)
-  end
-
-  describe "an instance" do
-    let(:reader){ described_class.new(StringIO.new("")) }
-
-    it 'returns a Enumerator with #each without block' do
-      reader.each.should be_a(Enumerator)
-    end
-  end
-
-end

data/spec/unit/alf-io/shared_examples/a_renderer_class.rb

@@ -1,24 +0,0 @@
-shared_examples_for "a Renderer class" do
-
-  it 'should be a subclass of Renderer' do
-    subject.ancestors.should include(Alf::Renderer)
-  end
-
-  it "has a default mime type" do
-    subject.should respond_to(:mime_type)
-  end
-
-  describe "an instance" do
-    let(:renderer){ subject.new([{id: 1}]) }
-
-    it 'renders and returns a buffer with #execute' do
-      buf = ""
-      renderer.execute(buf).should be(buf)
-    end
-
-    it 'returns a Enumerator with #each without block' do
-      renderer.each.should be_a(Enumerator)
-    end
-  end
-
-end

data/spec/unit/alf-io/support/test_proc_io.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe CSVUtils::ProcIO do
-      include CSVUtils
-
-      it 'works as expected' do
-        @seen = nil
-        proc_io = CSVUtils::ProcIO.new{|str| @seen = str}
-        with_csv(proc_io, row_sep: "\n") do |csv|
-          csv << ["Smith", 20, "London"]
-        end
-        @seen.should eq("Smith,20,London\n")
-      end
-
-    end
-  end
-end