csv2hash 0.6.6 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18bc8763e096c34ff6118e37ef9fd2247762e91d
-  data.tar.gz: 50318a57def57128858b83ccf06ec75a1d62c106
+  metadata.gz: 332e1760a8872c909fea63cc52a8701580ab1c50
+  data.tar.gz: 5c40139eef7283dbb3505b2557c539a4a9fb16c0
 SHA512:
-  metadata.gz: eac65e74ebc8aea9a5ab683ef76c50eff563eec50cd7d07e37d8f9136d10c439f2f242a3d8c44bb1acaf1e42d9461d00851d4123601a514f251e4c4fd0292ea8
-  data.tar.gz: e260dd7c94939ebc9acd6e311abb6140afbc3206807f7d4d7272d1feebb48077e77d81cb7654bab52edc859a01d0683133ad32ff6a2af12a55def72478475772
+  metadata.gz: d468a06d1114d8b16f283ea2f06ce08774cfa769eb761e4bb8c6a1f2f78431461c59f31d2ab4c79900ab500546c7c2666bc11a9ea0597ad8550a76c31bf01e8e
+  data.tar.gz: c6e8e3297d875cd2fda25ae025282df0a233170c3543c3d110280e30c8e4d7aedda4e0008941a258473aa5bc844547383b171169205b691ee65008f685a6a1fd

data/CHANGELOG.md

@@ -1,9 +1,19 @@
+### VERSION 0.6.7
+
+* enhancements
+  * initializer can be take block or value
+
+* refactoring
+  * following rails way for naming file
+  
+* [fullchanges](https://github.com/FinalCAD/csv2hash/pull/17)
+
 ### VERSION 0.6.6
 
 * refactoring
   * little trick on YamlLoader
 
-* [fullchanges](https://github.com/FinalCAD/csv2hash/pull/17)
+* [fullchanges](https://github.com/FinalCAD/csv2hash/commit/a4b3fb5b6cdb3ed41b039f68391b30054fab3668)
 
 ### VERSION 0.6.5
 

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    csv2hash (0.6.6)
+    csv2hash (0.6.7)
       activesupport (~> 4.1)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (4.1.5)
+    activesupport (4.1.6)
       i18n (~> 0.6, >= 0.6.9)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -44,18 +44,18 @@ GEM
     rest-client (1.7.2)
       mime-types (>= 1.16, < 3.0)
       netrc (~> 0.7)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.4)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.4)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.4)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.4)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.0)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.0)
     simplecov (0.9.0)
       docile (~> 1.1.0)
       multi_json

data/README.md

@@ -31,16 +31,16 @@ Parsing is based on rules, you should defined rule for each cells
 ### DSL
 
 ```
-  Csv2hash::Main.generate_definition :name do
-    set_type { Definition::MAPPING }
-    set_header_size { 2 } # 0 by default
-    set_structure_rules {{ max_columns: 2 }}
-    mapping do
-      cell position: [0,0], key: 'gender'
-      cell position: [1,0], key: 'name'
-    end
+Csv2hash::Main.generate_definition :name do
+  set_type { Definition::MAPPING }
+  set_header_size { 2 } # 0 by default
+  set_structure_rules {{ max_columns: 2 }}
+  mapping do
+    cell position: [0,0], key: 'gender'
+    cell position: [1,0], key: 'name'
   end
-  Csv2hash::Main[:name] # Access anywhere
+end
+Csv2hash::Main[:name] # Access anywhere
 ```
 
 ### Rules
@@ -52,37 +52,37 @@ Example :
 If you want the very first cell, located on the first line and on the first column to be a string with values are either 'yes' either 'no', you can write the following validation rule:
 
 ```
-	cell name: 'aswering', type: 'string', values: ['yes', 'no'], position: [0,0]
+cell name: 'aswering', type: 'string', values: ['yes', 'no'], position: [0,0]
 ```
 
 `:type` attribute has `String` for default value, therefore you can just write this:
 
 ```
-	cell name: 'aswering', values: ['yes', 'no'], position: [0,0]
+cell name: 'aswering', values: ['yes', 'no'], position: [0,0]
 ```
 
 You can define you own message but default message is 'undefined :key on :position'
 
 ```
-	cell name: 'aswering', values: ['yes', 'no'], position: [0,0], message: 'this value is not supported'
+cell name: 'aswering', values: ['yes', 'no'], position: [0,0], message: 'this value is not supported'
 ```
 
 You can also define Range of values
 
 ```
-	cell name: 'score', values: 0..5, position: [0,0]
+cell name: 'score', values: 0..5, position: [0,0]
 ```
 
 The message is parsed:
 
 ```
-	cell ..., message: 'value of :name is not supported, please you one of :values'
+cell ..., message: 'value of :name is not supported, please you one of :values'
 ```
 
 It produces :
 
 ```
-	value of answering is not supported, please use one of [yes, no]
+value of answering is not supported, please use one of [yes, no]
 ```
 
 ### Default values
