csv2hash 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 043c4be4542235e09772f8ca2249288158f7230f
-  data.tar.gz: 2eb0e8d2a0e13854f103b21b34d4a54fbb55e64f
+  metadata.gz: 12502614a6a2f8d3243b4b35152bc6dc33cc3f60
+  data.tar.gz: 235432257ee6d4e907aaa900f5090fc284fc80db
 SHA512:
-  metadata.gz: 43c070b76ca768925631f70c3e95750b5ec7edf9438e856ee58160c288f04a9c6d2215bc04c01af7a464ef80a991c1adb88797b5f4183d7c53922b1d09ca893b
-  data.tar.gz: 62050c84397a144b712a592cc9e39d28d1bec6965fdbe31d35263016cf31a4b4a35b2450538088da239583ed76a0d9ce7e8ec0c3e129176792ed39e5a6c06715
+  metadata.gz: 5f597444c037b909413309e3570374c074a18e96463c40c1c7979cd5aeec5f96f6203ade714959c4ca930341e90d4b67a39f2b3718f02c57e85cf4882b6594d5
+  data.tar.gz: e9488827e829ecdc086791c8beadc0afcf5dd868327fbf0c78a479f963d19608a50e581d6974366dacbac9fed4ce289741c8c9971098dddbf90f7e374e0f8bb2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    csv2hash (0.5.0)
+    csv2hash (0.6.0)
       activesupport (~> 4.1)
 
 GEM

data/README.md

@@ -28,6 +28,19 @@ Or install it yourself as:
 
 Parsing is based on rules, you must defined rules of parsing
 
+### DSL
+
+Csv2hash::Main.generate_definition :name do
+  set_type { Definition::MAPPING }
+  set_header_size { 2 } # 0 by default
+  set_structure_rules {{ 'MaxColumns' => 2 }}
+  mapping do
+    cell position: [0,0], key: 'gender'
+    cell position: [1,0], key: 'name'
+  end
+end
+Csv2hash::Main[:name] # Access anywhere
+
 ### Rules
 
 You should declared a definition for you CSV, and then define for each cell what you would expect.
@@ -37,31 +50,31 @@ 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:
 
 ```
-	{ 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:
 
 ```
