csv_row_model 1.0.0.beta1 → 1.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 620b2a84648e1723419994992518ecd9e77609d3
-  data.tar.gz: 5b331bc69fb075b9ca84bf53db592c0e6db15dde
+  metadata.gz: b9eb25b87297dafc35c155017125d709b0606449
+  data.tar.gz: ba28f582a1319e2217350a6ad910ef7fa427c386
 SHA512:
-  metadata.gz: 5e10d1f2a7fd7115e632fadee715a852d9aa05bf5f1d69d04c79fc1503d598118bb75dfbb1707af4cf5afa6692c2338bd1d1e93125b39d1175445f34197dacad
-  data.tar.gz: 78994103e5eab1c176f5a2e9c7306073071a7da9adfc94344393e16cdd32fff6023c3f1e8e018b2f6ed8178f2720bbfc7149abba232a3b4414393ae6bc6bb8cf
+  metadata.gz: 52392629db0ded13d4dc3ede022c1f98520d21aa59ee10dca1f98e9011118597b04b424fd1354dd7d79470b8f0c809292494bf4e447611c321cb69955e804c44
+  data.tar.gz: 6b8d3f701bc4005dc8508cc64ee601255c50d587b81fa80ccc0579a57db88d3eb18589e95b65802375ffedaf80e940f22b78625028d6ebda1b649007aa9f693c

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
---color
+--color
+--order rand

data/README.md

@@ -50,10 +50,10 @@ end
 import_file = CsvRowModel::Import::File.new(file_path, ProjectImportRowModel)
 row_model = import_file.next
 
-row_model.header # => ["id", "name"]
+row_model.headers # => ["id", "name"]
 
 row_model.source_row # => ["1", "Some Project Name"]
-row_model.mapped_row # => { id: "1", name: "Some Project Name" }, this is `source_row` mapped to `column_names`
+row_model.source_attributes # => { id: "1", name: "Some Project Name" }, this is `source_row` mapped to `column_names`
 row_model.attributes # => { id: "1", name: "Some Project Name" }, this is final attribute values mapped to `column_names`
 
 row_model.id # => 1
@@ -123,7 +123,7 @@ To generate a attribute value, the following pseudocode is executed:
 ```ruby
 def original_attribute(column_name)
   # 1. Get the raw CSV string value for the column
-  value = mapped_row[column_name]
+  value = source_attributes[column_name]
 
   # 2. Clean or format each cell
   value = self.class.format_cell(cell, column_name, column_index, context)
@@ -280,6 +280,18 @@ import_file.each { |project_import_model| puts "does not yield here" }
 import_file.next # does not skip or abort
 ```
 
