csv2hash 0.0.2 → 0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4d2f7ba34ef01f65b28e952dcc72dc479ed2891
-  data.tar.gz: 77bfe0698393fedb815d54f631d8e6e7af05f401
+  metadata.gz: a139a39be73ed85cce068c4b1b34c564a7c5a7a7
+  data.tar.gz: 26ad3fe5d1ce458dfcd8dd4269d519f419f79592
 SHA512:
-  metadata.gz: d246e42bd2202619bc8e4ad3ca581c9c5b3fa15be34bcee30817d31030b782d33d1f1e2d89cf95df17059c21e63c185bc4a682ec9a08fbc5c1242f18ed0e8800
-  data.tar.gz: b863db362851632a77e7a157d5a112f67e0e8d3c6ae31dd7a2d610fdc92defb1c59f720656a84e54f2ac207b79b2e695924e91925c99dbc808322cb4c2ceb101
+  metadata.gz: 9270e2cf190351a68be08114049fb16392769da65b3fb8eb03206f699a898bf8a99e21d3cf6f6fd28196dfbd3197cb9f0918f3563205d2c1b0d1ddf3064a6b5c
+  data.tar.gz: 55f28e1b266ca939c901d47d61bb6bd58b91d25506e764da2bab3ae62b9022ff190f630b29cb199a7a09f33714d367b7506e51c9d3a5c696095d5b58073de82c

data/.coveralls.yml

@@ -1,2 +1 @@
-service_name: travis-pro
 repo_token: N3Ql9kjuVUDMaof2gKqn1TiNXt4bYfRUw

data/Gemfile.lock

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

data/README.md

