csv_row_model 1.0.0.beta1 → 1.0.0.beta2

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

@@ -4,15 +4,7 @@ module CsvRowModel
       extend ActiveSupport::Concern
 
       included do
-        attr_reader :context
-
-        # @return [Model] return the parent, if this instance is a child
-        attr_reader :parent
-
-        # @return [DateTime] return when self has been intialized
-        attr_reader :initialized_at
-
-        validate_attributes :parent
+        attr_reader :context, :parent, :initialized_at
       end
 
       # @param [Hash] options
@@ -25,14 +17,12 @@ module CsvRowModel
       end
 
       # Safe to override.
-      #
       # @return [Boolean] returns true, if this instance should be skipped
       def skip?
         !valid?
       end
 
       # Safe to override.
-      #
       # @return [Boolean] returns true, if the entire csv file should stop reading
       def abort?
         false

data/lib/csv_row_model/{model → concerns/model}/children.rb

@@ -1,7 +1,13 @@
+require 'inherited_class_var'
+require 'csv_row_model/concerns/hidden_module'
+
 module CsvRowModel
   module Model
     module Children
       extend ActiveSupport::Concern
+      include InheritedClassVar
+      include HiddenModule
+
       included do
         inherited_class_hash :has_many_relationships
       end
@@ -55,7 +61,7 @@ module CsvRowModel
 
           merge_has_many_relationships(relation_name => row_model_class)
 
-          define_method(relation_name) do
+          define_proxy_method(relation_name) do
             #
             # equal to: @relation_name ||= []
             #

data/lib/csv_row_model/{model → concerns/model}/dynamic_columns.rb

@@ -1,40 +1,29 @@
-require 'csv_row_model/model/dynamic_column_cell'
+require 'csv_row_model/internal/model/dynamic_column_header'
 
 module CsvRowModel
   module Model
     module DynamicColumns
       extend ActiveSupport::Concern
+      include InheritedClassVar
+
       included do
         inherited_class_hash :dynamic_columns
       end
 
-      # See Model::Columns#attributes
-      def attributes
-        super.merge!(attributes_from_method_names(self.class.dynamic_column_names))
-      end
-
       class_methods do
         def dynamic_columns?
           dynamic_columns.present?
         end
 
-        def is_dynamic_column?(column_name)
-          dynamic_columns.keys.include?(column_name)
-        end
-
-        # Safe to override. Method applied to each dynamic_column attribute
-        #
-        # @param cells [Array] Array of values
-        # @param column_name [Symbol] Dynamic column name
-        def format_dynamic_column_cells(cells, column_name, column_index, context)
-          cells
+        # @return [Integer] index of dynamic_column of all columns
+        def dynamic_column_index(column_name)
+          offset = dynamic_column_names.index(column_name)
+          offset ? columns.size + offset : nil
         end
 
-        # Safe to override
-        #
-        # @return [String] formatted header
-        def format_dynamic_column_header(header_model, column_name, dynamic_column_index, index_of_column, context)
-          header_model
+        # @return [Array<Symbol>] column names for the row model
+        def dynamic_column_names
+          dynamic_columns.keys
         end
 
         # See Model::Columns::headers
@@ -43,35 +32,27 @@ module CsvRowModel
         end
 
         def dynamic_column_headers(context={})
-          context = OpenStruct.new(context)
-
-          dynamic_columns.map do |column_name, options|
-            Array(context.public_send(column_name)).map.with_index do |header_model, index_of_column|
-              header_proc = options[:header] ||
-                ->(header_model) { format_dynamic_column_header(header_model, column_name, dynamic_column_index(column_name), index_of_column, context) }
-              instance_exec(header_model, &header_proc)
-            end
-          end.flatten
+          dynamic_column_names.map { |column_name| DynamicColumnHeader.new(column_name, self, context).value }.flatten
         end
 
-        # @return [Integer] index of dynamic_column of all columns
-        def dynamic_column_index(column_name)
-          offset = dynamic_column_names.index(column_name)
-          offset ? columns.size + offset : nil
-        end
-
-        # @return [Array<Symbol>] column names for the row model
-        def dynamic_column_names
-          dynamic_columns.keys
+        # Safe to override. Method applied to each dynamic_column attribute
+        #
+        # @param cells [Array] Array of values
+        # @param column_name [Symbol] Dynamic column name
+        def format_dynamic_column_cells(cells, column_name, column_index, context)
+          cells
         end
 
