csv2hash 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f8f8219aff79abbf8d98c623d02d6e95929af47
-  data.tar.gz: 428d41f0b1a1c8490bb19aa78d0dbf4dbe61f487
+  metadata.gz: d4d2f7ba34ef01f65b28e952dcc72dc479ed2891
+  data.tar.gz: 77bfe0698393fedb815d54f631d8e6e7af05f401
 SHA512:
-  metadata.gz: 1b68da6acde6bace6121a0db5dfb4470827d6129f17f776a83157870c0f8f5977ad72bbead178782694d4ceeb0ae54d369a8152b2a6b11482bc4935e96c0db45
-  data.tar.gz: d492de227d7970cbbed83e984ae531d7fa4e5761a345320bbde6c58e93daa4aede871af4a5e7cb7bb0e27618c7d4286fe28b660eb5feb77410757a31c434c14c
+  metadata.gz: d246e42bd2202619bc8e4ad3ca581c9c5b3fa15be34bcee30817d31030b782d33d1f1e2d89cf95df17059c21e63c185bc4a682ec9a08fbc5c1242f18ed0e8800
+  data.tar.gz: b863db362851632a77e7a157d5a112f67e0e8d3c6ae31dd7a2d610fdc92defb1c59f720656a84e54f2ac207b79b2e695924e91925c99dbc808322cb4c2ceb101

data/.gitignore

@@ -4,3 +4,7 @@ private.notes
 *.gem
 bundler/
 
+
+coverage/.last_run.json
+
+coverage/.resultset.json

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    csv2hash (0.0.1)
+    csv2hash (0.0.2)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -27,6 +27,8 @@ Or install it yourself as:
 
 ## Usage
 
+#### Rules
+
 You should be declare an definition for you CSV, for each cells you should define what you expect.
 
 Example :
@@ -35,7 +37,7 @@ You want first cell parsed should be string with values are 'yes' or 'no' you mu
 
 	{ name: 'aswering', type: 'string', values: ['yes', 'no'], position: [0,0] }
 
-All keys as default value, so you can just define this rule :
+All keys as default values, so you can just define this rule :
 
 	{ name: 'aswering', values: ['yes', 'no'], position: [0,0] }
 
@@ -43,23 +45,148 @@ You can define message, default is 'undefined :key on :position'
 
 	{ name: 'aswering', values: ['yes', 'no'], position: [0,0], message: 'this value is not supported' }
 
+You can also define Range
+
+	{ name: 'score', values: 0..5, position: [0,0] }
+
 if you insert key on you message they will be substituted
 
 	{ ..., message: 'value of :name is not supported, please you one of :values' }
 