@@ -9,7 +9,7 @@
 [![Coverage Status](https://coveralls.io/repos/joel/csv2hash/badge.png)](https://coveralls.io/r/joel/csv2hash)
 
 
-It's DSL for valided and map CSV to Ruby Hash
+It is a DSL to validate and map a CSV to a Ruby Hash.
 
 ## Installation
 
@@ -27,21 +27,23 @@ Or install it yourself as:
 
 ## Usage
 
-#### Rules
+Parsing is based on rules, you must defined rules of parsing
 
-You should be declare an definition for you CSV, for each cells you should define what you expect.
+### Rules
+
+You should declare a definition for you CSV, and then define for each cell what you would expect.
 
 Example :
 
-You want first cell parsed should be string with values are 'yes' or 'no' you must fill follow rule :
+You want the cell located on first line, first column to be a string with its values to be 'yes' or 'no'. Then you can right the following validation rule :
 
 	{ name: 'aswering', type: 'string', values: ['yes', 'no'], position: [0,0] }
 
-All keys as default values, so you can just define this rule :
+The type is 'string' by default, so can just write:
 
 	{ name: 'aswering', values: ['yes', 'no'], position: [0,0] }
 
-You can define message, default is 'undefined :key on :position'
+You can define a message, default is 'undefined :key on :position'
 
 	{ name: 'aswering', values: ['yes', 'no'], position: [0,0], message: 'this value is not supported' }
 
@@ -49,37 +51,52 @@ You can also define Range
 
 	{ name: 'score', values: 0..5, position: [0,0] }
 
-if you insert key on you message they will be substituted
+The message is parsed:
 
 	{ ..., message: 'value of :name is not supported, please you one of :values' }
 
-produce :
-
+It produces :
 
 	value of aswering is not supported, please you one of [yes, no]
 
-##### Position
+### Default values
+
+Only position is required:
+
+* :position
+
+All remaining keys are optionals:
+
+* message:     'undefined :key on :position'
+* mappable:    true
+* type:        'string'
+* values:      nil
+* nested:      nil
+* allow_blank: false
+* extra_validator: nil
 
-Position mean [Y, X], where Y is rows, X columns
+## Define where your data is expected
 
-#### Definition
+**IMPORTANT!** Position mean [Y, X], where Y is rows, X columns
 
-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
+A definition should be provided. There are 2 types of definitions:
+* search for data at a precise position in the table: `y,x`
+* or search for data in a column of rows, where all the rows are the same: `x` (column index)
 
-### Sample
+## Samples
 
-#### Mapping
+### Validation of a cell at a precise position
 
-Consider csv data like that
+Consider the following CSV:
 
 | Fields      | Person Informations  | Optional |
 |-------------|----------------------|----------|
-| Nickname    |        john          |    no    |
+| Nickname    |        jo            |    no    |
 | First Name  |        John          |    yes   |
 | Last Name   |        Doe           |    yes   |
 
 
-Mapping sample definition
+Precise position validation sample:
 
 	class MyParser
 
@@ -89,6 +106,12 @@ Mapping sample definition
 			@file_path = file_path
 		end
 
+		def data
+			@data_wrapper ||= Csv2hash.new(definition, file_path).parse
+		end
+
+		private
+
 		def rules
 			[].tap do |mapping|
 				mapping << { position: [2,1], key: 'first_name' }
@@ -97,27 +120,21 @@ Mapping sample definition
 		end
 
 		def definition
-			Definition.new(rules, type = Definition::MAPPING)
-		end
-
-		def data
-			Csv2hash.new(definition, file_path).tap do |csv2hash|
-				csv2hash.parse
-			end.data
+			Csv2Hash::Definition.new(rules, type = Csv2Hash::Definition::MAPPING, 1)
 		end
 
 	end
 
-#### Collection
+### Validation of a collection
 
-Consider csv data like that
+Consider the following CSV:
 
 | Nickname | First Name | Last Name |
 |----------|------------|-----------|
-|   john   |    John    |    Doe    |
-|   jane   |    Jane    |    Doe    |
+|   jo     |    John    |    Doe    |
+|   ja     |    Jane    |    Doe    |
 
-Mapping sample definition
+Collection validation sample:
 
 	class MyParser
 
@@ -127,6 +144,12 @@ Mapping sample definition
 			@file_path = file_path
 		end
 
+		def data
+			@data_wrapper ||= Csv2hash.new(definition, file_path).parse
+		end
+
+		private
+
 		def rules
 			[].tap do |mapping|
 				mapping << { position: 0, key: 'nickname'   }
@@ -136,60 +159,125 @@ Mapping sample definition
 		end
 
 		def definition
-			Definition.new(rules, type = Definition::COLLECTION)
-		end
-
-		def data
-			Csv2hash.new(definition, file_path).tap do |csv2hash|
-				csv2hash.parse
-			end.data
+			Csv2Hash::Definition.new(rules, type = Csv2Hash::Definition::MAPPING, 1)
 		end
 
 	end
 
-#### Headers
+### CSV Headers
 
-You should be define header size
+You can define the number of rows to skip in the header of the CSV.
 
 	Definition.new(rules, type, header_size=0)
 
-#### Exception or CSV mode
+### Parser and configuration
 
-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.
+Pasrer take severale parameters like that :
 
+	initialize definition, file_path, exception_mode=true, data_source=nil, ignore_blank_line=false
 
-parse return data or csv_with_errors if parse is invalid, you can plug this like that :
+you can pass directly Array of data (Array at 2 dimensions) really useful for testing, if you don't care about line blank in your CSV you can ignore them.
 
-	csv2hash = Csv2hash.new(definition, 'file_path').new
-	result = csv2hash.parse
-	return result if csv2hash.valid?
+### Response
 
-	filename = 'issues_errors.csv'
-	tempfile = Tempfile.new [filename, File.extname(filename)]
-	File.open(tempfile.path, 'wb') { |file| file.write result }
+The parser return values wrapper into DataWrapper Object, you can call .valid? method on this Object and grab either data or errors like that :
 
-	# Send mail with csv file + errors and free resource
+    response = parser.parse
+    if response.valid?
+	    response.data
+    else
+	    response.errors
+    end
 
-	tempfile.unlink
+data or errors are Array, but errors can be formatted on csv format with .to_csv call
 
+	response.errors.to_csv
 
-#### Default values
+## Exception or Not !
 
-only position is require
+You can choice 2 modes 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.
 
-* :position
+### On **CSV MODE** you can choose different way for manage errors
 
-all remaind keys are optionals
+`.parse()` return `data_wrapper` if `.parse()` is invalid, you can code your own behavior like that :
+
+in your code
+
+	parser = Csv2hash.new(definition, 'file_path').new
+	response = parser.parse
+	return response if response.valid?
+	# Whatever
+
+In the same time Csv2hash call **notify(response)** method when CSV parsing fail, you can add your own Notifier like that
+
+	module Csv2hash
+		module Plugins
+			class Notifier
+				def initialize csv2hash
+					csv2hash.notifier.extend NotifierWithEmail
+				end
+
+				module NotifierWithEmail
+					def notify response
+						filename = 'issues_errors.csv'
+						tempfile = Tempfile.new [filename, File.extname(filename)]
+						File.open(tempfile.path, 'wb') { |file| file.write response.errors.to_csv }
+						# Send mail with csv file + errors and free resource
+						tempfile.unlink
+					end
+				end
+			end
+		end
+	end
+
+Or other implementation
+
+### Errors Format
+
+errors is a Array of Hash
+
+	{ y: 1, x: 0, message: 'message', key: 'key', value: '' }
+
+## Sample
+
+### Csv data
+
+| Fields      | Person Informations  |
+|-------------|----------------------|
+| Nickname    |        nil           |
+
+### Rule
+
+	{ position: [1,1], key: 'nickname', allow_blank: false }
+
+### Error
+
+	{ y: 1, x: 1, message: 'undefined nikcname on [0, 0]', key: 'nickname', value: nil }
+## Personal Validator Rule
+
+You can define your own Validator
+
+For downcase validation
+
+	class DowncaseValidator < Csv2hash::ExtraValidator
+		def valid? value
+			!!(value.match /^[a-z]+$/)
+		end
+	end
+
+in your rule
+
+	{ position: [0,0], key: 'name', extra_validator: DowncaseValidator.new,
+		message: 'your data should be writting in downcase only' }
+
+Csv data
+
+	[ [ 'Foo' ] ]
 
-* message:     'undefined :key on :position'
-* mappable:    true
-* type:        'string'
-* values:      nil
-* nested:      nil
-* allow_blank: false
 
 ### Limitations
 
+* Don't manage number of column you expected on collection mode
 
 ## Contributing
 
@@ -197,4 +285,4 @@ all remaind keys are optionals
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+5. Create new Pull Request

data/ReleaseNotes.md

@@ -0,0 +1,16 @@
+VERSION 0.1
+
+* Add csv errors mode
+* Add Extra Validator
+* Add Notifier Plugin
+* Add Data Wrapper Response
+* Add possibility to pass directly data in constructor, for more testing
+* You can ignore blank line
+
+VERSION 0.0.2
+
+* Liitle enhancement
+
+VERSION 0.0.1
+
+* Skeleton and first parsing

data/bin/publish

@@ -15,7 +15,7 @@ class Publish
 
 end
 
-if ARGV.length != 1 or !ARGV[0].match(/\d{1,3}.\d{1,3}.\d{1,3}/)
+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

data/csv2hash.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |spec|
 
   spec.name        = 'csv2hash'
-  spec.version     = '0.0.2'
+  spec.version     = '0.1'
   spec.date        = '2013-11-26'
-  spec.summary     = %q{Mapping CSV to Ruby Hash}
-  spec.description = %q{DSL for CSV Ruby Hash mapping}
+  spec.summary     = %q{Mapping a CSV to a Ruby Hash}
+  spec.description = %q{DSL to map a CSV to a Ruby Hash}
   spec.authors     = ['Joel AZEMAR']
   spec.email       = 'joel.azemar@gmail.com'
   spec.files       = ['lib/csv2hash.rb']
@@ -21,4 +21,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec'
 
   spec.required_ruby_version = '~> 2.0'
-end
+end

data/lib/csv2hash/csv_array.rb

@@ -4,7 +4,7 @@ class CsvArray < Array
   def to_csv options = {}
     CSV.generate(options) do |csv|
       self.each do |element|
-        csv << element
+        csv << [element[:value], element[:message]]
       end
     end
   end

data/lib/csv2hash/data_wrapper.rb

@@ -0,0 +1,13 @@
+class Csv2hash
+  class DataWrapper
+
+    attr_accessor :data, :errors, :valid
+
+    def initialize
+      self.valid = true
+      self.data, self.errors = [], []
+    end
+
+    def valid?() valid ; end
+  end
+end

data/lib/csv2hash/definition.rb

@@ -1,52 +1,55 @@
-class Definition
+class Csv2hash
+  class Definition
 
-  MAPPING = 'mapping'
-  COLLECTION = 'collection'
+    MAPPING = 'mapping'
+    COLLECTION = 'collection'
 
-  TYPES = [Definition::MAPPING, Definition::COLLECTION]
+    TYPES = [MAPPING, COLLECTION]
 
-  attr_accessor :rules, :type, :header_size
+    attr_accessor :rules, :type, :header_size
 
-  def initialize rules, type, header_size=0
-    @rules, @type, @header_size = rules, type, header_size
-  end
+    def initialize rules, type, header_size=0
+      self.rules, self.type, self.header_size = rules, type, header_size
+    end
 
-  def validate!
-    unless TYPES.include?(type)
-      raise "not suitable type, please use '#{Definition::MAPPING}' or '#{Definition::COLLECTION}'"
+    def validate!
+      unless TYPES.include?(type)
+        raise "not suitable type, please use '#{MAPPING}' or '#{COLLECTION}'"
+      end
+      raise 'rules must be an Array of rules' unless rules.class == Array
     end
-    raise 'rules must be an Array of rules' unless rules.class == Array
-  end
 
-  def default!
-    rules.each do |rule|
-      default_position rule
-      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'
+    def default!
+      rules.each do |rule|
+        default_position rule
+        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! extra_validator: nil unless rule.has_key? :extra_validator
       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
     end
-  end
 
-  private
+    private
 
-  def default_position rule
-    case type
-    when Definition::MAPPING
-      y, x = rule.fetch(:position, ['undefined', 'undefined'])
-      rule.merge! key: "key_#{y}_#{x}" unless rule.has_key? :key
-    when Definition::COLLECTION
-      x = rule.fetch :position
-      rule.merge! key: "key_undefined_#{x}" unless rule.has_key? :key
+    def default_position rule
+      case type
+      when MAPPING
+        y, x = rule.fetch(:position, ['undefined', 'undefined'])
+        rule.merge! key: "key_#{y}_#{x}" unless rule.has_key? :key
+      when COLLECTION
+        x = rule.fetch :position
+        rule.merge! key: "key_undefined_#{x}" unless rule.has_key? :key
+      end
     end
-  end
 
-end
+  end
+end

data/lib/csv2hash/extra_validator.rb

@@ -0,0 +1,5 @@
+class Csv2hash
+  class ExtraValidator
+    def valid?(rule, value) raise 'method parse!() should be implemented in sub class'; end
+  end
+end

data/lib/csv2hash/notifier.rb

@@ -0,0 +1,7 @@
+class Csv2hash
+  class Notifier
+    def notify response
+      # puts 'Csv with errors'
+    end
+  end
+end

data/lib/csv2hash/parser/collection.rb

@@ -1,10 +1,12 @@
-module Parser::Collection extend Parser
+module Csv2hash::Parser::Collection
+  include Csv2hash::Parser
 
   def fill!
-    @data = {}.tap do |data_computed|
+    self.data = {}.tap do |data_computed|
       data_computed[:data] ||= []
-      @data_source.each_with_index do |line, y|
+      self.data_source.each_with_index do |line, y|
         next if y < definition.header_size
+        next if self.ignore_blank_line and line.compact.empty?
         data_computed[:data] << {}.tap do |data_parsed|
           fill_it data_parsed, line
         end
@@ -26,4 +28,4 @@ module Parser::Collection extend Parser
     end
   end
 
-end
+end

data/lib/csv2hash/parser/mapping.rb

@@ -1,7 +1,8 @@
-module Parser::Mapping extend Parser
+module Csv2hash::Parser::Mapping
+  include Csv2hash::Parser
 
   def fill!
-    @data = {}.tap do |data_computed|
+    self.data = {}.tap do |data_computed|
       data_computed[:data] ||= []
       data_computed[:data] << {}.tap do |data_parsed|
         fill_it data_parsed, data_source
@@ -23,4 +24,4 @@ module Parser::Mapping extend Parser
     end
   end
 
-end
+end

data/lib/csv2hash/parser.rb

@@ -1,2 +1,4 @@
-module Parser
-end
+class Csv2hash
+  module Parser
+  end
+end

data/lib/csv2hash/validator/collection.rb

@@ -1,9 +1,10 @@
-module Validator::Collection
-  include Validator
+module Csv2hash::Validator::Collection
+  include Csv2hash::Validator
 
   def validate_data!
-    @data_source.each_with_index do |line, y|
+    self.data_source.each_with_index do |line, y|
       next if y < definition.header_size
+      next if self.ignore_blank_line and line.compact.empty?
       validate_rules y
     end
   end
@@ -14,4 +15,4 @@ module Validator::Collection
     [nil, _position]
   end
 
-end
+end

data/lib/csv2hash/validator/mapping.rb

@@ -1,5 +1,5 @@
-module Validator::Mapping
-  include Validator
+module Csv2hash::Validator::Mapping
+  include Csv2hash::Validator
 
   def validate_data!
     validate_rules data_source
@@ -11,4 +11,4 @@ module Validator::Mapping
     _position
   end
 
-end
+end

data/lib/csv2hash/validator.rb

@@ -1,42 +1,44 @@
-module Validator
+class Csv2hash
+  module Validator
+
+    def validate_rules y=nil
+      definition.rules.each do |rule|
+        _y, x = position rule.fetch(:position)
+        begin
+          validate_cell (_y||y), x, rule
+        rescue => e
+          self.errors << { y: (_y||y), x: x, message: e.message, key: rule.fetch(:key) }
+          raise if exception_mode
+        end
+      end
+    end
+
+    def valid?() self.errors.empty?; end
 
-  attr_accessor :errors, :exception
+    protected
 
-  def validate_rules y=nil
-    definition.rules.each do |rule|
-      _y, x = position rule.fetch(:position)
+    def validate_cell y, x, rule
+      value = data_source[y][x] rescue nil
       begin
-        validate_cell (_y||y), x, rule
+        raise unless value unless rule.fetch :allow_blank
+        if (extra_validator = rule.fetch :extra_validator) && extra_validator.kind_of?(Csv2hash::ExtraValidator)
+          raise unless extra_validator.valid? rule, value
+        else
+          if value && (values = rule.fetch :values)
+            raise unless values.include?(value)
+          end
+        end
       rescue => e
-        errors << { y: (_y||y), x: x, message: e.message, key: rule.fetch(:key) }
-        raise if exception
+        raise message(rule, y, x)
       end
     end
-  end
-
-  def valid?() errors.empty?; end
-
-  protected
 
-  def validate_cell y, x, rule
-
-    value = data_source[y][x] rescue nil
-
-    begin
-      raise unless value unless rule.fetch :allow_blank
-      if value && (values = rule.fetch :values)
-        raise unless values.include?(value)
+    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
-    rescue => e
-      raise message(rule, y, x)
+      msg.gsub ':position', "[#{y}, #{x}]"
     end
-  end
 
-  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
+end

data/lib/csv2hash/version.rb

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

data/lib/csv2hash.rb

@@ -7,29 +7,52 @@ require 'csv2hash/parser'
 require 'csv2hash/parser/mapping'
 require 'csv2hash/parser/collection'
 require 'csv2hash/csv_array'
+require 'csv2hash/data_wrapper'
+require 'csv2hash/notifier'
+require 'csv2hash/extra_validator'
+
 require 'csv'
 
 class Csv2hash
 
-  attr_accessor :definition, :file_path, :data, :data_source
+  attr_accessor :definition, :file_path, :data, :notifier, :exception_mode, :errors, :ignore_blank_line
+
+  def initialize definition, file_path, exception_mode=true, data_source=nil, ignore_blank_line=false
+    @data_source = data_source
+    self.definition, self.file_path = definition, file_path
+    dynamic_lib_loading 'Parser'
+    self.exception_mode, self.errors = exception_mode, []
+    dynamic_lib_loading 'Validator'
+    self.notifier = Notifier.new
+    self.ignore_blank_line = ignore_blank_line
+    init_plugins
+  end
 
-  def initialize definition, file_path, exception=true
-    @definition, @file_path = definition, file_path
-    dynamic_parser_loading
-    @exception, @errors = exception, []
-    dynamic_validator_loading
+  def init_plugins
+    begin
+      @plugins = []
+      ::Csv2hash::Plugins.constants.each do |name|
+        @plugins << ::Csv2hash::Plugins.const_get(name).new(self)
+      end
+    rescue; end
   end
 
   def parse
     load_data_source
+
     definition.validate!
     definition.default!
     validate_data!
-    if valid?
-      fill!
-      data
-    else
-      csv_with_errors
+
+    Csv2hash::DataWrapper.new.tap do |response|
+      if valid?
+        fill!
+        response.data = data[:data]
+      else
+        response.valid = false
+        response.errors = csv_with_errors
+        notifier.notify response
+      end
     end
   end
 
@@ -37,36 +60,27 @@ class Csv2hash
     @csv_with_errors ||= begin
       CsvArray.new.tap do |rows|
         errors.each do |error|
-          rows << (([data_source[error[:x]][error[:y]]]||[nil]) + [error[:message]])
+          rows << error.merge({ value: (data_source[error[:y]][error[:x]] rescue nil) })
         end
-      end.to_csv
+      end #.to_csv
     end
   end
 
   # protected
 
   def data_source
-    @data_source ||= CSV.read @file_path
+    @data_source ||= CSV.read self.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
+  def dynamic_lib_loading type
     case definition.type
-    when Definition::MAPPING
-      self.extend Parser::Mapping
-    when Definition::COLLECTION
-      self.extend Parser::Collection
+    when Csv2hash::Definition::MAPPING
+      self.extend Module.module_eval("Csv2hash::#{type}::Mapping")
+    when Csv2hash::Definition::COLLECTION
+      self.extend Module.module_eval("Csv2hash::#{type}::Collection")
     end
   end
 

data/spec/csv2hash/definition_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe Definition do
+describe Csv2hash::Definition do
 
   context 'regular context' do
     subject do
-      Definition.new(
+      Csv2hash::Definition.new(
         [ { position: [0,0], key: 'name' } ],
-        Definition::MAPPING
+        Csv2hash::Definition::MAPPING
       )
     end
 
     it 'variable should be assigned' do
-      subject.type.should eql Definition::MAPPING
+      subject.type.should eql Csv2hash::Definition::MAPPING
       subject.rules.should eql [ { position: [0,0], key: 'name' } ]
     end
   end
@@ -19,17 +19,18 @@ describe Definition do
   describe '#validate!' do
     context 'rules failling validation' do
       subject do
-        Definition.new nil, 'unsuitable_type'
+        Csv2hash::Definition.new nil, 'unsuitable_type'
       end
       it 'should throw exception' do
         expect {
           subject.validate!
-        }.to raise_error "not suitable type, please use '#{Definition::MAPPING}' or '#{Definition::COLLECTION}'"
+        }.to raise_error("not suitable type, please use '#{Csv2hash::Definition::MAPPING}' " \
+          "or '#{Csv2hash::Definition::COLLECTION}'")
       end
     end
     context 'rules failling validation' do
       subject do
-        Definition.new 'rules',Definition::MAPPING
+        Csv2hash::Definition.new 'rules',Csv2hash::Definition::MAPPING
       end
       it 'should throw exception' do
         expect { subject.validate! }.to raise_error 'rules must be an Array of rules'
@@ -39,7 +40,7 @@ describe Definition do
 
   describe '#default!' do
     subject do
-      Definition.new [ { position: [0,0], key: 'name' } ], Definition::MAPPING
+      Csv2hash::Definition.new [ { position: [0,0], key: 'name' } ], Csv2hash::Definition::MAPPING
     end
 
     before { subject.default! }
@@ -52,7 +53,8 @@ describe Definition do
         type: 'string',
         values: nil,
         nested: nil,
-        allow_blank: false }])
+        allow_blank: false,
+        extra_validator: nil }])
     end
   end
 end