-	{ 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'
 
 ```
-	{ 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
 
 ```
-	{ name: 'score', values: 0..5, position: [0,0] }
+	cell name: 'score', values: 0..5, position: [0,0]
 ```
 
 The message is parsed:
 
 ```
-	{ ..., 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 :
@@ -119,20 +132,21 @@ Precise position validation sample:
 		end
 
 		def data
-			@data_wrapper ||= Csv2hash::Main.new(definition, file_path_or_data).parse
+			@data_wrapper ||= Csv2hash::Main.new(Csv2hash::Main[:<definition_name>], file_path_or_data).parse
 		end
 
 		private
 
-		def rules
-			[].tap do |mapping|
-				mapping << { position: [2,1], key: 'first_name' }
-				mapping << { position: [3,1], key: 'last_name' }
-			end
-		end
-
 		def definition
-			Csv2Hash::Definition.new(rules, type = Csv2Hash::Definition::MAPPING, header_size: 1)
+      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
 
 	end
@@ -159,23 +173,28 @@ Collection validation sample:
 		end
 
 		def data
-			@data_wrapper ||= Csv2hash::Main.new(definition, file_path_or_data).parse
+			@data_wrapper ||= Csv2hash::Main.new(Csv2hash::Main[:<definition_name>], file_path_or_data).parse
 		end
 
 		private
 
-		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
 			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
+
 	end
 ```
 
@@ -194,22 +213,23 @@ Current validations are: MinColumn, MaxColumn
   	end
 
   	def data
-  		@data_wrapper ||= Csv2hash::Main.new(definition, file_path_or_data).parse
+  		@data_wrapper ||= Csv2hash::Main.new(Csv2hash::Main[:<definition_name>], file_path_or_data).parse
   	end
 
   	private
 
-  	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
-  	  Csv2Hash::Definition.new(rules, type = Csv2Hash::Definition::COLLECTION,
-        structure_rules: { 'MinColumns' => 2, 'MaxColumns' => 3 })
+      Main.generate_definition :my_defintion do
+        set_type { Definition::COLLECTION }
+        set_header_size { 1 }
+        set_structure_rules {{ 'MinColumns' => 2, 'MaxColumns' => 3 }}
+          mapping do
+            cell position: 0, key: 'nickname'
+            cell position: 1, key: 'first_name'
+            cell position: 2, key: 'last_name'
+          end
+        end
+      end
     end
   end
 ```
@@ -219,7 +239,7 @@ Current validations are: MinColumn, MaxColumn
 You can define the number of rows to skip in the header of the CSV.
 
 ```
-	Definition.new(rules, type, header_size: 0)
+	set_header_size { 1 }
 ```
 
 ### Parser and configuration
@@ -343,8 +363,8 @@ For downcase validation
 in your rule
 
 ```
-	{ 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
@@ -353,6 +373,30 @@ Csv data
 	[ [ 'Foo' ] ]
 ```
 
+# Upgrading
+
+# Upgrading from 0.5 to 0.6
+
+Introduce DSL
+
+Prior to 0.6 :
+
+```
+  rules = [{ position: [0,0], key: 'name' }]
+  Csv2hash::Definition.new(rules, Definition::MAPPING, options={})
+
+```
+
+Starting from 0.6 :
+
+```
+  Csv2hash::Main.generate_definition :foo do
+    set_type { Definition::MAPPING }
+    mapping { cell position: [0,0], key: 'name' }
+  end
+  Csv2hash::Main[:foo] # Access anywhere
+```
+
 # Upgrading from 0.4 to 0.5
 
 Signature of ```Csv2hash::Main#new``` has changed too

data/ReleaseNotes.md

@@ -1,10 +1,18 @@
+### VERSION 0.6.0
+
+* backwards incompatible changes
+  * Introduce DSL for definition
+
+* refactoring
+  * replace arguments for rules by DSL of cells
+
 ### VERSION 0.5.0
 
 * backwards incompatible changes
   * The signature of Csv2hash::Main#new has changed.
 
 * refactoring
-  * remove params ``` ignore_blank_line ``` to benefit of options of Hash 
+  * remove params ``` ignore_blank_line ``` to benefit of options of Hash
 
 ### VERSION 0.4.0
 

data/bin/launch_irb

@@ -0,0 +1 @@
+irb -r csv2hash -I ./lib

data/lib/csv2hash/adapters/base.rb

@@ -5,7 +5,6 @@ module Csv2hash
       class UnsupportedAdapter < StandardError ; end
 
       def self.create adapter_name, file_path_or_data
-        # binding.pry
         load "csv2hash/adapters/#{adapter_name}_adapter.rb"
         class_eval("Csv2hash::Adapter::#{klass_adapter(adapter_name)}").new file_path_or_data
       end

data/lib/csv2hash/cell.rb

@@ -0,0 +1,11 @@
+require 'active_support/core_ext/array/extract_options'
+
+class Cell
+
+  attr_accessor :rules
+
+  def initialize *args
+    self.rules = args.extract_options!
+  end
+
+end

data/lib/csv2hash/definition.rb

@@ -4,52 +4,81 @@ module Csv2hash
     MAPPING = 'mapping'.freeze
     COLLECTION = 'collection'.freeze
 
-    TYPES = [MAPPING, COLLECTION]
+    TYPES = [ MAPPING, COLLECTION ]
 
-    attr_accessor :rules, :type, :header_size, :structure_rules
+    attr_accessor :cells, :structure_rules, :header_size
+    attr_reader :type, :name
 
-    def initialize rules, type, options = {}
-      self.rules, self.type = rules, type
-      self.header_size, self.structure_rules = options.fetch(:header_size) { 0 }, options.fetch(:structure_rules) { {} }
+    def initialize name, &blk
+      @name = name
+      self.cells = []
+      self.header_size = 0
+      self.structure_rules = {}
+      instance_eval(&blk) if block_given?
+    end
+
+    def mapping &blk
+      instance_eval(&blk) if block_given?
+    end
+
+    def cell *args
+      self.cells << Cell.new(*args)
+    end
+
+    def set_header_size &blk
+      self.header_size = yield if block_given?
+    end
+
+    def set_type &blk
+      @type = yield if block_given?
+    end
+
+    def set_structure_rules &blk
+      self.structure_rules = yield if block_given?
     end
 
     def validate!
-      unless TYPES.include?(type)
+      # binding.pry
+      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
-      raise 'structure rules must be a Hash of rules' unless structure_rules.class == Hash
+      raise 'cells must be an Array of cell' unless self.cells.class == Array
+      raise 'structure rules must be a Hash of rules' unless self.structure_rules.class == Hash
     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'
+      # binding.pry
+      cells.each do |cell|
+        cell.rules.fetch(:position)
+
+        default_position cell
+        unless cell.rules.has_key? :message
+          if cell.rules.has_key? :values
+            cell.rules.merge! message: ':key not supported, please use one of :values'
           else
-            rule.merge! message: 'undefined :key on :position'
+            cell.rules.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
+        cell.rules.merge! mappable:    true    unless cell.rules.has_key? :mappable
+        cell.rules.merge! type:       'string' unless cell.rules.has_key? :type
+        cell.rules.merge! values:      nil     unless cell.rules.has_key? :values
+        cell.rules.merge! nested:      nil     unless cell.rules.has_key? :nested
+        cell.rules.merge! allow_blank: false   unless cell.rules.has_key? :allow_blank
+        cell.rules.merge! extra_validator: nil unless cell.rules.has_key? :extra_validator
       end
+      # binding.pry
     end
 
     private
 
-    def default_position rule
+    def default_position cell
       case type
       when MAPPING
-        y, x = rule.fetch(:position, ['undefined', 'undefined'])
-        rule.merge! key: "key_#{y}_#{x}" unless rule.has_key? :key
+        y, x = cell.rules.fetch(:position, ['undefined', 'undefined'])
+        cell.rules.merge! key: "key_#{y}_#{x}" unless cell.rules.has_key? :key
       when COLLECTION
-        x = rule.fetch :position
-        rule.merge! key: "key_undefined_#{x}" unless rule.has_key? :key
+        x = cell.rules.fetch :position
+        cell.rules.merge! key: "key_undefined_#{x}" unless cell.rules.has_key? :key
       end
     end
 

data/lib/csv2hash/expectation.rb

@@ -0,0 +1,10 @@
+module Csv2hash
+  module Expectation
+
+    def unexpected_line? line, y
+      return true if y < definition.header_size
+      return true if self.options.fetch(:ignore_blank_line){false} and line.compact.empty?
+    end
+
+  end
+end

data/lib/csv2hash/parser/collection.rb

@@ -1,31 +1,37 @@
-module Csv2hash::Parser::Collection
-  include Csv2hash::Parser
+require_relative '../expectation'
 
-  def fill!
-    self.data = {}.tap do |data_computed|
-      data_computed[:data] ||= []
-      self.data_source.each_with_index do |line, y|
-        next if y < definition.header_size
-        next if self.options.fetch(:ignore_blank_line) and line.compact.empty?
-        data_computed[:data] << {}.tap do |data_parsed|
-          fill_it data_parsed, line
+module Csv2hash
+  module Parser
+    module Collection
+      include Parser
+      include Expectation
+
+      def fill!
+        self.data = {}.tap do |data_computed|
+          data_computed[:data] ||= []
+          self.data_source.each_with_index do |line, y|
+            next if unexpected_line?(line, y)
+            data_computed[:data] << {}.tap do |data_parsed|
+              fill_it data_parsed, line
+            end
+          end
         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]
+      def fill_it parsed_data, source_data
+        definition.cells.each do |cell|
+          if cell.rules.fetch :mappable
+            x = cell.rules.fetch :position
+            if (nested = cell.rules.fetch :nested)
+              parsed_data[nested] ||= {}
+              parsed_data[nested][cell.rules.fetch(:key)] = source_data[x]
+            else
+              parsed_data[cell.rules.fetch(:key)] = source_data[x]
+            end
+          end
         end
       end
+
     end
   end
-
 end

data/lib/csv2hash/parser/mapping.rb

@@ -11,14 +11,14 @@ module Csv2hash::Parser::Mapping
   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)
