csv2hash 0.5.0 → 0.6.0

data/spec/csv2hash/validator/mapping_spec.rb

@@ -1,103 +1,107 @@
 require 'spec_helper'
 
-describe Csv2hash::Validator::Mapping do
+module Csv2hash
+  describe Validator::Mapping do
 
-  let(:definition) do
-    Csv2hash::Definition.new([ { position: [0,0], key: 'name' } ], Csv2hash::Definition::MAPPING).tap do |definition|
-      definition.validate!
-      definition.default!
+    let(:definition) do
+      Main.generate_definition :foo do
+        set_type { Definition::MAPPING }
+        mapping { cell position: [0,0], key: 'name' }
+      end.tap { |d| d.validate! ; d.default! }
     end
-  end
 
-  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
 
-  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' ] ]}
-    it { expect { subject.validate_data! }.to_not raise_error }
-  end
+    context 'with valid data' do
+      let(:data_source) { [ [ 'John Doe' ] ]}
+      it { expect { subject.validate_data! }.to_not raise_error }
+    end
 
-  context 'with invalid data' do
-    let(:data_source) { [ [ ] ]}
-    it { expect { subject.validate_data! }.to raise_error('undefined name on [0, 0]') }
-  end
+    context 'with invalid data' do
+      let(:data_source) { [ [ ] ]}
+      it { expect { subject.validate_data! }.to raise_error('undefined name on [0, 0]') }
+    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 be returned' do
-      let(:definition) do
-        Csv2hash::Definition.new(rules, Csv2hash::Definition::MAPPING).tap do |d|
-          d.validate!; d.default!
+      context 'original csv + errors should be returned' do
+        let(:definition) do
+          Main.generate_definition :foo do
+            set_type { Definition::MAPPING }
+            mapping do
+              cell position: [0,0], key: 'agree', values: ['yes', 'no']
+              cell position: [1,0], key: 'agree', values: ['yes', 'no']
+              cell position: [2,0], key: 'agree', values: ['yes', 'no']
+            end
+          end.tap { |d| d.validate! ; d.default! }
         end
-      end
-      context 'string values' do
-        let(:rules) do
-          [
-            { position: [0,0], key: 'agree', values: ['yes', 'no'] },
-            { position: [1,0], key: 'agree', values: ['yes', 'no'] },
-            { position: [2,0], key: 'agree', values: ['yes', 'no'] }
-          ]
+        context 'string values' do
+          let(:data_source) { [ [ 'what?' ], [ 'yes', 'what?' ], [ 'yes', 'what?', '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', 'what?' ], [ 'yes', 'what?', 'no' ] ] }
-        it { expect(subject.parse.errors.to_csv).to eql(
-          "what?,\"agree not supported, please use one of [\"\"yes\"\", \"\"no\"\"]\"\n") }
-      end
-      context 'range values' do
-        let(:rules) do
-          [
-            { position: [0,0], key: 'score', values: 1..10 },
-            { position: [1,0], key: 'score', values: 1..10 },
-            { position: [2,0], key: 'score', values: 1..10 }
-          ]
+        context 'range values' do
+          let(:definition) do
+            Main.generate_definition :foo do
+              set_type { Definition::MAPPING }
+              mapping do
+                cell position: [0,0], key: 'score', values: 1..10
+                cell position: [1,0], key: 'score', values: 1..10
+                cell position: [2,0], key: 'score', values: 1..10
+              end
+            end.tap { |d| d.validate! ; d.default! }
+          end
+          let(:data_source) { [ [ 12 ], [ 2, 12 ], [ 3, 12, 1 ] ] }
+          it { expect(subject.parse.errors.to_csv).to eql("12,\"score not supported, please use one of 1..10\"\n") }
         end
-        let(:data_source) { [ [ 12 ], [ 2, 12 ], [ 3, 12, 1 ] ] }
-        it { expect(subject.parse.errors.to_csv).to eql("12,\"score not supported, please use one of 1..10\"\n") }
       end
-    end
 
-    context 'with extra_validator' do
-      let(:definition) do
-        Csv2hash::Definition.new([
-            { position: [0,0], key: 'name', extra_validator: DowncaseValidator.new,
-              message: 'your data should be writting in downcase only'
-            }
-          ],
-          Csv2hash::Definition::MAPPING).tap do |definition|
-          definition.validate!; definition.default!
+      context 'with extra_validator' do
+        let(:definition) do
+          Main.generate_definition :foo do
+            set_type { Definition::MAPPING }
+            mapping do
+              cell position: [0,0], key: 'name', extra_validator: DowncaseValidator.new,
+                message: 'your data should be writting in downcase only'
+            end
+          end.tap { |d| d.validate! ; d.default! }
+        end
+        before { subject.parse }
+        context 'not valid data' do
+          let(:data_source) { [ [ 'Foo' ] ] }
+          its(:errors) do
+            should eql [{x: 0, y: 0, message: 'your data should be writting in downcase only', key: 'name'}]
+          end
+        end
+        context 'valid data' do
+          let(:data_source) { [ [ 'foo' ] ] }
+          its(:errors) { should be_empty }
         end