@@ -109,6 +109,24 @@ 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)
 
+## Invoke
+
+```
+Csv2hash::Main.new(:<definition_name>, file_path_or_data, options).parse
+```
+
+```
+Csv2hash::Main.new(:<definition_name>, options) do
+  file_path_or_data
+end.parse
+```
+
+### Options
+
+List of options :
+
+* ignore_blank_line: :boolean # i think is pretty straightforward to understand
+
 ## Samples
 
 ### [MAPPING] Validation of cells with defined precision
@@ -126,33 +144,31 @@ Consider the following CSV:
 Precise position validation sample:
 
 ```
-	class MyParser
+class MyParser
 
-		attr_accessor :file_path_or_data
+	attr_accessor :file_path_or_data
 
-		def initialize file_path_or_data
-			@file_path_or_data = file_path_or_data
-		end
+	def initialize file_path_or_data
+		@file_path_or_data = file_path_or_data
+	end
 
-		def data
-			@data_wrapper ||= Csv2hash::Main.new(:<definition_name>, file_path_or_data).parse
-		end
+	def data
+		@data_wrapper ||= Csv2hash::Main.new(:<definition_name>, file_path_or_data).parse
+	end
 
-		private
-
-		def definition
-	      Main.generate_definition :my_defintion do
-	        set_type { Definition::MAPPING }
-	        set_header_size { 1 }
-	          mapping do
-	            cell position: [2,1], key: 'first_name'
-	            cell position: [3,1], key: 'last_name'
-	          end
-	        end
-	      end
-		end
+	private
 
+	def definition
+    Main.generate_definition :my_defintion do
+      set_type { Definition::MAPPING }
+      set_header_size { 1 }
+      mapping do
+        cell position: [2,1], key: 'first_name'
+        cell position: [3,1], key: 'last_name'
+      end
+    end
 	end
+end
 ```
 
 ### Auto discover position
@@ -177,14 +193,14 @@ You want extract `Employment` information and `Personal info` but we do not know
 
 You must change Y position (rows) by the column index and regex, the parser will search on this column the index row of this regex, here our rule :
 
-```  
-  cell position: [4,1], key: 'employment'
+```
+cell position: [4,1], key: 'employment'
 ```
 
 became
 
 ```
-  cell position: [[0, /Employment/],1], key: 'employment'
+cell position: [[0, /Employment/],1], key: 'employment'
 ```
 
 ### [COLLECTION] Validation of a collection (Regular CSV)
@@ -201,38 +217,36 @@ Consider the following CSV:
 Collection validation sample:
 
 ```
-	class MyParser
-
-		attr_accessor :file_path_or_data
+class MyParser
 
-		def initialize file_path_or_data
-			@file_path_or_data = file_path_or_data
-		end
-
-		def data
-			@data_wrapper ||= Csv2hash::Main.new(:<definition_name>, file_path_or_data).parse
-		end
+	attr_accessor :file_path_or_data
 
-		private
+	def initialize file_path_or_data
+		@file_path_or_data = file_path_or_data
+	end
 
-		def definition
-			Csv2Hash::Definition.new(rules, type = Csv2Hash::Definition::COLLECTION, header_size: 1)
-		end
+	def data
+		@data_wrapper ||= Csv2hash::Main.new(:<definition_name>, file_path_or_data).parse
+	end
 
-	    def definition
-	      Main.generate_definition :my_defintion do
-	        set_type { Definition::COLLECTION }
-	        set_header_size { 1 }
-	          mapping do
-	            cell position: 0, key: 'nickname'
-	            cell position: 1, key: 'first_name'
-	            cell position: 2, key: 'last_name'
-	          end
-	        end
-	      end
-	    end
+	private
 