-        def singular_dynamic_attribute_method_name(column_name)
-          column_name.to_s.singularize
+        # Safe to override
+        #
+        # @return [String] formatted header
+        def format_dynamic_column_header(header_model, column_name, dynamic_column_index, context)
+          header_model
         end
 
         protected
 
-        VALID_OPTIONS_KEYS = %i[header].freeze
+        VALID_OPTIONS_KEYS = %i[header header_models_context_key].freeze
 
         # define a dynamic_column, must be after all normal columns
         #

data/lib/csv_row_model/export/file_model.rb

@@ -7,14 +7,8 @@ module CsvRowModel
       #                 and everything else is return as is.
       def to_rows
         rows_template.map.with_index do |row, index|
-          [].tap do |result|
-            row.each do |cell|
-              if header? cell
-                result << self.class.format_header(cell, index, context)
-              else
-                result << cell.to_s
-              end
-            end
+          row.map do |cell|
+            self.class.row_names.include?(cell) ? self.class.format_header(cell, index, context) : cell.to_s
           end
         end
       end
@@ -31,13 +25,6 @@ module CsvRowModel
       class_methods do
         def setup(csv, context, with_headers: true); end
       end
-
-      private
-
-      def header?(cell)
-        self.class.is_row_name? cell
-      end
-
     end
   end
 end

data/lib/csv_row_model/export.rb

@@ -1,6 +1,6 @@
-require 'csv_row_model/export/base'
-require 'csv_row_model/export/dynamic_columns'
-require 'csv_row_model/export/attributes'
+require 'csv_row_model/concerns/export/base'
+require 'csv_row_model/concerns/export/dynamic_columns'
+require 'csv_row_model/concerns/export/attributes'
 
 module CsvRowModel
   # Include this to with {Model} to have a RowModel for exporting to CSVs.

data/lib/csv_row_model/import/file.rb

@@ -1,40 +1,39 @@
-require 'csv_row_model/import/file/callbacks'
-require 'csv_row_model/import/file/validations'
+require 'csv_row_model/internal/import/csv'
 
 module CsvRowModel
   module Import
     # Represents a csv file and handles parsing to return `Import`
     class File
-      include Callbacks
-      include Validations
-
-      # @return [Csv]
-      attr_reader :csv
-      # @return [Input] model class returned for importing
-      attr_reader :row_model_class
-
-      # Current index of the row model (not the same as number of rows)
-      # @return [Integer] returns -1 = start of file, 0 to infinity = index of row_model, nil = end of file, no row_model
-      attr_reader :index
-      # @return [Input] the current row model set by {#next}
-      attr_reader :current_row_model
-      # @return [Input] the previous row model set by {#next}
-      attr_reader :previous_row_model
-      # @return [Hash] context passed to the {Import}
-      attr_reader :context
+      extend ActiveModel::Callbacks
+      include ActiveWarnings
+
+      attr_reader :csv, :row_model_class
+      attr_reader :index # -1 = start of file, 0 to infinity = index of row_model, nil = end of file, no row_model
+      attr_reader :current_row_model, :previous_row_model, :context
 
       delegate :size, :end_of_file?, :line_number, to: :csv
 
+      define_model_callbacks :each_iteration
+      define_model_callbacks :next
+      define_model_callbacks :abort, :skip, only: :before
+
+      validate { errors.messages.merge!(csv.errors.messages) unless csv.valid? }
+      warnings do
+        validate :headers_invalid_row
+      end
+
       # @param [String] file_path path of csv file
       # @param [Import] row_model_class model class returned for importing
       # @param context [Hash] context passed to the {Import}
       def initialize(file_path, row_model_class, context={})
-        @csv, @row_model_class, @context = Csv.new(file_path), row_model_class, context.to_h.symbolize_keys
+        @csv = Csv.new(file_path)
+        @row_model_class = row_model_class
+        @context = context.to_h.symbolize_keys
         reset
       end
 
-      def header
-        h = csv.header
+      def headers
+        h = csv.headers
         h.class == Array ? h : []
       end
 