data/spec/csv2hash/parser/collection_spec.rb

@@ -1,29 +1,27 @@
 require 'spec_helper'
 
-describe Parser::Collection do
+describe Csv2hash::Parser::Collection do
 
   let(:definition) do
-    Definition.new [ { position: 0, key: 'name' } ], Definition::COLLECTION
+    Csv2hash::Definition.new [ { position: 0, key: 'name' } ], Csv2hash::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
+    Csv2hash.new(definition, 'file_path', false, data_source)
   end
 
   context 'regular way' do
     it { expect { subject.parse }.to_not raise_error }
     it {
-      subject.tap do |csv2hash|
-        csv2hash.parse
+      subject.tap do |parser|
+        parser.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' ] ]}
+      let(:data_source) { [ [ 'Name' ], [ 'John Doe' ], [ 'Jane Doe' ] ] }
       it {
         subject.tap { |c| c.parse }.data.should eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
       }
@@ -46,4 +44,13 @@ describe Parser::Collection do
     }
   end
 
+  context '#ignore_blank_line' do
+    let(:data_source) { [ [ 'John Doe' ], [ 'Jane Doe' ], [ nil ] ] }
+    it {
+      subject.tap do |parser|
+        parser.ignore_blank_line = true
+        parser.parse
+      end.data.should eql({ data: [ { 'name' => 'John Doe' }, { 'name' => 'Jane Doe' } ] })
+    }
+  end
 end