+	def definition
+		Csv2Hash::Definition.new(rules, type = Csv2Hash::Definition::COLLECTION, header_size: 1)
 	end
+
+  def definition
+    Main.generate_definition :my_defintion do
+      set_type { Definition::COLLECTION }
+      set_header_size { 1 }
+      mapping do
+        cell position: 0, key: 'nickname'
+        cell position: 1, key: 'first_name'
+        cell position: 2, key: 'last_name'
+      end
+    end
+  end
+end
 ```
 
 ### Structure validation rules
@@ -241,34 +255,33 @@ You may want to validate some structure, like min or max number of columns, defi
 Current validations are: :min_columns, :max_columns
 
 ```
-  class MyParser
+class MyParser
 
-  	attr_accessor :file_path_or_data
+	attr_accessor :file_path_or_data
 
-  	def initialize file_path_or_data
-  		@file_path_or_data = file_path_or_data
-  	end
-
-  	def data
-  		@data_wrapper ||= Csv2hash::Main.new(:<definition_name>, file_path_or_data).parse
-  	end
+	def initialize file_path_or_data
+		@file_path_or_data = file_path_or_data
+	end
 
-  	private
+	def data
+		@data_wrapper ||= Csv2hash::Main.new(:<definition_name>, file_path_or_data).parse
+	end
 
-    def definition
-      Main.generate_definition :my_defintion do
-        set_type { Definition::COLLECTION }
-        set_header_size { 1 }
-        set_structure_rules {{ min_columns: 2, max_columns: 3 }}
-          mapping do
-            cell position: 0, key: 'nickname'
-            cell position: 1, key: 'first_name'
-            cell position: 2, key: 'last_name'
-          end
-        end
+	private
+
+  def definition
+    Main.generate_definition :my_defintion do
+      set_type { Definition::COLLECTION }
+      set_header_size { 1 }
+      set_structure_rules {{ min_columns: 2, max_columns: 3 }}
+      mapping do
+        cell position: 0, key: 'nickname'
+        cell position: 1, key: 'first_name'
+        cell position: 2, key: 'last_name'
       end
     end
   end
+end
 ```
 
 ### CSV Headers
@@ -276,7 +289,7 @@ Current validations are: :min_columns, :max_columns
 You can define the number of rows to skip in the header of the CSV.
 
 ```
-	set_header_size { 1 }
+set_header_size { 1 }
 ```
 
 ### Parser and configuration
@@ -284,7 +297,7 @@ You can define the number of rows to skip in the header of the CSV.
 Pasrer can take several parameters like that:
 
 ```
-	definition, file_path_or_data, ignore_blank_line: false
+definition, file_path_or_data, ignore_blank_line: false
 ```
 
 in `file_path_or_data` attribute you can pass directly an `Array` of data (`Array` with 2 dimensions) really useful for testing, if you don't care about blank lines in your CSV you can ignore them.
@@ -294,18 +307,18 @@ in `file_path_or_data` attribute you can pass directly an `Array` of data (`Arra
 The parser return values wrapper into `DataWrapper Object`, you can call ```.valid?``` method on this Object and grab either data or errors like that :
 
 ```
-    response = parser.parse
-    if response.valid?
-	    response.data
-    else
-		response.errors
-    end
+response = parser.parse
+if response.valid?
+  response.data
+else
+  response.errors
+end
 ```
 
 data or errors are Array, but errors can be formatted on csv format with .to_csv call
 
 ```
-	response.errors.to_csv
+response.errors.to_csv
 ```
 
 ## Exception or Not !
@@ -323,34 +336,34 @@ You need call `.parse()` return `data_wrapper` if `.parse()` is invalid, you can
 in your code
 
 ```
-	parser = Csv2hash::Main.new(definition, file_path_or_data, ignore_blank_line: false).new
-	response = parser.parse
-	return response if response.valid?
-	# Whatever
+parser = Csv2hash::Main.new(definition, file_path_or_data, ignore_blank_line: false).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:
 
 ```