@@ -75,6 +74,47 @@ module CsvRowModel
           end
         end
       end
+
+      # @return [Boolean] returns true, if the file should abort reading
+      def abort?
+        !valid? || !!current_row_model.try(:abort?)
+      end
+
+      # @return [Boolean] returns true, if the file should skip `current_row_model`
+      def skip?
+        !!current_row_model.try(:skip?)
+      end
+
+      protected
+      def _abort?
+        abort = abort?
+        run_callbacks(:abort) if abort
+        abort
+      end
+
+      def _skip?
+        skip = skip?
+        run_callbacks(:skip) if skip
+        skip
+      end
+
+      #
+      # Validations
+      #
+      def headers_invalid_row
+        errors.add(:csv, "has header with #{csv.headers.message}") if csv.headers.class < Exception
+      end
+
+      def headers_count
+        return if headers_invalid_row || !csv.valid?
+        return if row_model_class.dynamic_columns? || row_model_class.try(:row_names) # dynamic_column or FileModel
+
+        size_until_blank = ((headers || []).map { |h| h.try(:strip) }.rindex(&:present?) || -1) + 1
+        column_names = row_model_class.column_names
+
+        return if size_until_blank == column_names.size
+        errors.add(:headers, "count does not match. Given headers (#{size_until_blank}). Expected headers (#{column_names.size}): #{column_names.join(", ")}.")
+      end
     end
   end
 end

data/lib/csv_row_model/import/file_model.rb

@@ -19,11 +19,10 @@ module CsvRowModel
           match ? match[1] : nil
         end
 
-        # @return [Array] header_matchs matchers for the row model
         def header_matchers(context)
           @header_matchers ||= begin
-            columns.map.with_index do |(name, options), index|
-              if formatted_header = self.format_header(name, index, context)
+            row_names.map.with_index do |row_name, index|
+              if formatted_header = self.format_header(row_name, index, context)
                 Regexp.new("^#{formatted_header}$", Regexp::IGNORECASE)
               end
             end.compact
@@ -49,7 +48,7 @@ module CsvRowModel
             end
           end
 
-          new(source_row, source_header: csv.header, context: context, previous: file.previous_row_model)
+          new(source_row, source_headers: csv.headers, context: context, previous: file.previous_row_model)
         end
       end
     end

data/lib/csv_row_model/import.rb

@@ -1,20 +1,16 @@
-require 'csv_row_model/import/base'
-require 'csv_row_model/import/csv_string_model'
-require 'csv_row_model/import/attributes'
-require 'csv_row_model/import/dynamic_columns'
-require 'csv_row_model/import/represents'
+require 'csv_row_model/concerns/import/base'
+require 'csv_row_model/concerns/import/attributes'
+require 'csv_row_model/concerns/import/dynamic_columns'
+require 'csv_row_model/concerns/import/represents'
 
 module CsvRowModel
   # Include this to with {Model} to have a RowModel for importing csvs.
   module Import
     extend ActiveSupport::Concern
 
-    include Concerns::Inspect
-
     include Base
-    include CsvStringModel
     include Attributes
-    include DynamicColumns
     include Represents
+    include DynamicColumns
   end
 end

data/lib/csv_row_model/internal/attribute_base.rb

@@ -0,0 +1,22 @@
+require 'csv_row_model/internal/concerns/column_shared'
+
+module CsvRowModel
+  class AttributeBase
+    include ColumnShared
+
+    attr_reader :column_name, :row_model
+
+    def initialize(column_name, row_model)
+      @column_name = column_name
+      @row_model = row_model
+    end
+
+    def formatted_value
+      @formatted_value ||= row_model_class.format_cell(source_value, column_name, column_index, row_model.context)
+    end
+
+    def row_model_class
+      row_model.class
+    end
+  end
+end

data/lib/csv_row_model/internal/concerns/column_shared.rb

@@ -0,0 +1,21 @@
+module CsvRowModel
+  module ColumnShared
+    #
+    # row_model
+    #
+    def context
+      row_model.context
+    end
+
+    #
+    # row_model_class
+    #
+    def column_index
+      row_model_class.index(column_name)
+    end
+
+    def options
+      row_model_class.columns[column_name]
+    end
+  end
+end

data/lib/csv_row_model/internal/concerns/dynamic_column_shared.rb