data/spec/csv2hash/parser/mapping_spec.rb

@@ -1,17 +1,15 @@
 require 'spec_helper'
 
-describe Parser::Mapping do
+describe Csv2hash::Parser::Mapping do
 
   let(:definition) do
-    Definition.new [ { position: [0,0], key: 'name' } ], Definition::MAPPING
+    Csv2hash::Definition.new [ { position: [0,0], key: 'name' } ], Csv2hash::Definition::MAPPING
   end
 
   let(:data_source) { [ [ 'John Doe' ] ] }
 
   subject do
-    Csv2hash.new(definition, 'file_path').tap do |csv2hash|
-      csv2hash.data_source = data_source
-    end
+    Csv2hash.new(definition, 'file_path', false, data_source)
   end
 
   context 'regular way' do

data/spec/csv2hash/parser_spec.rb

@@ -1,3 +1,3 @@
 require 'spec_helper'
 
-describe Parser
+describe Csv2hash::Parser

data/spec/csv2hash/validator/collection_spec.rb

@@ -1,18 +1,16 @@
 require 'spec_helper'
 
-describe Validator::Collection do
+describe Csv2hash::Validator::Collection do
 
   let(:definition) do
-    Definition.new([ { position: 0, key: 'name' } ], Definition::COLLECTION).tap do |definition|
+    Csv2hash::Definition.new([ { position: 0, key: 'name' } ], Csv2hash::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
+    Csv2hash.new(definition, 'file_path', true, data_source)
   end
 
   context 'with valid data' do
@@ -25,8 +23,18 @@ describe Validator::Collection do
     end
   end
 
+  context '#ignore_blank_line' do
+    let(:data_source) { [ [ ] ] }
+    before { subject.ignore_blank_line = true }
+    it { expect { subject.validate_data! }.to_not raise_error }
+    context 'csv mode' do
+      before { subject.exception_mode = false }
+      its(:errors) { should be_empty }
+    end
+  end
+
   context 'with invalid data' do
-    let(:data_source) { [ [ ] ]}
+    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 }
@@ -37,8 +45,8 @@ describe Validator::Collection do
 
   context 'wihtout exception' do
     let(:data_source) { [ [ ] ]}
