csv2hash 0.5.0 → 0.6.0

data/spec/csv2hash/definition_spec.rb

@@ -1,70 +1,73 @@
 require 'spec_helper'
 
-describe Csv2hash::Definition do
+module Csv2hash
+  describe Definition do
+    let(:valid_rules) { [ { position: [0,0], key: 'name' } ] }
 
-  let(:valid_rules) { [ { position: [0,0], key: 'name' } ] }
-  context 'regular context' do
-    subject do
-      Csv2hash::Definition.new(
-        valid_rules,
-        Csv2hash::Definition::MAPPING
-      )
-    end
-
-    it 'variable should be assigned' do
-      expect(subject.type).to eql Csv2hash::Definition::MAPPING
-      expect(subject.rules).to eql [ { position: [0,0], key: 'name' } ]
-    end
-  end
-
-  describe '#validate!' do
-    context 'rules failling validation' do
+    context 'regular context' do
       subject do
-        Csv2hash::Definition.new nil, 'unsuitable_type'
+        Main.generate_definition :foo do
+          set_type { Definition::MAPPING }
+          mapping { cell position: [0,0], key: 'name' }
+        end
       end
-      it 'should throw exception' do
-        expect {
-          subject.validate!
-        }.to raise_error("not suitable type, please use '#{Csv2hash::Definition::MAPPING}' " \
-          "or '#{Csv2hash::Definition::COLLECTION}'")
+
+      it 'variable should be assigned' do
+        expect(subject.type).to eql Definition::MAPPING
+        expect(subject.cells.first.rules).to eql({ position: [0,0], key: 'name' })
       end
     end
-    context 'rules failling validation' do
-      subject do
-        Csv2hash::Definition.new 'rules',Csv2hash::Definition::MAPPING
+
+    describe '#validate!' do
+      context 'rules failling validation' do
+        subject do
+          Main.generate_definition :foo do
+            set_type { :unsuitable_type }
+          end
+        end
+        it 'should throw exception' do
+          expect {
+            subject.validate!
+          }.to raise_error("not suitable type, please use '#{Definition::MAPPING}' " \
+            "or '#{Definition::COLLECTION}'")
+        end
       end
-      it 'should throw exception' do
-        expect { subject.validate! }.to raise_error 'rules must be an Array of rules'
+
+      context 'structure rules failling validation' do
+        subject do
+          Main.generate_definition :foo do
+            set_type { Definition::MAPPING }
+            set_structure_rules { :unsuitable_structure_rule }
+          end
+        end
+
+        it 'should throw exception' do
+          expect { subject.validate! }.to raise_error 'structure rules must be a Hash of rules'
+        end
       end
     end
 
-    context 'structure rules failling validation' do
+    describe '#default!' do
       subject do
-        Csv2hash::Definition.new valid_rules, Csv2hash::Definition::MAPPING, { structure_rules: 'invalid structure rule' }
+        Main.generate_definition :foo do
+          set_type { Definition::MAPPING }
+          mapping { cell position: [0,0], key: 'name' }
+        end
       end
-      it 'should throw exception' do
-        expect { subject.validate! }.to raise_error 'structure rules must be a Hash of rules'
-      end
-    end
-  end
-
-  describe '#default!' do
-    subject do
-      Csv2hash::Definition.new [ { position: [0,0], key: 'name' } ], Csv2hash::Definition::MAPPING
-    end
 
-    before { subject.default! }
+      before { subject.default! }
 
-    it 'missing key must be filled' do
-      expect(subject.rules).to eql([{ position: [0, 0],
-        key: 'name',
-        message: 'undefined :key on :position',
-        mappable: true,
-        type: 'string',
-        values: nil,
-        nested: nil,
-        allow_blank: false,
-        extra_validator: nil }])
+      it 'missing key must be filled' do
+        expect(subject.cells.first.rules).to eql({ position: [0, 0],
+          key: 'name',
+          message: 'undefined :key on :position',
+          mappable: true,
+          type: 'string',
+          values: nil,
+          nested: nil,
+          allow_blank: false,
+          extra_validator: nil })
+      end
     end
   end
 end

data/spec/csv2hash/parser/collection_spec.rb

@@ -1,58 +1,63 @@
 require 'spec_helper'
 