+### File Validations
+You can also have file validations, while will make the entire import process abort. Currently, there is one provided validation.
+
+```ruby
+class ImportFile < CsvRowModel::Import::File
+  validate :headers_invalid_row # checks if header is valid CSV syntax
+  validate :headers_count # calls #headers_invalid_row, then check the count. will ignore tailing empty headers
+end
+```
+
+Can't be used for [Dynamic Columns](#dynamic-columns) or [File Model](#file-model)s.
+
 ### Import Callbacks
 `CsvRowModel::Import::File` can be subclassed to access
 [`ActiveModel::Callbacks`](http://api.rubyonrails.org/classes/ActiveModel/Callbacks.html).
@@ -350,7 +362,7 @@ row_model.valid? # => false
 row_model.errors.full_messages # => ["Id must be greater than 0"]
 ```
 
-Note that `CsvStringModel` validations are calculated after [Format Cell](#format-cell).
+Note that `CsvStringModel` validations are calculated after [Format Attribute](#format-cell).
 
 ### Represents
 A CSV is often a representation of database model(s), much like how JSON parameters represents models in requests.
@@ -429,7 +441,7 @@ row_model = import_file.next
 row_model.projects # => [<ProjectImportRowModel>, ...]
 ```
 
-## Dynamic columns
+## Dynamic Columns
 Dynamic columns are columns that can expand to many columns. Currently, we can only one dynamic column after all other standard columns.
 The following:
 
@@ -440,7 +452,7 @@ class DynamicColumnModel
   column :first_name
   column :last_name
   # header is optional, below is the default_implementation
-  dynamic_column :skills, header: ->(skill_name) { skill_name }
+  dynamic_column :skills, header: ->(skill_name) { skill_name }, header_models_context_key: :skills
 end
 ```
 
@@ -453,7 +465,7 @@ represents this table:
 | Mike       | Jackson    |   Yes  |   Yes  |
 
 
-The `format_dynamic_column_header(header_model, column_name, dynamic_column_index, index_of_column, context)` can
+The `format_dynamic_column_header(header_model, column_name, dynamic_column_index, context)` can
 be used to defined like `format_header`. Defined in both import and export due to headers being used for both.
 
 ### Export
@@ -470,7 +482,8 @@ class DynamicColumnExportModel < DynamicColumnModel
   end
 end
 
-# the `skills` context is mapped to generate an array
+# `skills` in the context is used as the header, which is used in `def skill(skill_name)` above
+# to change this context key, use the :header_models_context_key option
 export_file = CsvRowModel::Export::File.new(DynamicColumnExportModel, { skills: Skill.all  })
 export_file.generate do |csv|
   User.all.each { |user| csv << user }
@@ -504,7 +517,7 @@ row_model.attributes # => { first_name: "John", last_name: "Doe", skills: ['No',
 row_model.skills # => ['No', 'Yes']
 ```
 
-## File Model (Mapping)
+## File Model
 
 If you have to deal with a mapping on a csv you can use FileModel, isn't complete a this time and many cases isn't covered but can be helpful
 

data/lib/csv_row_model/concerns/attributes_base.rb

@@ -0,0 +1,86 @@
+require 'csv_row_model/concerns/model/attributes'
+require 'csv_row_model/concerns/hidden_module'
+
+# Shared between Import and Export, see test fixture for basic setup
+module CsvRowModel
+  module AttributesBase
+    extend ActiveSupport::Concern
+    include Model::Attributes
+    include HiddenModule
+
+    # @return [Hash] a map of `column_name => public_send(column_name)`
+    def attributes
+      attributes_from_method_names self.class.column_names
+    end
+
+    # Export:
+    # source_value - row_model.column1 --> source_model.column1
+    # formatted_value - format_cell(source_value)
+    # vale - formatted_value
+    #
+    # Import:
+    # source_value - form source_row
+    # formatted_value - format_cell(source_value)
+    # value - calculated_value from a bunch of stuff
+    ATTRIBUTE_METHODS = {
+      original_attributes: :value, # a map of `column_name => original_attribute(column_name)`
+      formatted_attributes: :formatted_value, # a map of `column_name => format_cell(column_name, ...)`
+      source_attributes: :source_value # a map of `column_name => source (source_row[index_of_column_name] or row_model.public_send(column_name)) `
+    }.freeze
+    ATTRIBUTE_METHODS.each do |method_name, attribute_method|
+      define_method(method_name) do
+        column_names_to_attribute_value(self.class.column_names, attribute_method)
+      end
+    end
+
+    # @return [Object] the column's attribute (the csv_row_model default value to be used for import/export)
+    def original_attribute(column_name)
+      attribute_objects[column_name].try(:value)
+    end
+
+    def to_json
+      attributes.to_json
+    end
+
+    def eql?(other)
+      other.try(:attributes) == attributes
+    end
+
+    def hash
+      attributes.hash
+    end
+
+    protected
+    def attributes_from_method_names(column_names)
+      array_to_block_hash(column_names) { |column_name| try(column_name) }
+    end
+
+    def column_names_to_attribute_value(column_names, attribute_method)
+      array_to_block_hash(column_names) { |column_name| attribute_objects[column_name].public_send(attribute_method)}
+    end
+
+    def array_to_block_hash(array, &block)
+      array.zip(array.map(&block)).to_h
+    end
+
+    class_methods do
+      protected
+      # See {Model#column}
+      def column(column_name, options={})
+        super
+        define_attribute_method(column_name)
+      end
+
+      # Define default attribute method for a column
+      # @param column_name [Symbol] the cell's column_name
+      def define_attribute_method(column_name, &block)
+        return if method_defined? column_name
+        define_proxy_method(column_name, &block)
+      end
+
+      def ensure_attribute_method
+        self.column_names.each { |*args| define_attribute_method(*args) }
+      end
+    end
+  end
+end

data/lib/csv_row_model/concerns/check_options.rb

@@ -1,14 +1,12 @@
 module CsvRowModel
-  module Concerns
-    module CheckOptions
-      extend ActiveSupport::Concern
+  module CheckOptions
+    extend ActiveSupport::Concern
 
-      class_methods do
-        def check_options(options)
-          invalid_options = options.keys - self::VALID_OPTIONS
-          raise ArgumentError.new("Invalid option(s): #{invalid_options}") if invalid_options.present?
-          true
-        end
+    class_methods do
+      def check_options(options)
+        invalid_options = options.keys - self::VALID_OPTIONS
+        raise ArgumentError.new("Invalid option(s): #{invalid_options}") if invalid_options.present?
+        true
       end
     end
   end

data/lib/csv_row_model/concerns/dynamic_columns_base.rb

@@ -0,0 +1,47 @@
+require 'csv_row_model/concerns/model/dynamic_columns'
+
+# Shared between Import and Export, see test fixture for basic setup
+module CsvRowModel
+  module DynamicColumnsBase
+    extend ActiveSupport::Concern
+    include Model::DynamicColumns
+
+    def attribute_objects
+      @attribute_objects ||= super.merge(dynamic_column_attribute_objects)
+    end
+
+    def attributes
+      super.merge!(attributes_from_method_names(self.class.dynamic_column_names))
+    end
+
+    ATTRIBUTE_METHODS = {
+      original_attributes: :value, # a map of `column_name => original_attribute(column_name)`
+      formatted_attributes: :formatted_cells, # a map of `column_name => format_cell(column_name, ...)`
+    }.freeze
+    ATTRIBUTE_METHODS.each do |method_name, attribute_method|
+      define_method(method_name) do
+        super().merge! column_names_to_attribute_value(self.class.dynamic_column_names, attribute_method)
+      end
+    end
+
+    class_methods do
+      protected
+      # See {Model::DynamicColumns#dynamic_column}
+      def dynamic_column(column_name, options={})
+        super
+        define_dynamic_attribute_method(column_name)
+      end
+
+      # Define default attribute method for a dynamic_column
+      # @param column_name [Symbol] the cell's column_name
+      def define_dynamic_attribute_method(column_name)
+        define_proxy_method(column_name) { original_attribute(column_name) }
+        dynamic_attribute_class.define_process_cell(self, column_name)
+      end
+
+      def ensure_define_dynamic_attribute_method
+        dynamic_column_names.each { |*args| define_dynamic_attribute_method(*args) }
+      end
+    end
+  end
+end

data/lib/csv_row_model/concerns/export/attributes.rb

@@ -0,0 +1,26 @@
+require 'csv_row_model/concerns/attributes_base'
+require 'csv_row_model/internal/export/attribute'
+
+module CsvRowModel
+  module Export
+    module Attributes
+      extend ActiveSupport::Concern
+      include AttributesBase
+
+      included do
+        ensure_attribute_method
+      end
+
+      def attribute_objects
+        @attribute_objects ||= array_to_block_hash(self.class.column_names) { |column_name| Attribute.new(column_name, self) }
+      end
+
+      class_methods do
+        protected
+        def define_attribute_method(column_name)
+          super { source_model.public_send(column_name) }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/{export → concerns/export}/base.rb

@@ -21,7 +21,7 @@ module CsvRowModel
 
       # @return [Array] an array of public_send(column_name) of the CSV model
       def to_row
-        formatted_attributes.values
+        original_attributes.values
       end
 
       class_methods do

data/lib/csv_row_model/concerns/export/dynamic_columns.rb

@@ -0,0 +1,33 @@
+require 'csv_row_model/concerns/dynamic_columns_base'
+require 'csv_row_model/concerns/export/attributes'
+require 'csv_row_model/internal/export/dynamic_column_attribute'
+
+module CsvRowModel
+  module Export
+    module DynamicColumns
+      extend ActiveSupport::Concern
+      include DynamicColumnsBase
+
+      included do
+        ensure_define_dynamic_attribute_method
+      end
+
+      def dynamic_column_attribute_objects
+        @dynamic_column_attribute_objects ||= array_to_block_hash(self.class.dynamic_column_names) do |column_name|
+          self.class.dynamic_attribute_class.new(column_name, self)
+        end
+      end
+
+      # @return [Array] an array of public_send(column_name) of the CSV model
+      def to_row
+        super.flatten
+      end
+
+      class_methods do
+        def dynamic_attribute_class
+          DynamicColumnAttribute
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/concerns/hidden_module.rb

@@ -0,0 +1,15 @@
+module CsvRowModel
+  module HiddenModule
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def hidden_module
+        @hidden_module ||= Module.new.tap { |mod| include mod }
+      end
+
+      def define_proxy_method(*args, &block)
+        hidden_module.send(:define_method, *args, &block)
+      end
+    end
+  end
+end

data/lib/csv_row_model/concerns/import/attributes.rb

@@ -0,0 +1,52 @@
+require 'csv_row_model/concerns/attributes_base'
+require 'csv_row_model/concerns/import/csv_string_model'
+require 'csv_row_model/internal/import/attribute'
+
+module CsvRowModel
+  module Import
+    module Attributes
+      extend ActiveSupport::Concern
+      include AttributesBase
+      include CsvStringModel
+
+      included do
+        ensure_attribute_method
+      end
+
+      def attribute_objects
+        @attribute_objects ||= begin
+          csv_string_model.valid?
+          _attribute_objects(csv_string_model.errors)
+        end
+      end
+
+      # return [Hash] a map changes from {.column}'s default option': `column_name -> [value_before_default, default_set]`
+      def default_changes
+        column_names_to_attribute_value(self.class.column_names, :default_change).delete_if {|k, v| v.blank? }
+      end
+
+      protected
+      # to prevent circular dependency with csv_string_model
+      def _attribute_objects(csv_string_model_errors={})
+        index = -1
+        array_to_block_hash(self.class.column_names) do |column_name|
+          Attribute.new(column_name, source_row[index += 1], csv_string_model_errors[column_name], self)
+        end
+      end
+
+      class_methods do
+        protected
+        def merge_options(column_name, options={})
+          original_options = columns[column_name]
+          csv_string_model_class.add_type_validation(column_name, columns[column_name]) unless original_options[:validate_type]
+          super
+        end
+
+        def define_attribute_method(column_name)
+          return if super { original_attribute(column_name) }.nil?
+          csv_string_model_class.add_type_validation(column_name, columns[column_name])
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/{import → concerns/import}/base.rb

@@ -1,19 +1,22 @@
+require 'csv_row_model/concerns/inspect'
+
 module CsvRowModel
   module Import
     module Base
       extend ActiveSupport::Concern
+      include Inspect
+      INSPECT_METHODS = %i[source_attributes initialized_at parent context previous].freeze
 
       included do
-        attr_reader :source_header, :source_row, :line_number, :index, :previous
-
-        validate { errors.add(:csv, "has #{@csv_exception.message}") if @csv_exception }
+        attr_reader :source_headers, :source_row, :line_number, :index, :previous
+        validate { errors.add(:csv, "has #{@csv_exception.message}") if @csv_exception  }
       end
 
       # @param [Array] source_row_or_exception the csv row
       # @param options [Hash]
       # @option options [Integer] :index 1st row_model is 0, 2nd is 1, 3rd is 2, etc.
       # @option options [Integer] :line_number line_number in the CSV file
-      # @option options [Array] :source_header the csv header row
+      # @option options [Array] :source_headers the csv header row
       # @option options [CsvRowModel::Import] :previous the previous row model
       # @option options [CsvRowModel::Import] :parent if the instance is a child, pass the parent
       def initialize(source_row_or_exception=[], options={})
@@ -21,19 +24,13 @@ module CsvRowModel
         @csv_exception = source_row if source_row.kind_of? Exception
         @source_row = [] if source_row_or_exception.class != Array
 
-        @line_number, @index, @source_header = options[:line_number], options[:index], options[:source_header]
+        @line_number, @index, @source_headers = options[:line_number], options[:index], options[:source_headers]
 
         @previous = options[:previous].try(:dup)
         previous.try(:free_previous)
         super(options)
       end
 
-      # @return [Hash] a map of `column_name => source_row[index_of_column_name]`
-      def mapped_row
-        return {} unless source_row
-        @mapped_row ||= self.class.column_names.zip(source_row).to_h
-      end
-
       # Free `previous` from memory to avoid making a linked list
       def free_previous
         attributes
@@ -64,7 +61,7 @@ module CsvRowModel
         # @return [Import] the next model instance from the csv
         def next(file, context={})
           csv = file.csv
-          csv.skip_header
+          csv.skip_headers
           row_model = nil
 
           loop do # loop until the next parent or end_of_file? (need to read children rows)
@@ -72,7 +69,7 @@ module CsvRowModel
             row_model ||= new(csv.current_row,
                               line_number: csv.line_number,
                               index: file.index,
-                              source_header: csv.header,
+                              source_headers: csv.headers,
                               context: context,
                               previous: file.previous_row_model)
 
@@ -82,11 +79,6 @@ module CsvRowModel
             return row_model if next_row_is_parent
           end
         end
-
-        protected
-        def inspect_methods
-          @inspect_methods ||= %i[mapped_row initialized_at parent context previous].freeze
-        end
       end
     end
   end

data/lib/csv_row_model/{import → concerns/import}/csv_string_model.rb

@@ -13,12 +13,11 @@ module CsvRowModel
         end
       end
 
-      # @return [Import::CsvStringModel::Model] a model with validations related to csv_string_model (values are from format_cell)
       # @return [Import::CsvStringModel::Model] a model with validations related to csv_string_model (values are from format_cell)
       def csv_string_model
         @csv_string_model ||= begin
-          cell_objects = _cell_objects
-          formatted_hash = array_to_block_hash(self.class.column_names) { |column_name| cell_objects[column_name].formatted_value }
+          attribute_objects = _attribute_objects
+          formatted_hash = array_to_block_hash(self.class.column_names) { |column_name| attribute_objects[column_name].formatted_value }
           self.class.csv_string_model_class.new(formatted_hash)
         end
       end

data/lib/csv_row_model/concerns/import/dynamic_columns.rb

@@ -0,0 +1,50 @@
+require 'csv_row_model/concerns/dynamic_columns_base'
+require 'csv_row_model/internal/import/dynamic_column_attribute'
+
+module CsvRowModel
+  module Import
+    module DynamicColumns
+      extend ActiveSupport::Concern
+      include DynamicColumnsBase
+
+      included do
+        ensure_define_dynamic_attribute_method
+      end
+
+      def dynamic_column_attribute_objects
+        @dynamic_column_attribute_objects ||= array_to_block_hash(self.class.dynamic_column_names) do |column_name|
+          self.class.dynamic_attribute_class.new(column_name, dynamic_column_source_headers, dynamic_column_source_cells, self)
+        end
+      end
+
+      # @return [Array] an array of format_dynamic_column_header(...)
+      def formatted_dynamic_column_headers
+        dynamic_column_attribute_objects.values.first.try(:formatted_headers) || []
+      end
+
+      # @return [Array] dynamic_column headers
+      def dynamic_column_source_headers
+        self.class.dynamic_column_source_headers source_headers
+      end
+
+      # @return [Array] dynamic_column row data
+      def dynamic_column_source_cells
+        self.class.dynamic_column_source_cells source_row
+      end
+
+      class_methods do
+        def dynamic_column_source_headers(source_headers)
+          dynamic_columns? ? source_headers[columns.size..-1] : []
+        end
+
+        def dynamic_column_source_cells(source_row)
+          dynamic_columns? ? source_row[columns.size..-1] : []
+        end
+
+        def dynamic_attribute_class
+          DynamicColumnAttribute
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/{import → concerns/import}/represents.rb

@@ -1,4 +1,4 @@
-require 'csv_row_model/import/representation'
+require 'csv_row_model/internal/import/representation'
 
 module CsvRowModel
   module Import
@@ -76,7 +76,7 @@ module CsvRowModel
         def define_representation_method(representation_name, options={}, &block)
           Representation.check_options(options)
           merge_representations(representation_name.to_sym => options)
-          define_method(representation_name) { representation_value(representation_name) }
+          define_proxy_method(representation_name) { representation_value(representation_name) }
           Representation.define_lambda_method(self, representation_name, &block)
         end
       end

data/lib/csv_row_model/concerns/inspect.rb

@@ -1,10 +1,9 @@
 module CsvRowModel
-  module Concerns
-    module Inspect
-      def inspect
-        s = self.class.send(:inspect_methods).map { |method| "#{method}=#{public_send(method).inspect}" }.join(", ")
-        "#<#{self.class.name}:#{object_id} #{s}>"
-      end
+  module Inspect
+    def inspect
+      s = self.class::INSPECT_METHODS.map { |method| "#{method}=#{public_send(method).inspect}" }.join(", ")
+      address = ('%x' % (object_id << 1)).rjust(14, "0")
+      "#<#{self.class.name}:0x#{address} #{s}>"
     end
   end
 end

data/lib/csv_row_model/{model/columns.rb → concerns/model/attributes.rb}

@@ -1,34 +1,20 @@
+require 'inherited_class_var'
+require 'csv_row_model/internal/model/header'
+
 module CsvRowModel
   module Model
-    module Columns
+    module Attributes
       extend ActiveSupport::Concern
+      include InheritedClassVar
+
       included do
         inherited_class_hash :columns
       end
 
-      # @return [Hash] a map of `column_name => public_send(column_name)`
-      def attributes
-        attributes_from_method_names self.class.column_names
-      end
-
-      def to_json
-        attributes.to_json
-      end
-
       def headers
         self.class.headers(context)
       end
 
-      protected
-
-      def attributes_from_method_names(column_names)
-        array_to_block_hash(column_names) { |column_name| try(column_name) }
-      end
-
-      def array_to_block_hash(array, &block)
-        array.zip(array.map { |column_name| block.call(column_name) }).to_h
-      end
-
       class_methods do
         # @return [Array<Symbol>] column names for the row model
         def column_names
@@ -41,19 +27,10 @@ module CsvRowModel
           column_names.index column_name
         end
 
-        # @param [Symbol] column_name name of column to check
-        # @return [Boolean] true if it's a column name
-        def is_column_name? column_name
-          column_name.is_a?(Symbol) && index(column_name)
-        end
-
         # @param [Hash, OpenStruct] context name of column to check
         # @return [Array] column headers for the row model
         def headers(context={})
-          context = OpenStruct.new(context)
-          columns.map.with_index do |(column_name, options), index|
-            options[:header] || format_header(column_name, index, context)
-          end
+          column_names.map { |column_name| Header.new(column_name, self, context).value }
         end
 
         # Safe to override
@@ -74,7 +51,7 @@ module CsvRowModel
 
         protected
 
-        VALID_OPTIONS_KEYS = %i[type parse validate_type default header header_matchs].freeze
+        VALID_OPTIONS_KEYS = %i[type parse validate_type default header].freeze
 
         # Adds column to the row model
         #