-    before { subject.exception = false }
-    it { subject.parse.should eql ",\"undefined name on [0, 0]\"\n" }
+    before { subject.exception_mode = false }
+    it { subject.parse.errors.to_csv.should eql ",\"undefined name on [0, 0]\"\n" }
 
     context 'errors should be filled' do
       before { subject.parse }
@@ -47,13 +55,14 @@ describe Validator::Collection do
 
     context 'original csv + errors should returned' do
       let(:definition) do
-        Definition.new([ { position: 0, key: 'agree', values: ['yes', 'no'] } ], Definition::COLLECTION).tap do |d|
+        Csv2hash::Definition.new(
+          [{ position: 0, key: 'agree', values: ['yes', 'no'] }], Csv2hash::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" }
+      it { subject.parse.errors.to_csv.should eql "what?,\"agree not supported, please use one of [\"\"yes\"\", \"\"no\"\"]\"\n" }
     end
   end
 
-end
+end

data/spec/csv2hash/validator/mapping_spec.rb

@@ -1,18 +1,16 @@
 require 'spec_helper'
 
-describe Validator::Mapping do
+describe Csv2hash::Validator::Mapping do
 
   let(:definition) do
-    Definition.new([ { position: [0,0], key: 'name' } ], Definition::MAPPING).tap do |definition|
+    Csv2hash::Definition.new([ { position: [0,0], key: 'name' } ], Csv2hash::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
+    Csv2hash.new(definition, 'file_path', true, data_source)
   end
 
   context 'with valid data' do
@@ -26,9 +24,9 @@ describe Validator::Mapping do
   end
 
   context 'wihtout exception' do
-    let(:data_source) { [ [ ] ]}
-    before { subject.exception = false }
-    it { subject.parse.should eql ",\"undefined name on [0, 0]\"\n" }
+    let(:data_source) { [ [ ] ] }
+    before { subject.exception_mode = false }
+    it { subject.parse.errors.to_csv.should eql ",\"undefined name on [0, 0]\"\n" }
 
     context 'errors should be filled' do
       before { subject.parse }
@@ -37,7 +35,7 @@ describe Validator::Mapping do
 
     context 'original csv + errors should be returned' do
       let(:definition) do
-        Definition.new(rules, Definition::MAPPING).tap do |d|
+        Csv2hash::Definition.new(rules, Csv2hash::Definition::MAPPING).tap do |d|
           d.validate!; d.default!
         end
       end
@@ -50,7 +48,8 @@ describe Validator::Mapping do
           ]
         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" }
+        it { subject.parse.errors.to_csv.should eql(
+          "what?,\"agree not supported, please use one of [\"\"yes\"\", \"\"no\"\"]\"\n") }
       end
       context 'range values' do
         let(:rules) do
@@ -61,8 +60,37 @@ describe Validator::Mapping do
           ]
         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" }