-      end
-      before { subject.parse }
-      context 'not valid data' do
-        let(:data_source) { [ [ 'Foo' ] ] }
-        its(:errors) { should eql [{x: 0, y: 0, message: 'your data should be writting in downcase only', key: 'name'}]}
-      end
-      context 'valid data' do
-        let(:data_source) { [ [ 'foo' ] ] }
-        its(:errors) { should be_empty }
       end
     end
   end
-end
 
-class DowncaseValidator < Csv2hash::ExtraValidator
-  def valid? rule, value
-    !!(value.match /^[a-z]+$/)
+  class DowncaseValidator < ExtraValidator
+    def valid? rule, value
+      !!(value.match /^[a-z]+$/)
+    end
   end
 end

data/spec/csv2hash/validator_spec.rb

@@ -1,40 +1,41 @@
 require 'spec_helper'
 
-describe Csv2hash::Validator do
+module Csv2hash
+  describe 'Validator' do
 
-  let(:definition) do
-    Csv2hash::Definition.new([ { position: [0,0], key: 'name' } ], Csv2hash::Definition::MAPPING).tap do |definition|
-      definition.validate!
-      definition.default!
-    end
-  end
+    describe '#message' do
+      let(:cell) { double(:cell, rules: rules) }
 
-  describe '#message' do
-    subject { Csv2hash::Main.new double('definition', type: Csv2hash::Definition::COLLECTION), nil }
+      subject do
+        Class.new do
+          include Validator
+        end.new
+      end
 
-    context 'string value' do
-      let(:rule) { { foo: 'bar', message: ':foo are value of foo key' } }
+      context 'string value' do
+        let(:rules) {{ foo: 'bar', message: ':foo are value of foo key' }}
 
-      it 'substitue value of key' do
-        expect(subject.send(:message, rule, nil, nil)).to eql 'bar are value of foo key'
+        it 'substitue value of key' do
+          expect(subject.send(:message, cell, nil, nil)).to eql 'bar are value of foo key'
+        end
       end
-    end
 
-    context 'array value' do
-      let(:rule) { { foo: ['bar', 'zone'], message: ':foo are values of foo key' } }
+      context 'array value' do
+        let(:rules) { { foo: ['bar', 'zone'], message: ':foo are values of foo key' } }
 
-      it 'substitue value of key' do
-        expect(subject.send(:message, rule, nil, nil)).to eql '["bar", "zone"] are values of foo key'
+        it 'substitue value of key' do
+          expect(subject.send(:message, cell, nil, nil)).to eql '["bar", "zone"] are values of foo key'
+        end
       end
-    end
 
-    context 'with position' do
-      let(:rule) { { message: 'value not found on :position' } }
+      context 'with position' do
+        let(:rules) { { message: 'value not found on :position' } }
 
-      it 'substitue value of key' do
-        expect(subject.send(:message, rule, 0, 2)).to eql 'value not found on [0, 2]'
+        it 'substitue value of key' do
+          expect(subject.send(:message, cell, 0, 2)).to eql 'value not found on [0, 2]'
+        end
       end
     end
-  end
 
+  end
 end

data/spec/csv2hash_spec.rb

@@ -1,3 +1,17 @@
 require 'spec_helper'
 
-describe Csv2hash
+describe Csv2hash do
+  let(:definition)  { double('definition', type: nil) }
+  let(:data_source) { nil }
+
+  subject do
+    Csv2hash::Main.new(definition, data_source, ignore_blank_line: false)
+  end
+
+  context '...' do
+    specify do
+      expect(subject.options.fetch(:ignore_blank_line)).to eql(false)
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csv2hash
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Joel AZEMAR
@@ -83,6 +83,7 @@ dependencies:
 description: DSL to map a CSV to a Ruby Hash
 email: joel.azemar@gmail.com
 executables:
+- launch_irb
 - load_rvm
 extensions: []
 extra_rdoc_files: []
@@ -97,6 +98,7 @@ files:
 - README.md
 - Rakefile
 - ReleaseNotes.md
+- bin/launch_irb
 - bin/load_rvm
 - coverage/.resultset.json.lock
 - csv2hash.gemspec
@@ -105,14 +107,17 @@ files:
 - lib/csv2hash/adapters/base.rb
 - lib/csv2hash/adapters/csv_adapter.rb
 - lib/csv2hash/adapters/memory_adapter.rb
+- lib/csv2hash/cell.rb
 - lib/csv2hash/csv_array.rb
 - lib/csv2hash/data_wrapper.rb
 - lib/csv2hash/definition.rb
+- lib/csv2hash/expectation.rb
 - lib/csv2hash/extra_validator.rb
 - lib/csv2hash/notifier.rb
 - lib/csv2hash/parser.rb
 - lib/csv2hash/parser/collection.rb
 - lib/csv2hash/parser/mapping.rb
+- lib/csv2hash/registry.rb
 - lib/csv2hash/structure_validator.rb
 - lib/csv2hash/structure_validator/max_columns.rb
 - lib/csv2hash/structure_validator/min_columns.rb