-describe Csv2hash::Parser::Collection do
+module Csv2hash
+  describe Parser::Collection do
 
-  let(:definition) do
-    Csv2hash::Definition.new [ { position: 0, key: 'name' } ], Csv2hash::Definition::COLLECTION
-  end
+    let(:definition) do
+      Main.generate_definition :foo do
+        set_type { Definition::COLLECTION }
+        mapping { cell position: 0, key: 'name' }
+      end
+    end
 
-  let(:data_source) { [ [ 'John Doe' ], [ 'Jane Doe' ] ] }
-  let(:ignore_blank_line) { false }
+    let(:data_source) { [ [ 'John Doe' ], [ 'Jane Doe' ] ] }
+    let(:ignore_blank_line) { false }
 
-  subject do
-    Csv2hash::Main.new(definition, data_source, ignore_blank_line: ignore_blank_line)
-  end
+    subject do
+      Main.new(definition, data_source, ignore_blank_line: ignore_blank_line)
+    end
 
-  context 'regular way' do
-    it { expect { subject.parse }.to_not raise_error }
-    it {
-      expect(subject.tap do |parser|
-        parser.parse
-      end.data).to eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
-    }
-    context 'with header' do
-      before { subject.definition.header_size = 1 }
-      let(:data_source) { [ [ 'Name' ], [ 'John Doe' ], [ 'Jane Doe' ] ] }
+    context 'regular way' do
+      it { expect { subject.parse! }.to_not raise_error }
       it {
-        expect(subject.tap { |c| c.parse }.data).to eql(
-          { data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
+        expect(subject.tap do |parser|
+          parser.parse!
+        end.data).to eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
       }
+      context 'with header' do
+        before { subject.definition.header_size = 1 }
+        let(:data_source) { [ [ 'Name' ], [ 'John Doe' ], [ 'Jane Doe' ] ] }
+        it {
+          expect(subject.tap { |c| c.parse }.data).to eql(
+            { data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
+        }
+      end
     end
-  end
 
-  context 'with nested' do
-    let(:data_source) { [ [ 'John Doe', 22 ], [ 'Jane Doe', 19 ] ] }
-    before do
-      definition.rules << { position: 1, key: 'age', nested: 'infos' }
+    context 'with nested' do
+      let(:data_source) { [ [ 'John Doe', 22 ], [ 'Jane Doe', 19 ] ] }
+      before do
+        definition.cells << Cell.new({ position: 1, key: 'age', nested: 'infos' })
+      end
+      it {
+        expect(subject.tap { |c| c.parse! }.data).to eql(
+          { data: [
+            { 'name' => 'John Doe', 'infos' => { 'age' => 22 } },
+            { 'name' => 'Jane Doe', 'infos' => { 'age' => 19 } }
+            ]
+          }
+        )
+      }
     end
-    it {
-      expect(subject.tap { |c| c.parse }.data).to eql(
-        { data: [
-          { 'name' => 'John Doe', 'infos' => { 'age' => 22 } },
-          { 'name' => 'Jane Doe', 'infos' => { 'age' => 19 } }
-          ]
-        }
-      )
-    }
-  end
 
-  context '#ignore_blank_line' do
-    let(:data_source) { [ [ 'John Doe' ], [ 'Jane Doe' ], [ nil ] ] }
-    let(:ignore_blank_line) { true }
-    it {
-      expect(subject.tap do |parser|
-        parser.parse
-      end.data).to eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
-    }
+    context '#ignore_blank_line' do
+      let(:data_source) { [ [ 'John Doe' ], [ 'Jane Doe' ], [ nil ] ] }
+      let(:ignore_blank_line) { true }
+      it {
+        expect(subject.tap do |parser|
+          parser.parse!
+        end.data).to eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
+      }
+    end
   end
 end

data/spec/csv2hash/parser/mapping_spec.rb

@@ -1,36 +1,41 @@
 require 'spec_helper'
 
-describe Csv2hash::Parser::Mapping do
+module Csv2hash
+  describe Parser::Mapping do
 
-  let(:definition) do
-    Csv2hash::Definition.new [ { position: [0,0], key: 'name' } ], Csv2hash::Definition::MAPPING
-  end
+    let(:definition) do
+      Main.generate_definition :foo do
+        set_type { Definition::MAPPING }
+        mapping { cell position: [0,0], key: 'name' }
+      end
+    end
 
-  let(:data_source) { [ [ 'John Doe' ] ] }
+    let(:data_source) { [ [ 'John Doe' ] ] }
 
-  subject do
-    Csv2hash::Main.new(definition, data_source, ignore_blank_line: false)
-  end
+    subject do
+      Main.new(definition, data_source, ignore_blank_line: false)
+    end
 
-  context 'regular way' do
-    it { expect { subject.parse }.to_not raise_error }
-    it {
-      expect(subject.tap do |csv2hash|
-        csv2hash.parse
-      end.data).to eql({ data: [ { 'name' => 'John Doe' } ] })
-    }
-  end
+    context 'regular way' do
+      it { expect { subject.parse! }.to_not raise_error }
+      it {
+        expect(subject.tap do |csv2hash|
+          csv2hash.parse!
+        end.data).to eql({ data: [ { 'name' => 'John Doe' } ] })
+      }
+    end
 
-  context 'with nested' do
-    let(:data_source) { [ [ 'John Doe', 22 ] ] }
-    before do
-      definition.rules << { position: [0,1], key: 'age', nested: 'infos' }
+    context 'with nested' do
+      let(:data_source) { [ [ 'John Doe', 22 ] ] }
+      before do
+        definition.cells << Cell.new({ position: [0,1], key: 'age', nested: 'infos' })
+      end
+      it {
+        expect(subject.tap { |c| c.parse! }.data).to eql(
+          { data: [ { 'name' => 'John Doe', 'infos' => { 'age' => 22 } } ] }
+        )
+      }
     end
-    it {
-      expect(subject.tap { |c| c.parse }.data).to eql(
-        { data: [ { 'name' => 'John Doe', 'infos' => { 'age' => 22 } } ] }
-      )
-    }
-  end
 
+  end
 end

data/spec/csv2hash/structure_validator_spec.rb

@@ -1,89 +1,90 @@
 require 'spec_helper'
 
-describe Csv2hash::StructureValidator do
-
-  let(:rules) { [ { position: [0,0], key: 'name' } ] }
-  let(:options) { {} }
-  let(:definition) do
-    Csv2hash::Definition.new(rules, Csv2hash::Definition::MAPPING, options).tap do |definition|
-      definition.validate!
-      definition.default!
-    end
-  end
-
-  subject do
-    Csv2hash::Main.new(definition, data_source, ignore_blank_line: false)
-  end
-
-  context 'the csv with errors' do
-    let(:options){ { structure_rules: { 'MaxColumns' => 2 } } }
-    before { subject.parse }
-    let(:data_source) do
-      [
-        [ 'John', 'Doe' ],
-        [ 'Jane', 'Doe', 'extra field' ]
-      ]
-    end
-
-    its(:csv_with_errors) { should be_kind_of CsvArray }
-    it "adds structure error in first cell" do
-      expect(subject.csv_with_errors.first[:message]).to eq 'Too many columns (max. 2) on line 1'
+module Csv2hash
+  describe StructureValidator do
+    let(:definition) do
+      Main.generate_definition :foo do
+        set_type { Definition::MAPPING }
+        mapping { cell position: [0,0], key: 'name' }
+      end.tap do |definition|
+        definition.validate!
+        definition.default!
+      end
     end
-  end
-
-
-  context '#MaxColumns'  do
-    let(:options){ { structure_rules: { 'MaxColumns' => 2 } } }
 
-    before do
-      allow(subject).to receive(:break_on_failure) { true }
+    subject do
+      Main.new(definition, data_source, ignore_blank_line: false)
     end
 
-    context 'valid data' do
-      let(:data_source) do
-        [
-          [ 'John', 'Doe' ]
-        ]
+    context 'the csv with errors' do
+      before do
+        allow(definition).to receive(:structure_rules) {{ 'MaxColumns' => 2 }}
+        subject.parse
       end
-      it { expect { subject.validate_structure! }.to_not raise_error }
-    end
-
-    context 'invalid data' do
       let(:data_source) do
         [
           [ 'John', 'Doe' ],
           [ 'Jane', 'Doe', 'extra field' ]
         ]
       end
-      it { expect { subject.validate_structure! }.to raise_error 'Too many columns (max. 2) on line 1' }
+
+      its(:csv_with_errors) { should be_kind_of CsvArray }
+      it "adds structure error in first cell" do
+        expect(subject.csv_with_errors.first[:message]).to eq 'Too many columns (max. 2) on line 1'
+      end
     end
-  end
 
-  context '#MinColumns'  do
-    let(:options){ { structure_rules: { 'MinColumns' => 2 } } }
+    context '#MaxColumns'  do
+      before do
+        allow(definition).to receive(:structure_rules) {{ 'MaxColumns' => 2 }}
+        allow(subject).to receive(:break_on_failure) { true }
+      end
 
-    before do
-      allow(subject).to receive(:break_on_failure) { true }
-    end
+      context 'valid data' do
+        let(:data_source) do
+          [
+            [ 'John', 'Doe' ]
+          ]
+        end
+        it { expect { subject.validate_structure! }.to_not raise_error }
+      end
 
-    context 'valid data' do
-      let(:data_source) do
-        [
-          [ 'John', 'Doe', 'foo' ]
-        ]
+      context 'invalid data' do
+        let(:data_source) do
+          [
+            [ 'John', 'Doe' ],
+            [ 'Jane', 'Doe', 'extra field' ]
+          ]
+        end
+        it { expect { subject.validate_structure! }.to raise_error 'Too many columns (max. 2) on line 1' }
       end
-      it { expect { subject.validate_structure! }.to_not raise_error }
     end
 
-    context 'invalid data' do
-      let(:data_source) do
-        [
-          [ 'John' ],
-          [ 'Jane', 'Doe' ]
-        ]
+    context '#MinColumns'  do
+      before do
+        allow(definition).to receive(:structure_rules) {{ 'MinColumns' => 2 }}
+        allow(subject).to receive(:break_on_failure) { true }
+      end
+
+      context 'valid data' do
+        let(:data_source) do
+          [
+            [ 'John', 'Doe', 'foo' ]
+          ]
+        end
+        it { expect { subject.validate_structure! }.to_not raise_error }
+      end
+
+      context 'invalid data' do
+        let(:data_source) do
+          [
+            [ 'John' ],
+            [ 'Jane', 'Doe' ]
+          ]
+        end
+        it { expect { subject.validate_structure! }.to raise_error 'Not enough columns (min. 2) on line 0' }
       end
-      it { expect { subject.validate_structure! }.to raise_error 'Not enough columns (min. 2) on line 0' }
     end
-  end
 
+  end
 end

data/spec/csv2hash/validator/collection_spec.rb

@@ -1,78 +1,86 @@
 require 'spec_helper'
 
-describe Csv2hash::Validator::Collection do
-  let(:options) { {} }
-  let(:definition) do
-    Csv2hash::Definition.new([ { position: 0, key: 'name' } ], Csv2hash::Definition::COLLECTION, options).tap do |definition|
-      definition.validate!
-      definition.default!
+module Csv2hash
+  describe Validator::Collection do
+    let(:options) { {} }
+    let(:definition) do
+      Main.generate_definition :foo do
+        set_type { Definition::COLLECTION }
+        mapping { cell position: 0, key: 'name' }
+      end.tap do |definition|
+        definition.validate!
+        definition.default!
+      end
     end
-  end
-  let(:ignore_blank_line) { false }
+    let(:ignore_blank_line) { false }
 
-  subject do
-    Csv2hash::Main.new(definition, data_source, ignore_blank_line: ignore_blank_line)
-  end
+    subject do
+      Main.new(definition, data_source, ignore_blank_line: ignore_blank_line)
+    end
 
-  before do
-    allow(subject).to receive(:break_on_failure) { true }
-  end
+    before do
+      allow(subject).to receive(:break_on_failure) { true }
+    end
 
-  context 'with valid data' do
-    let(:data_source) { [ [ 'John Doe' ] ]}
+    context 'with valid data' do
+      let(:data_source) { [ [ 'John Doe' ] ]}
 
-    it { expect { subject.validate_data! }.to_not raise_error }
-    context 'with header' do
-      let(:options) { { header_size: 1 } }
-      let(:data_source) { [ [ 'Name' ], [ 'John Doe' ] ]}
       it { expect { subject.validate_data! }.to_not raise_error }
+      context 'with header' do
+        let(:options) { { header_size: 1 } }
+        let(:data_source) { [ [ 'Name' ], [ 'John Doe' ] ]}
+        it { expect { subject.validate_data! }.to_not raise_error }
+      end
     end
-  end
 
-  context '#ignore_blank_line' do
-    let(:data_source) { [ [ ] ] }
-    let(:ignore_blank_line) { true }
-    it { expect { subject.validate_data! }.to_not raise_error }
-    context 'csv mode' do
-      before { subject.break_on_failure = false }
-      its(:errors) { should be_empty }
+    context '#ignore_blank_line' do
+      let(:data_source) { [ [ ] ] }
+      let(:ignore_blank_line) { true }
+      it { expect { subject.validate_data! }.to_not raise_error }
+      context 'csv mode' do
+        before { subject.break_on_failure = false }
+        its(:errors) { should be_empty }
+      end
     end
-  end
 
-  context 'with invalid data' do
-    let(:data_source) { [ [ ] ] }
-    it { expect { subject.validate_data! }.to raise_error('undefined name on [0, 0]') }
-    context 'with header' do
-      let(:options) { { header_size: 1 } }
-      let(:data_source) { [ [ 'Name' ], [ ] ]}
-      it { expect { subject.validate_data! }.to raise_error('undefined name on [1, 0]') }
+    context 'with invalid data' do
+      let(:data_source) { [ [ ] ] }
+      it { expect { subject.validate_data! }.to raise_error('undefined name on [0, 0]') }
+      context 'with header' do
+        let(:options) { { header_size: 1 } }
+        let(:data_source) { [ [ 'Name' ], [ ] ]}
+        it { expect { subject.validate_data! }.to raise_error('undefined name on [1, 0]') }
+      end
     end
-  end
 
-  context 'wihtout exception' do
-    let(:data_source) { [ [ ] ]}
+    context 'wihtout exception' do
+      let(:data_source) { [ [ ] ]}
 
-    before do
-      allow(subject).to receive(:break_on_failure) { false }
-    end
+      before do
+        allow(subject).to receive(:break_on_failure) { false }
+      end
 
-    it { expect(subject.parse.errors.to_csv).to eql ",\"undefined name on [0, 0]\"\n" }
+      it { expect(subject.parse.errors.to_csv).to eql ",\"undefined name on [0, 0]\"\n" }
 
-    context 'errors should be filled' do
-      before { subject.parse }
-      its(:errors) { should eql [{x: 0, y: 0, message: 'undefined name on [0, 0]', key: 'name'}] }
-    end
+      context 'errors should be filled' do
+        before { subject.parse }
+        its(:errors) { should eql [{x: 0, y: 0, message: 'undefined name on [0, 0]', key: 'name'}] }
+      end
 
-    context 'original csv + errors should returned' do
-      let(:definition) do
-        Csv2hash::Definition.new(
-          [{ position: 0, key: 'agree', values: ['yes', 'no'] }], Csv2hash::Definition::COLLECTION).tap do |d|
-          d.validate!; d.default!
+      context 'original csv + errors should returned' do
+        let(:definition) do
+          Main.generate_definition :foo do
+            set_type { Definition::COLLECTION }
+            mapping  { cell position: 0, key: 'agree', values: ['yes', 'no'] }
+          end.tap do |definition|
+            definition.validate!
+            definition.default!
+          end
         end
+        let(:data_source) { [ [ 'what?' ], [ 'yes' ], [ 'no' ] ] }
+        it { expect(subject.parse.errors.to_csv).to eql "what?,\"agree not supported, please use one of [\"\"yes\"\", \"\"no\"\"]\"\n" }
       end
-      let(:data_source) { [ [ 'what?' ], [ 'yes' ], [ 'no' ] ] }
-      it { expect(subject.parse.errors.to_csv).to eql "what?,\"agree not supported, please use one of [\"\"yes\"\", \"\"no\"\"]\"\n" }
     end
-  end
 
+  end
 end