-produce ':
-	value of aswering is not supported, please you one of [yes, no]'
+produce :
+
+
+	value of aswering is not supported, please you one of [yes, no]
+
+##### Position
+
+Position mean [Y, X], where Y is rows, X columns
+
+#### Definition
+
+You should provide a definition, you have 2 types of definitions, mapping definition for search on x,y in your data or collection definition for rules apply for all lines in x, so you position rules should be only x value
+
+### Sample
+
+#### Mapping
+
+Consider csv data like that
+
+| Fields      | Person Informations  | Optional |
+|-------------|----------------------|----------|
+| Nickname    |        john          |    no    |
+| First Name  |        John          |    yes   |
+| Last Name   |        Doe           |    yes   |
+
+
+Mapping sample definition
+
+	class MyParser
+
+		attr_accessor :file_path
+
+		def initialize file_path
+			@file_path = file_path
+		end
+
+		def rules
+			[].tap do |mapping|
+				mapping << { position: [2,1], key: 'first_name' }
+				mapping << { position: [3,1], key: 'last_name' }
+			end
+		end
+
+		def definition
+			Definition.new(rules, type = Definition::MAPPING)
+		end
+
+		def data
+			Csv2hash.new(definition, file_path).tap do |csv2hash|
+				csv2hash.parse
+			end.data
+		end
+
+	end
+
+#### Collection
+
+Consider csv data like that
+
+| Nickname | First Name | Last Name |
+|----------|------------|-----------|
+|   john   |    John    |    Doe    |
+|   jane   |    Jane    |    Doe    |
+
+Mapping sample definition
+
+	class MyParser
+
+		attr_accessor :file_path
+
+		def initialize file_path
+			@file_path = file_path
+		end
+
+		def rules
+			[].tap do |mapping|
+				mapping << { position: 0, key: 'nickname'   }
+				mapping << { position: 1, key: 'first_name' }
+				mapping << { position: 2, key: 'last_name'  }
+			end
+		end
+
+		def definition
+			Definition.new(rules, type = Definition::COLLECTION)
+		end
+
+		def data
+			Csv2hash.new(definition, file_path).tap do |csv2hash|
+				csv2hash.parse
+			end.data
+		end
+
+	end
+
+#### Headers
+
+You should be define header size
+
+	Definition.new(rules, type, header_size=0)
+
+#### Exception or CSV mode
+
+You can choice 2 mode of parsing, either exception mode for raise exception in first breaking rules or csv mode for get csv original data + errors throwing into added columns.
+
+
+parse return data or csv_with_errors if parse is invalid, you can plug this like that :
+
+	csv2hash = Csv2hash.new(definition, 'file_path').new
+	result = csv2hash.parse
+	return result if csv2hash.valid?
+
+	filename = 'issues_errors.csv'
+	tempfile = Tempfile.new [filename, File.extname(filename)]
+	File.open(tempfile.path, 'wb') { |file| file.write result }
+
+	# Send mail with csv file + errors and free resource
+
+	tempfile.unlink
+
 
 #### Default values
 
+only position is require
+
+* :position
+
+all remaind keys are optionals
+
 * message:     'undefined :key on :position'
 * mappable:    true
 * type:        'string'
 * values:      nil
 * nested:      nil
 * allow_blank: false
-* position:    nil
-* maptype:     'cell'
 
 ### Limitations
 

data/bin/publish

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# bin/publish 0.0.1
+
+class Publish
+
+  def start version
+    system "bundle && bundle exec rake spec"
+    system "gem build csv2hash.gemspec"
+    system "git tag -a v#{version} -m 'version #{version}'"
+    system "git push --tags"
+    system "gem push csv2hash-#{version}.gem"
+    system "git push origin master"
+  end
+
+end
+
+if ARGV.length != 1 or !ARGV[0].match(/\d{1,3}.\d{1,3}.\d{1,3}/)
+  puts 'HELP: '
+  puts '$ bin/publish 0.0.1'
+  exit 0
+end
+
+Publish.new.start ARGV[0]

data/csv2hash.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |spec|
 
   spec.name        = 'csv2hash'
-  spec.version     = '0.0.1'
+  spec.version     = '0.0.2'
   spec.date        = '2013-11-26'
   spec.summary     = %q{Mapping CSV to Ruby Hash}
   spec.description = %q{DSL for CSV Ruby Hash mapping}

data/lib/csv2hash/csv_array.rb

@@ -0,0 +1,12 @@
+require 'csv'
+class CsvArray < Array
+
+  def to_csv options = {}
+    CSV.generate(options) do |csv|
+      self.each do |element|
+        csv << element
+      end
+    end
+  end
+
+end

data/lib/csv2hash/definition.rb

@@ -5,7 +5,11 @@ class Definition
 
   TYPES = [Definition::MAPPING, Definition::COLLECTION]
 
-  attr_accessor :type, :rules
+  attr_accessor :rules, :type, :header_size
+
+  def initialize rules, type, header_size=0
+    @rules, @type, @header_size = rules, type, header_size
+  end
 
   def validate!
     unless TYPES.include?(type)
@@ -17,14 +21,18 @@ class Definition
   def default!
     rules.each do |rule|
       default_position rule