+    definition.cells.each do |cell|
+      if cell.rules.fetch :mappable
+        y, x = cell.rules.fetch :position
+        if (nested = cell.rules.fetch :nested)
           parsed_data[nested] ||= {}
-          parsed_data[nested][rule.fetch(:key)] = source_data[y][x]
+          parsed_data[nested][cell.rules.fetch(:key)] = source_data[y][x]
         else
-          parsed_data[rule.fetch(:key)] = source_data[y][x]
+          parsed_data[cell.rules.fetch(:key)] = source_data[y][x]
         end
       end
     end

data/lib/csv2hash/registry.rb

@@ -0,0 +1,13 @@
+class Registry
+    def initialize
+    @definitions = Hash.new
+  end
+
+  def [] name
+    @definitions[name]
+  end
+
+  def []= name, definition
+    @definitions[name] = definition
+  end
+end

data/lib/csv2hash/structure_validator.rb

@@ -4,6 +4,7 @@ module Csv2hash::StructureValidator
   class ValidationError < StandardError ; end
 
   def validate_structure!
+    # binding.pry
     definition.structure_rules.each do |rule, options|
       begin
         rule_instance(rule, options).validate! data_source

data/lib/csv2hash/validator/collection.rb

@@ -1,18 +1,24 @@
-module Csv2hash::Validator::Collection
-  include Csv2hash::Validator
+require_relative '../expectation'
 