-	module Csv2hash
-		module Plugins
-			class Notifier
-				def initialize csv2hash
-					csv2hash.notifier.extend NotifierWithEmail
-				end
+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
+			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
@@ -360,7 +373,7 @@ Or other implementation
 errors is a Array of Hash
 
 ```
-	{ y: 1, x: 0, message: 'message', key: 'key', value: '' }
+{ y: 1, x: 0, message: 'message', key: 'key', value: '' }
 ```
 
 ## Sample
@@ -376,13 +389,13 @@ errors is a Array of Hash
 ### Rule
 
 ```
-	cell position: [1,1], key: 'nickname', allow_blank: false
+cell position: [1,1], key: 'nickname', allow_blank: false
 ```
 
 ### Error
 
 ```
-	{ y: 1, x: 1, message: 'undefined nikcname on [0, 0]', key: 'nickname', value: nil }
+{ y: 1, x: 1, message: 'undefined nikcname on [0, 0]', key: 'nickname', value: nil }
 ```
 
 ## Personal Validator Rule
@@ -392,24 +405,24 @@ You can define your own Validator
 For downcase validation
 
 ```
-	class DowncaseValidator < Csv2hash::ExtraValidator
-		def valid? value
-			!!(value.match /^[a-z]+$/)
-		end
+class DowncaseValidator < Csv2hash::ExtraValidator
+	def valid? value
+		!!(value.match /^[a-z]+$/)
 	end
+end
 ```
 
 in your rule
 
 ```
-	cell position: [0,0], key: 'name', extra_validator: DowncaseValidator.new,
-		message: 'your data should be written in lowercase only.'
+cell position: [0,0], key: 'name', extra_validator: DowncaseValidator.new,
+	message: 'your data should be written in lowercase only.'
 ```
 
 Csv data
 
 ```
-	[ [ 'Foo' ] ]
+[ [ 'Foo' ] ]
 ```
 
 # Config file
@@ -468,19 +481,19 @@ position: [[0,'LastName'],1]
 
 this change is due to Yaml conversion
 
-You can write ERB file, should be named with following convention ```<file name>.erb.yml```
+You can write ERB file, should be named with following convention ```<file name>.yml.erb```
 
 ## YamlLoader
 
 You can load your definition with YamlLoader llike that :
 
 ```
-loader = Csv2hash::YamlLoader.load!('config/rules.erb.yml')
+loader = Csv2hash::YamlLoader.load!('config/rules.yml.erb')
 loader.definition
 ```
 or
 ```
-loader = Csv2hash::YamlLoader.new('config/rules.erb.yml')
+loader = Csv2hash::YamlLoader.new('config/rules.yml.erb')
 loader.load!
 loader.definition
 ```

data/UPGRADE.md

@@ -1,5 +1,9 @@
 # Upgrading
 
+# Upgrading from 0.6.6 to 0.6.7
+
+nothing
+
 # Upgrading from 0.6.5 to 0.6.6
 
 nothing

data/lib/csv2hash/validator.rb

@@ -25,16 +25,13 @@ module Csv2hash
     def validate_cell y, x, cell
       value = data_source[y][x] rescue nil
       begin
-        raise unless value unless cell.rules.fetch :allow_blank
-        if (extra_validator = cell.rules.fetch :extra_validator) && extra_validator.kind_of?(ExtraValidator)
-          raise unless extra_validator.valid? cell.rules, value
+        verify_blank! cell, value
+        if extra_validator?(cell)
+          verify_extra_validator! cell, value
         else
-          if value && (values = cell.rules.fetch :values)
-            if values.class == Range
-              raise unless values.include?(value.to_f)
-            else
-              raise unless values.include?(value)
-            end
+          if rang? cell, value
+            values = cell.rules.fetch(:values)
+            verify_rang! values, value
           end
         end
       rescue => e
@@ -54,27 +51,50 @@ module Csv2hash
 
     private
 
+    def extra_validator? cell
+      (extra_validator = cell.rules.fetch(:extra_validator)) && extra_validator.kind_of?(ExtraValidator)
+    end
+
+    def verify_extra_validator! cell, value
+      raise unless cell.rules.fetch(:extra_validator).valid? cell.rules, value
+    end
+
+    def verify_blank! cell, value
+      raise unless value unless cell.rules.fetch :allow_blank
+    end
+
+    def rang? cell, value
+      value && (values = cell.rules.fetch(:values))
+    end
+
+    def verify_rang! values, value
+      if values.class == Range
+        raise unless values.include?(value.to_f)
+      else
+        raise unless values.include?(value)
+      end
+    end
+
     def find_or_remove_dynamic_fields!
       cells = definition.cells.dup