-      rule.merge! message:     'undefined :key on :position' unless rule.has_key? :message
+      unless rule.has_key? :message
+        if rule.has_key? :values
+          rule.merge! message: ':key not supported, please use one of :values'
+        else
+          rule.merge! message: 'undefined :key on :position'
+        end
+      end
       rule.merge! mappable:    true                          unless rule.has_key? :mappable
       rule.merge! type:       'string'                       unless rule.has_key? :type
       rule.merge! values:      nil                           unless rule.has_key? :values
       rule.merge! nested:      nil                           unless rule.has_key? :nested
       rule.merge! allow_blank: false                         unless rule.has_key? :allow_blank
-      rule.merge! position:    nil                           unless rule.has_key? :position
-      rule.merge! maptype:     'cell'                        unless rule.has_key? :maptype
     end
   end
 
@@ -33,11 +41,11 @@ class Definition
   def default_position rule
     case type
     when Definition::MAPPING
-      x, y = rule.fetch(:position, ['undefined', 'undefined'])
-      rule.merge! key: "key_#{x}_#{y}" unless rule.has_key? :key
+      y, x = rule.fetch(:position, ['undefined', 'undefined'])
+      rule.merge! key: "key_#{y}_#{x}" unless rule.has_key? :key
     when Definition::COLLECTION
-      y = rule.fetch :position
-      rule.merge! key: "key_#{y}" unless rule.has_key? :key
+      x = rule.fetch :position
+      rule.merge! key: "key_undefined_#{x}" unless rule.has_key? :key
     end
   end
 

data/lib/csv2hash/parser/collection.rb

@@ -0,0 +1,29 @@
+module Parser::Collection extend Parser
+
+  def fill!
+    @data = {}.tap do |data_computed|
+      data_computed[:data] ||= []
+      @data_source.each_with_index do |line, y|
+        next if y < definition.header_size
+        data_computed[:data] << {}.tap do |data_parsed|
+          fill_it data_parsed, line
+        end
+      end
+    end
+  end
+
+  def fill_it parsed_data, source_data
+    definition.rules.each do |rule|
+      if rule.fetch :mappable
+        x = rule.fetch :position
+        if (nested = rule.fetch :nested)
+          parsed_data[nested] ||= {}
+          parsed_data[nested][rule.fetch(:key)] = source_data[x]
+        else
+          parsed_data[rule.fetch(:key)] = source_data[x]
+        end
+      end
+    end
+  end
+
+end

data/lib/csv2hash/parser/mapping.rb

@@ -0,0 +1,26 @@
+module Parser::Mapping extend Parser
+
+  def fill!
+    @data = {}.tap do |data_computed|
+      data_computed[:data] ||= []
+      data_computed[:data] << {}.tap do |data_parsed|
+        fill_it data_parsed, data_source
+      end
+    end
+  end
+
+  def fill_it parsed_data, source_data
+    definition.rules.each do |rule|
+      if rule.fetch :mappable
+        y, x = rule.fetch :position
+        if (nested = rule.fetch :nested)
+          parsed_data[nested] ||= {}
+          parsed_data[nested][rule.fetch(:key)] = source_data[y][x]
+        else
+          parsed_data[rule.fetch(:key)] = source_data[y][x]
+        end
+      end
+    end
+  end
+
+end

data/lib/csv2hash/parser.rb

@@ -1,24 +1,2 @@
 module Parser
-
-  def fill!
-    @data = {}.tap do |data_computed|
-      data_computed[:data] ||= []
-      data_computed[:data] << {}.tap do |data_parsed|
-
-        definition.rules.each do |rule|
-          if rule.fetch :mappable
-            x, y = rule.fetch :position
-            if (nested = rule.fetch :nested)
-              data_parsed[nested] ||= {}
-              data_parsed[nested][rule.fetch(:key)] = data_source[x][y]
-            else
-              data_parsed[rule.fetch(:key)] = data_source[x][y]
-            end
-          end
-        end
-
-      end
-    end
-  end
-
 end

data/lib/csv2hash/validator/collection.rb

@@ -0,0 +1,17 @@
+module Validator::Collection
+  include Validator
+
+  def validate_data!
+    @data_source.each_with_index do |line, y|
+      next if y < definition.header_size
+      validate_rules y
+    end
+  end
+
+  protected
+
+  def position _position
+    [nil, _position]
+  end
+
+end