-  def validate_data!
-    self.data_source.each_with_index do |line, y|
-      next if y < definition.header_size
-      next if self.options.fetch(:ignore_blank_line) and line.compact.empty?
-      validate_rules y
-    end
-  end
+module Csv2hash
+  module Validator
+    module Collection
+      include Validator
+      include Expectation
 
-  protected
+      def validate_data!
+        self.data_source.each_with_index do |line, y|
+          next if unexpected_line?(line, y)
+          validate_rules y
+        end
+      end
 
-  def position _position
-    [nil, _position]
-  end
+      protected
 
+      def position _position
+        [nil, _position]
+      end
+
+    end
+  end
 end

data/lib/csv2hash/validator/mapping.rb

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

data/lib/csv2hash/validator.rb

@@ -2,12 +2,13 @@ module Csv2hash
   module Validator
 
     def validate_rules y=nil
-      definition.rules.each do |rule|
-        _y, x = position rule.fetch(:position)
+      # binding.pry
+      definition.cells.each do |cell|
+        _y, x = position cell.rules.fetch(:position)
         begin
-          validate_cell (_y||y), x, rule
+          validate_cell (_y||y), x, cell
         rescue => e
-          self.errors << { y: (_y||y), x: x, message: e.message, key: rule.fetch(:key) }
+          self.errors << { y: (_y||y), x: x, message: e.message, key: cell.rules.fetch(:key) }
           raise if break_on_failure
         end
       end
@@ -17,14 +18,14 @@ module Csv2hash
 
     protected
 
-    def validate_cell y, x, rule
+    def validate_cell y, x, cell
       value = data_source[y][x] rescue nil
       begin
-        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
+        raise unless value unless cell.rules.fetch :allow_blank
+        if (extra_validator = cell.rules.fetch :extra_validator) && extra_validator.kind_of?(Csv2hash::ExtraValidator)
+          raise unless extra_validator.valid? cell.rules, value
         else
-          if value && (values = rule.fetch :values)
+          if value && (values = cell.rules.fetch :values)
             if values.class == Range
               raise unless values.include?(value.to_f)
             else
@@ -33,13 +34,13 @@ module Csv2hash
           end
         end
       rescue => e
-        raise message(rule, y, x)
+        raise message(cell, 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 }
+    def message cell, y, x
+      msg = cell.rules.fetch(:message).tap do |msg|
+        cell.rules.each { |key, value| msg.gsub!(":#{key.to_s}", value.to_s) unless key == :position }
       end
       msg.gsub ':position', "[#{y}, #{x}]"
     end

data/lib/csv2hash/version.rb

@@ -1,3 +1,3 @@
 module Csv2hash
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/csv2hash.rb

@@ -1,4 +1,6 @@
 require_relative 'csv2hash/version'
+require_relative 'csv2hash/registry'
+require_relative 'csv2hash/cell'
 require_relative 'csv2hash/definition'
 require_relative 'csv2hash/validator'
 require_relative 'csv2hash/validator/mapping'
@@ -26,6 +28,24 @@ module Csv2hash
   class Main
     include Csv2hash::StructureValidator
 
+    class << self
+
+      def generate_definition name, &block
+        definition = Definition.new name, &block
+        Main[name] = definition
+      end
+
+      def [] definition_name
+        @@registry[definition_name]
+      end
+
+      def []= definition_name, role
+        @@registry[definition_name] = role
+      end
+    end
+
+    @@registry = Registry.new
+
     attr_accessor :definition, :file_path_or_data, :data, :notifier, :break_on_failure, :errors, :options
 
     def initialize definition, file_path_or_data, *args