@@ -0,0 +1,28 @@
+require 'csv_row_model/internal/concerns/column_shared'
+
+module CsvRowModel
+  module DynamicColumnShared
+    include ColumnShared
+    #
+    # row_model_class
+    #
+    def column_index
+      @dynamic_column_index ||= row_model_class.dynamic_column_index(column_name)
+    end
+
+    def options
+      row_model_class.dynamic_columns[column_name]
+    end
+
+    #
+    # header models
+    #
+    def header_models
+      Array(context.public_send(header_models_context_key))
+    end
+
+    def header_models_context_key
+      options[:header_models_context_key] || column_name
+    end
+  end
+end

data/lib/csv_row_model/internal/dynamic_column_attribute_base.rb

@@ -0,0 +1,42 @@
+require 'csv_row_model/internal/attribute_base'
+require 'csv_row_model/internal/concerns/dynamic_column_shared'
+
+module CsvRowModel
+  class DynamicColumnAttributeBase < AttributeBase
+    include DynamicColumnShared
+
+    def value
+      @value ||= row_model_class.format_dynamic_column_cells(unformatted_value, column_name, column_index, row_model.context)
+    end
+
+    def formatted_cells
+      source_cells.map.with_index.map do |cell, index|
+        row_model_class.format_cell(cell, column_name, column_index + index, row_model.context)
+      end
+    end
+
+    protected
+
+    def process_cell_method_name
+      self.class.process_cell_method_name(column_name)
+    end
+
+    # Calls the process_cell to return the value of a Attribute given the args
+    def call_process_cell(*args)
+      row_model.public_send(process_cell_method_name, *args)
+    end
+
+    class << self
+      def process_cell_method_name(column_name)
+        column_name.to_s.singularize.to_sym
+      end
+
+      # define a method to process each cell of the attribute method
+      # process_cell = one cell
+      # attribute_method = many cells = [process_cell(), process_cell()...]
+      def define_process_cell(row_model_class, column_name, &block)
+        row_model_class.define_proxy_method(process_cell_method_name(column_name), &block)
+      end
+    end
+  end
+end

data/lib/csv_row_model/internal/export/attribute.rb

@@ -0,0 +1,15 @@
+require 'csv_row_model/internal/attribute_base'
+
+module CsvRowModel
+  module Export
+    class Attribute < CsvRowModel::AttributeBase
+      def value
+        formatted_value
+      end
+
+      def source_value
+        row_model.public_send(column_name)
+      end
+    end
+  end
+end

data/lib/csv_row_model/internal/export/dynamic_column_attribute.rb

@@ -0,0 +1,21 @@
+require 'csv_row_model/internal/dynamic_column_attribute_base'
+
+module CsvRowModel
+  module Export
+    class DynamicColumnAttribute < CsvRowModel::DynamicColumnAttributeBase
+      def unformatted_value
+        formatted_cells
+      end
+
+      def source_cells
+        header_models.map { |header_model| call_process_cell(header_model) }
+      end
+
+      class << self
+        def define_process_cell(row_model_class, column_name)
+          super { |header_model| header_model }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/{import/cell.rb → internal/import/attribute.rb}

@@ -1,15 +1,14 @@
-require 'csv_row_model/validators/boolean_format'
+require 'csv_row_model/internal/attribute_base'
 
 module CsvRowModel
   module Import
-    class Cell
-      attr_reader :column_name, :source_value, :csv_string_model_errors, :row_model
+    class Attribute < CsvRowModel::AttributeBase
+      attr_reader :source_value, :csv_string_model_errors
 
       def initialize(column_name, source_value, csv_string_model_errors, row_model)
-        @column_name = column_name
         @source_value = source_value
         @csv_string_model_errors = csv_string_model_errors
-        @row_model = row_model
+        super(column_name, row_model)
       end
 
       def value
@@ -19,10 +18,6 @@ module CsvRowModel
         end
       end
 
-      def formatted_value
-        @formatted_value ||= row_model.class.format_cell(source_value, column_name, row_model.class.index(column_name), row_model.context)
-      end
-
       def parsed_value
         @parsed_value ||= begin
           value = formatted_value
@@ -45,10 +40,6 @@ module CsvRowModel
         [formatted_value, default_value] if default?
       end
 