+        it { subject.parse.errors.to_csv.should 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!
+        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
+end
+
+class DowncaseValidator < Csv2hash::ExtraValidator
+  def valid? rule, value
+    !!(value.match /^[a-z]+$/)
+  end
+end
+

data/spec/csv2hash/validator_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
-describe Validator do
+describe Csv2hash::Validator do
 
   let(:definition) do
-    Definition.new([ { position: [0,0], key: 'name' } ], Definition::MAPPING).tap do |definition|
+    Csv2hash::Definition.new([ { position: [0,0], key: 'name' } ], Csv2hash::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
+    Csv2hash.new(definition, 'file_path').tap do |parser|
+      parser.instance_variable_set :@data_source, data_source
     end
   end
 
   describe '#message' do
-    subject { Csv2hash.new double('definition', type: Definition::COLLECTION), nil }
+    subject { Csv2hash.new double('definition', type: Csv2hash::Definition::COLLECTION), nil }
 
     context 'string value' do
       let(:rule) { { foo: 'bar', message: ':foo are value of foo key' } }
@@ -43,4 +43,4 @@ describe Validator do
     end
   end
 
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csv2hash
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: '0.1'
 platform: ruby
 authors:
 - Joel AZEMAR
@@ -52,7 +52,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: DSL for CSV Ruby Hash mapping
+description: DSL to map a CSV to a Ruby Hash
 email: joel.azemar@gmail.com
 executables:
 - load_rvm
@@ -70,12 +70,16 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- ReleaseNotes.md
 - bin/load_rvm
 - bin/publish
 - csv2hash.gemspec
 - lib/csv2hash.rb
 - lib/csv2hash/csv_array.rb
+- lib/csv2hash/data_wrapper.rb
 - lib/csv2hash/definition.rb
+- lib/csv2hash/extra_validator.rb
+- lib/csv2hash/notifier.rb
 - lib/csv2hash/parser.rb
 - lib/csv2hash/parser/collection.rb
 - lib/csv2hash/parser/mapping.rb
@@ -115,7 +119,7 @@ rubyforge_project:
 rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
-summary: Mapping CSV to Ruby Hash
+summary: Mapping a CSV to a Ruby Hash
 test_files:
 - spec/csv2hash/definition_spec.rb
 - spec/csv2hash/parser/collection_spec.rb