data/lib/csv2hash/validator/mapping.rb

@@ -0,0 +1,14 @@
+module Validator::Mapping
+  include Validator
+
+  def validate_data!
+    validate_rules data_source
+  end
+
+  protected
+
+  def position _position
+    _position
+  end
+
+end

data/lib/csv2hash/validator.rb

@@ -1,34 +1,42 @@
 module Validator
-  
-  def validate_data!
+
+  attr_accessor :errors, :exception
+
+  def validate_rules y=nil
     definition.rules.each do |rule|
-      if (rule.fetch(:maptype) == 'cell')
-        x, y = rule.fetch :position
-        validate_rule x, y, rule
+      _y, x = position rule.fetch(:position)
+      begin
+        validate_cell (_y||y), x, rule
+      rescue => e
+        errors << { y: (_y||y), x: x, message: e.message, key: rule.fetch(:key) }
+        raise if exception
       end
     end
   end
 
-  private
+  def valid?() errors.empty?; end
+
+  protected
+
+  def validate_cell y, x, rule
+
+    value = data_source[y][x] rescue nil
 
-  def validate_rule x, y, rule
     begin
-      raise unless data_source[x]
-      unless rule.fetch :allow_blank
-        raise unless data_source[x][y]
-      end
-      if (values = rule.fetch :values)
-        raise unless values.include?(data_source[x][y])
+      raise unless value unless rule.fetch :allow_blank
+      if value && (values = rule.fetch :values)
+        raise unless values.include?(value)
       end
     rescue => e
-      raise message(rule)
+      raise message(rule, y, x)
     end
   end
 
-  def message rule
-    rule.fetch(:message).tap do |msg|
-      rule.each { |key, value| msg.gsub! ":#{key.to_s}", value.to_s }
+  def message rule, y, x
+    msg = rule.fetch(:message).tap do |msg|
+      rule.each { |key, value| msg.gsub!(":#{key.to_s}", value.to_s) unless key == :position }
     end
+    msg.gsub ':position', "[#{y}, #{x}]"
   end
-  
+
 end

data/lib/csv2hash/version.rb

@@ -1,3 +1,3 @@
 module Cvs2hash
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/csv2hash.rb

@@ -1,24 +1,73 @@
 require 'csv2hash/version'
 require 'csv2hash/definition'
-require 'csv2hash/definition/mapping'
 require 'csv2hash/validator'
+require 'csv2hash/validator/mapping'
+require 'csv2hash/validator/collection'
 require 'csv2hash/parser'
+require 'csv2hash/parser/mapping'
+require 'csv2hash/parser/collection'
+require 'csv2hash/csv_array'
+require 'csv'
 
 class Csv2hash
-  include Validator
-  include Parser
 
-  attr_accessor :definition, :data_source, :data
+  attr_accessor :definition, :file_path, :data, :data_source
 
-  def initialize definition, data_source
-    @definition, @data_source = definition, data_source
+  def initialize definition, file_path, exception=true
+    @definition, @file_path = definition, file_path
+    dynamic_parser_loading
+    @exception, @errors = exception, []
+    dynamic_validator_loading
   end
 
   def parse
+    load_data_source
     definition.validate!
     definition.default!
     validate_data!
-    fill!
+    if valid?
+      fill!
+      data
+    else
+      csv_with_errors
+    end
+  end
+
+  def csv_with_errors
+    @csv_with_errors ||= begin
+      CsvArray.new.tap do |rows|
+        errors.each do |error|
+          rows << (([data_source[error[:x]][error[:y]]]||[nil]) + [error[:message]])
+        end
+      end.to_csv
+    end
+  end
+
+  # protected
+
+  def data_source
+    @data_source ||= CSV.read @file_path
+  end
+  alias_method :load_data_source, :data_source
+
+  private
+
+  def dynamic_validator_loading
+    case definition.type
+    when Definition::MAPPING
+      self.extend Validator::Mapping
+    when Definition::COLLECTION
+      self.extend Validator::Collection
+    end
+  end
+
+  def dynamic_parser_loading
+    case definition.type
+    when Definition::MAPPING
+      self.extend Parser::Mapping
+    when Definition::COLLECTION
+      self.extend Parser::Collection
+    end
   end
 
 end