-      def options
-        row_model.class.columns[column_name]
-      end
-
       protected
 
       # Mapping of column type classes to a parsing lambda. These are applied after {Import.format_cell}.

data/lib/csv_row_model/{import → internal/import}/csv.rb

@@ -11,7 +11,7 @@ module CsvRowModel
 
       include ActiveModel::Validations
 
-      validate { begin; _ruby_csv; rescue => e; errors.add(:ruby_csv, e.message) end }
+      validate { begin; _ruby_csv; rescue => e; errors.add(:csv, e.message) end }
 
       def initialize(file_path)
         @file_path = file_path
@@ -24,18 +24,16 @@ module CsvRowModel
         @size ||= `wc -l #{file_path}`.split[0].to_i + 1
       end
 
-      # If the current position is at the header, skip it and return it. Otherwise, only return false.
+      # If the current position is at the headers, skip it and return it. Otherwise, only return false.
       # @return [Boolean, Array] returns false, if header is already skipped, otherwise returns the header
-      def skip_header
-        start_of_file? ? (@header = read_row) : false
+      def skip_headers
+        start_of_file? ? (@headers = read_row) : false
       end
 
       # Returns the header __without__ changing the position of the CSV
       # @return [Array, nil] the header
-      def header
-        return unless valid?
-        return @header if @header
-        @header = next_row
+      def headers
+        @headers ||= next_row
       end
 
       # Resets the file to the start of file
@@ -43,7 +41,7 @@ module CsvRowModel
         return false unless valid?
 
         @line_number = 0
-        @current_row = @next_row = @skipped_rows = @next_skipped_rows = nil
+        @headers = @current_row = @next_row = @skipped_rows = @next_skipped_rows = nil
 
         @ruby_csv.try(:close)
         @ruby_csv = _ruby_csv
@@ -83,13 +81,13 @@ module CsvRowModel
         CSV.open(file_path)
       end
 
-      def _read_row(ruby_csv=@ruby_csv)
+      def _read_row
         return unless valid?
-        ruby_csv.readline
+        @ruby_csv.readline.tap { |row| @headers ||= row }
       rescue Exception => e
-        changed = e.exception(e.message.gsub(/line \d+\./, "line #{line_number + 1}.")) # line numbers are usually off
+        changed = e.exception(e.message.gsub(/line \d+\.?/, "line #{line_number + 1}.")) # line numbers are usually off
         changed.set_backtrace(e.backtrace)
-        return changed
+        changed
       end
     end
   end

data/lib/csv_row_model/internal/import/dynamic_column_attribute.rb

@@ -0,0 +1,33 @@
+require 'csv_row_model/internal/dynamic_column_attribute_base'
+
+module CsvRowModel
+  module Import
+    class DynamicColumnAttribute < CsvRowModel::DynamicColumnAttributeBase
+      attr_reader :source_headers, :source_cells
+
+      def initialize(column_name, source_headers, source_cells, row_model)
+        @source_headers = source_headers
+        @source_cells = source_cells
+        super(column_name, row_model)
+      end
+
+      def unformatted_value
+        formatted_cells.zip(formatted_headers).map do |formatted_cell, source_headers|
+          call_process_cell(formatted_cell, source_headers)
+        end
+      end
+
+      def formatted_headers
+        source_headers.map do |source_headers|
+          row_model_class.format_dynamic_column_header(source_headers, column_name, column_index, row_model.context)
+        end
+      end
+
+      class << self
+        def define_process_cell(row_model_class, column_name)
+          super { |formatted_cell, source_headers| formatted_cell }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/{import → internal/import}/representation.rb

@@ -1,7 +1,7 @@
 module CsvRowModel
   module Import
     class Representation
-      include Concerns::CheckOptions
+      include CheckOptions
       VALID_OPTIONS = %i[memoize empty_value dependencies].freeze
 
       attr_reader :name, :options, :row_model
@@ -52,7 +52,7 @@ module CsvRowModel
         end
 
         def define_lambda_method(row_model_class, representation_name, &block)
-          row_model_class.send(:define_method, lambda_name(representation_name), &block)
+          row_model_class.define_proxy_method(lambda_name(representation_name), &block)
         end
       end
     end