-      _cells = []
-
-      while(!cells.empty?) do
-        cell = cells.pop
-        _y, x = cell.rules.fetch(:position)
-        if dynamic_field?(_y)
-          begin
-            _cell = find_dynamic_position cell
-            _cells << _cell if _cell
-          rescue => e
-            self.errors << { y: (_y||y), x: x, message: e.message, key: cell.rules.fetch(:key) }
-            raise if break_on_failure
+      # cells without optional and not found dynamic field
+      definition.cells = [].tap do |_cells|
+        while(!cells.empty?) do
+          cell = cells.pop
+          _y, x = cell.rules.fetch(:position)
+          if dynamic_field?(_y)
+            begin
+              _cell = find_dynamic_position cell
+              _cells << _cell
+            rescue => e
+              self.errors << { y: (_y||y), x: x, message: e.message, key: cell.rules.fetch(:key) }
+              raise if break_on_failure
+            end
+          else
+            _cells << cell
           end
-        else
-          _cells << cell
         end
-      end
-
-      definition.cells = _cells # cells without optional and not found dynamic field
+      end.compact
       nil
     end
 

data/lib/csv2hash/version.rb

@@ -1,3 +1,3 @@
 module Csv2hash
-  VERSION = '0.6.6'
+  VERSION = '0.6.7'
 end

data/lib/csv2hash/yaml_loader.rb

@@ -38,7 +38,7 @@ module Csv2hash
     private
 
     def load_config_file file
-      if file.to_s =~ /(?<ext>\.erb\.)/
+      if file.to_s =~ /(?<ext>\.erb)/
         YAML.load(ERB.new(File.read(file)).result)
       else
         YAML.load_file(file)

data/lib/csv2hash.rb

@@ -70,10 +70,16 @@ module Csv2hash
 
     attr_accessor :definition, :file_path_or_data, :data, :notifier, :break_on_failure, :errors, :options
 
-    def initialize definition_file_or_symbol, file_path_or_data, *args
-      self.options           = args.extract_options!
+    def initialize *args
+      self.options = args.extract_options!
+      definition_file_or_symbol, file_path_or_data = args
+
+      unless block_given? ^ file_path_or_data
+        raise ArgumentError, 'Either value or block must be given, but not both'
+      end
+
+      self.file_path_or_data = file_path_or_data || yield
       self.definition        = load_definition(definition_file_or_symbol)
-      self.file_path_or_data = file_path_or_data
       self.break_on_failure  = false
       self.errors            = []
       self.notifier          = Notifier.new

data/spec/csv2hash/structure_validator_spec.rb

@@ -10,7 +10,9 @@ module Csv2hash
     end
 
     subject do
-      Main.new(definition, data_source, ignore_blank_line: false)
+      Main.new(definition, ignore_blank_line: false) do
+        data_source
+      end
     end
 
     context 'the csv with errors' do

data/spec/csv2hash/yaml_loader_spec.rb

@@ -6,7 +6,7 @@ module Csv2hash
     before  { subject.load! }
 
     context 'yml' do
-      let(:config_file) { 'config/rules.erb.yml' }
+      let(:config_file) { 'config/rules.yml.erb' }
 
       specify do
         expect(subject.definition.name).to eql('example')
@@ -25,7 +25,7 @@ module Csv2hash
     end
 
     context 'extra validator' do
-      let(:config_file) { 'config/rules.extra_validator.erb.yml' }
+      let(:config_file) { 'config/rules.extra_validator.yml.erb' }
 
       specify do
         expect(subject.definition.name).to eql('example')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csv2hash
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.6.7
 platform: ruby
 authors:
 - Joel AZEMAR
@@ -108,9 +108,9 @@ files:
 - bin/launch_irb
 - bin/load_rvm
 - config/example.csv
-- config/rules.erb.yml
-- config/rules.extra_validator.erb.yml
+- config/rules.extra_validator.yml.erb
 - config/rules.yml
+- config/rules.yml.erb
 - coverage/.resultset.json.lock
 - csv2hash.gemspec
 - lib/csv2hash.rb