data/spec/csv2hash/definition_spec.rb

@@ -4,14 +4,10 @@ describe Definition do
 
   context 'regular context' do
     subject do
-      Definition.new.tap do |definition|
-        definition.type = Definition::MAPPING
-        definition.rules = begin
-          [
-            { position: [0,0], key: 'name' }
-          ]
-        end
-      end
+      Definition.new(
+        [ { position: [0,0], key: 'name' } ],
+        Definition::MAPPING
+      )
     end
 
     it 'variable should be assigned' do
@@ -23,9 +19,7 @@ describe Definition do
   describe '#validate!' do
     context 'rules failling validation' do
       subject do
-        Definition.new.tap do |definition|
-          definition.type = 'unsuitable_type'
-        end
+        Definition.new nil, 'unsuitable_type'
       end
       it 'should throw exception' do
         expect {
@@ -35,10 +29,7 @@ describe Definition do
     end
     context 'rules failling validation' do
       subject do
-        Definition.new.tap do |definition|
-          definition.type = Definition::MAPPING
-          definition.rules = 'rules'
-        end
+        Definition.new 'rules',Definition::MAPPING
       end
       it 'should throw exception' do
         expect { subject.validate! }.to raise_error 'rules must be an Array of rules'
@@ -48,14 +39,7 @@ describe Definition do
 
   describe '#default!' do
     subject do
-      Definition.new.tap do |definition|
-        definition.type = Definition::MAPPING
-        definition.rules = begin
-          [
-            { position: [0,0], key: 'name' }
-          ]
-        end
-      end
+      Definition.new [ { position: [0,0], key: 'name' } ], Definition::MAPPING
     end
 
     before { subject.default! }
@@ -68,8 +52,7 @@ describe Definition do
         type: 'string',
         values: nil,
         nested: nil,
-        allow_blank: false,
-        maptype: 'cell' }])
+        allow_blank: false }])
     end
   end
 end

data/spec/csv2hash/parser/collection_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Parser::Collection do
+
+  let(:definition) do
+    Definition.new [ { position: 0, key: 'name' } ], Definition::COLLECTION
+  end
+
+  let(:data_source) { [ [ 'John Doe' ], [ 'Jane Doe' ] ] }
+
+  subject do
+    Csv2hash.new(definition, 'file_path').tap do |csv2hash|
+      csv2hash.data_source = data_source
+    end
+  end
+
+  context 'regular way' do
+    it { expect { subject.parse }.to_not raise_error }
+    it {
+      subject.tap do |csv2hash|
+        csv2hash.parse
+      end.data.should 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 {
+        subject.tap { |c| c.parse }.data.should eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
+      }
+    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' }
+    end
+    it {
+      subject.tap { |c| c.parse }.data.should eql(
+        { data: [
+          { 'name' => 'John Doe', 'infos' => { 'age' => 22 } },
+          { 'name' => 'Jane Doe', 'infos' => { 'age' => 19 } }
+          ]
+        }
+      )
+    }
+  end
+
+end

data/spec/csv2hash/parser/mapping_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Parser::Mapping do
+
+  let(:definition) do
+    Definition.new [ { position: [0,0], key: 'name' } ], Definition::MAPPING
+  end
+
+  let(:data_source) { [ [ 'John Doe' ] ] }
+
+  subject do
+    Csv2hash.new(definition, 'file_path').tap do |csv2hash|
+      csv2hash.data_source = data_source
+    end
+  end
+
+  context 'regular way' do
+    it { expect { subject.parse }.to_not raise_error }
+    it {
+      subject.tap do |csv2hash|
+        csv2hash.parse
+      end.data.should 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' }
+    end
+    it {
+      subject.tap { |c| c.parse }.data.should eql(
+        { data: [ { 'name' => 'John Doe', 'infos' => { 'age' => 22 } } ] }
+      )
+    }
+  end
+
+end

data/spec/csv2hash/parser_spec.rb

@@ -1,39 +1,3 @@
 require 'spec_helper'
 
-describe Parser do
-
-  let(:definition) do
-    Definition.new.tap do |definition|
-      definition.type = Definition::MAPPING
-      definition.rules = [ { position: [0,0], key: 'name' } ]
-      definition.validate!
-      definition.default!
-    end
-  end
-
-  let(:data_source) { [ [ 'John Doe' ] ] }
-
-  subject { Csv2hash.new definition, data_source }
-
-  context 'regular way' do
-    it { expect { subject.parse }.to_not raise_error }
-    it {
-      subject.tap do |csv2hash|
-        csv2hash.parse
-      end.data.should 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' }
-    end
-    it {
-      subject.tap { |c| c.parse }.data.should eql(
-        { data: [ { 'name' => 'John Doe', 'infos' => { 'age' => 22 } } ] }
-      )
-    }
-  end
-
-end
+describe Parser

data/spec/csv2hash/validator/collection_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Validator::Collection do
+
+  let(:definition) do
+    Definition.new([ { position: 0, key: 'name' } ], Definition::COLLECTION).tap do |definition|
+      definition.validate!
+      definition.default!
+    end
+  end
+
+  subject do
+    Csv2hash.new(definition, 'file_path').tap do |csv2hash|
+      csv2hash.data_source = data_source
+    end
+  end
+
+  context 'with valid data' do
+    let(:data_source) { [ [ 'John Doe' ] ]}
+    it { expect { subject.validate_data! }.to_not raise_error }
+    context 'with header' do
+      before { subject.definition.header_size = 1 }
+      let(:data_source) { [ [ 'Name' ], [ 'John Doe' ] ]}
+      it { expect { subject.validate_data! }.to_not raise_error }
+    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
+      before { subject.definition.header_size = 1 }
+      let(:data_source) { [ [ 'Name' ], [ ] ]}
+      it { expect { subject.validate_data! }.to raise_error('undefined name on [1, 0]') }
+    end
+  end
+
+  context 'wihtout exception' do
+    let(:data_source) { [ [ ] ]}
+    before { subject.exception = false }
+    it { subject.parse.should 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 'original csv + errors should returned' do
+      let(:definition) do
+        Definition.new([ { position: 0, key: 'agree', values: ['yes', 'no'] } ], Definition::COLLECTION).tap do |d|
+          d.validate!; d.default!
+        end
+      end
+      let(:data_source) { [ [ 'what?' ], [ 'yes' ], [ 'no' ] ] }
+      it { subject.parse.should eql "what?,\"agree not supported, please use one of [\"\"yes\"\", \"\"no\"\"]\"\n" }
+    end
+  end
+
+end

data/spec/csv2hash/validator/mapping_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Validator::Mapping do
+
+  let(:definition) do
+    Definition.new([ { position: [0,0], key: 'name' } ], Definition::MAPPING).tap do |definition|
+      definition.validate!
+      definition.default!
+    end
+  end
+
+  subject do
+    Csv2hash.new(definition, 'file_path').tap do |csv2hash|
+      csv2hash.data_source = data_source
+    end
+  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 'wihtout exception' do
+    let(:data_source) { [ [ ] ]}
+    before { subject.exception = false }
+    it { subject.parse.should 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 'original csv + errors should be returned' do
+      let(:definition) do
+        Definition.new(rules, Definition::MAPPING).tap do |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'] }
+          ]
+        end
+        let(:data_source) { [ [ 'what?' ], [ 'yes', 'what?' ], [ 'yes', 'what?', 'no' ] ] }
+        it { subject.parse.should 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 }
+          ]
+        end
+        let(:data_source) { [ [ 12 ], [ 2, 12 ], [ 3, 12, 1 ] ] }
+        it { subject.parse.should eql "12,\"score not supported, please use one of 1..10\"\n" }
+      end
+    end
+  end
+end

data/spec/csv2hash/validator_spec.rb

@@ -3,36 +3,26 @@ require 'spec_helper'
 describe Validator do
 
   let(:definition) do
-    Definition.new.tap do |definition|
-      definition.type = Definition::MAPPING
-      definition.rules = [ { position: [0,0], key: 'name' } ]
+    Definition.new([ { position: [0,0], key: 'name' } ], Definition::MAPPING).tap do |definition|
       definition.validate!
       definition.default!
     end
   end
 
   subject do
-    Csv2hash.new definition, data_source
-  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]') }
+    Csv2hash.new(definition, 'file_path').tap do |csv2hash|
+      csv2hash.data_source = data_source
+    end
   end
 
   describe '#message' do
-    subject { Csv2hash.new nil, nil }
+    subject { Csv2hash.new double('definition', type: Definition::COLLECTION), nil }
 
     context 'string value' do
       let(:rule) { { foo: 'bar', message: ':foo are value of foo key' } }
 
       it 'substitue value of key' do
-        subject.send(:message, rule).should eql 'bar are value of foo key'
+        subject.send(:message, rule, nil, nil).should eql 'bar are value of foo key'
       end
     end
 
@@ -40,8 +30,17 @@ describe Validator do
       let(:rule) { { foo: ['bar', 'zone'], message: ':foo are values of foo key' } }
 
       it 'substitue value of key' do
-        subject.send(:message, rule).should eql '["bar", "zone"] are values of foo key'
+        subject.send(:message, rule, nil, nil).should eql '["bar", "zone"] are values of foo key'
+      end
+    end
+
+    context 'with position' do
+      let(:rule) { { message: 'value not found on :position' } }
+
+      it 'substitue value of key' do
+        subject.send(:message, rule, 0, 2).should eql 'value not found on [0, 2]'
       end
     end
   end
-end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csv2hash
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Joel AZEMAR
@@ -56,6 +56,7 @@ description: DSL for CSV Ruby Hash mapping
 email: joel.azemar@gmail.com
 executables:
 - load_rvm
+- publish
 extensions: []
 extra_rdoc_files: []
 files:
@@ -70,15 +71,24 @@ files:
 - README.md
 - Rakefile
 - bin/load_rvm
+- bin/publish
 - csv2hash.gemspec
 - lib/csv2hash.rb
+- lib/csv2hash/csv_array.rb
 - lib/csv2hash/definition.rb
-- lib/csv2hash/definition/mapping.rb
 - lib/csv2hash/parser.rb
+- lib/csv2hash/parser/collection.rb
+- lib/csv2hash/parser/mapping.rb
 - lib/csv2hash/validator.rb
+- lib/csv2hash/validator/collection.rb
+- lib/csv2hash/validator/mapping.rb
 - lib/csv2hash/version.rb
 - spec/csv2hash/definition_spec.rb
+- spec/csv2hash/parser/collection_spec.rb
+- spec/csv2hash/parser/mapping_spec.rb
 - spec/csv2hash/parser_spec.rb
+- spec/csv2hash/validator/collection_spec.rb
+- spec/csv2hash/validator/mapping_spec.rb
 - spec/csv2hash/validator_spec.rb
 - spec/csv2hash_spec.rb
 - spec/spec_helper.rb
@@ -108,7 +118,11 @@ specification_version: 4
 summary: Mapping CSV to Ruby Hash
 test_files:
 - spec/csv2hash/definition_spec.rb
+- spec/csv2hash/parser/collection_spec.rb
+- spec/csv2hash/parser/mapping_spec.rb
 - spec/csv2hash/parser_spec.rb
+- spec/csv2hash/validator/collection_spec.rb
+- spec/csv2hash/validator/mapping_spec.rb
 - spec/csv2hash/validator_spec.rb
 - spec/csv2hash_spec.rb
 - spec/spec_helper.rb

data/lib/csv2hash/definition/mapping.rb

@@ -1,7 +0,0 @@
-class Definition::Mapping < Definition
-
-  def validate!
-    super
-  end
-
-end