csv_row_model 0.4.1 → 1.0.0.beta1

data/lib/csv_row_model/import/dynamic_column_cell.rb

@@ -0,0 +1,37 @@
+module CsvRowModel
+  module Import
+    class DynamicColumnCell < CsvRowModel::Model::DynamicColumnCell
+      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_header|
+          call_process_cell(formatted_cell, source_header)
+        end
+      end
+
+      def formatted_cells
+        source_cells.map.with_index do |source_cell, index|
+          row_model.class.format_cell(source_cell, column_name, dynamic_column_index + index, row_model.context)
+        end
+      end
+
+      def formatted_headers
+        source_headers.map.with_index do |source_header, index|
+          row_model.class.format_dynamic_column_header(source_header, column_name, dynamic_column_index, index, row_model.context)
+        end
+      end
+
+      class << self
+        def define_process_cell(row_model_class, column_name)
+          super { |formatted_cell, source_header| formatted_cell }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/dynamic_columns.rb

@@ -1,3 +1,5 @@
+require 'csv_row_model/import/dynamic_column_cell'
+
 module CsvRowModel
   module Import
     module DynamicColumns
@@ -7,55 +9,36 @@ module CsvRowModel
         self.dynamic_column_names.each { |*args| define_dynamic_attribute_method(*args) }
       end
 
-      # @return [Array] dynamic_column headers
-      def dynamic_source_headers
-        self.class.dynamic_source_headers source_header
-      end
-
-      # @return [Array] dynamic_column row data
-      def dynamic_source_row
-        self.class.dynamic_columns? ? source_row[self.class.columns.size..-1] : []
+      def cell_objects
+        @dynamic_column_cell_objects ||= super.merge(array_to_block_hash(self.class.dynamic_column_names) do |column_name|
+          DynamicColumnCell.new(column_name, dynamic_column_source_headers, dynamic_column_source_cells, self)
+        end)
       end
 
       # @return [Hash] a map of `column_name => original_attribute(column_name)`
       def original_attributes
-        super
-        self.class.dynamic_column_names.each { |column_name| original_attribute(column_name) }
-        @original_attributes
+        super.merge!(array_to_block_hash(self.class.dynamic_column_names) { |column_name| original_attribute(column_name) })
       end
 
-      # @return [Object] the column's attribute before override
-      def original_attribute(column_name)
-        return super if self.class.column_names.include? column_name
-        return unless self.class.dynamic_column_names.include? column_name
-        return @original_attributes[column_name] if original_attribute_memoized? column_name
-
-        values = dynamic_source_headers.map.with_index do |source_header, index|
-          value = self.class.format_cell(
-            dynamic_source_row[index],
-            source_header,
-            self.class.dynamic_index(column_name),
-            context
-          )
-          public_send(self.class.singular_dynamic_attribute_method_name(column_name), value, source_header)
-        end
+      # @return [Array] dynamic_column headers
+      def dynamic_column_source_headers
+        self.class.dynamic_column_source_headers source_header
+      end
 
-        @original_attributes[column_name] = self.class.format_dynamic_column_cells(values, column_name)
+      # @return [Array] dynamic_column row data
+      def dynamic_column_source_cells
+        self.class.dynamic_column_source_cells source_row
       end
 
       class_methods do
-        # 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)
-          cells
-        end
-        # @return [Array] dynamic_column headers
-        def dynamic_source_headers(source_header)
+        def dynamic_column_source_headers(source_header)
           dynamic_columns? ? source_header[columns.size..-1] : []
         end
 
+        def dynamic_column_source_cells(source_row)
+          dynamic_columns? ? source_row[columns.size..-1] : []
+        end
+
         protected
 
         # See {Model#dynamic_column}
@@ -68,7 +51,7 @@ module CsvRowModel
         # @param column_name [Symbol] the cell's column_name
         def define_dynamic_attribute_method(column_name)
           define_method(column_name) { original_attribute(column_name) }
-          define_method(singular_dynamic_attribute_method_name(column_name)) { |value, source_header| value }
+          DynamicColumnCell.define_process_cell(self, column_name)
         end
       end
     end

data/lib/csv_row_model/import/file/validations.rb

@@ -4,11 +4,15 @@ module CsvRowModel
       module Validations
         extend ActiveSupport::Concern
 
-        include ActiveModel::Validations
+        include ActiveWarnings
         include Validators::ValidateAttributes
 
         included do
           validate_attributes :csv
+
+          warnings do
+            validate { errors.add(:csv, "has header with #{csv.header.message}") unless csv.header.class == Array }
+          end
         end
 
         # @return [Boolean] returns true, if the file should abort reading

data/lib/csv_row_model/import/file.rb

@@ -13,7 +13,7 @@ module CsvRowModel
       # @return [Input] model class returned for importing
       attr_reader :row_model_class
 
-      # Current index of the row model
+      # 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}
@@ -23,7 +23,7 @@ module CsvRowModel
       # @return [Hash] context passed to the {Import}
       attr_reader :context
 
-      delegate :header, :size, :skipped_rows, :end_of_file?, to: :csv
+      delegate :size, :end_of_file?, :line_number, to: :csv
 
       # @param [String] file_path path of csv file
       # @param [Import] row_model_class model class returned for importing
@@ -33,6 +33,11 @@ module CsvRowModel
         reset
       end
 
+      def header
+        h = csv.header
+        h.class == Array ? h : []
+      end
+
       # Resets the file back to the top
       def reset
         csv.reset
@@ -47,8 +52,8 @@ module CsvRowModel
         run_callbacks :next do
           context = context.to_h.reverse_merge(self.context)
           @previous_row_model = current_row_model
-          @current_row_model = row_model_class.next(csv, header, context, previous_row_model)
           @index += 1
+          @current_row_model = row_model_class.next(self, context)
           @current_row_model = @index = nil if end_of_file?
         end
 

data/lib/csv_row_model/import/file_model.rb

@@ -22,15 +22,16 @@ module CsvRowModel
         # @return [Array] header_matchs matchers for the row model
         def header_matchers(context)
           @header_matchers ||= begin
-            columns.map do |name, options|
-              if formatted_header = self.format_header(name, context)
+            columns.map.with_index do |(name, options), index|
+              if formatted_header = self.format_header(name, index, context)
                 Regexp.new("^#{formatted_header}$", Regexp::IGNORECASE)
               end
             end.compact
           end
         end
 
-        def next(csv, source_header, context={}, previous=nil)
+        def next(file, context={})
+          csv = file.csv
           return csv.read_row unless csv.next_row
 
           source_row = Array.new(header_matchers(context).size)
@@ -48,7 +49,7 @@ module CsvRowModel
             end
           end
 
-          new(source_row, source_header: source_header, context: context, previous: previous)
+          new(source_row, source_header: csv.header, context: context, previous: file.previous_row_model)
         end
       end
     end

data/lib/csv_row_model/import/representation.rb

@@ -0,0 +1,60 @@
+module CsvRowModel
+  module Import
+    class Representation
+      include Concerns::CheckOptions
+      VALID_OPTIONS = %i[memoize empty_value dependencies].freeze
+
+      attr_reader :name, :options, :row_model
+
+      def initialize(name, options, row_model)
+        @name = name
+        @options = options
+        @row_model = row_model
+      end
+
+      def value
+        memoize? ? memoized_value : dependencies_value
+      end
+
+      def memoized_value
+        @memoized_value ||= dependencies_value
+      end
+
+      def memoize?
+        options.has_key?(:memoize) ? !!options[:memoize] : true
+      end
+
+      def dependencies_value
+        valid_dependencies? ? lambda_value : empty_value
+      end
+
+      # @return [Boolean] if the dependencies are valid
+      def valid_dependencies?
+        dependencies.each { |attribute_name| return false if row_model.public_send(attribute_name).blank? }
+        true
+      end
+
+      def empty_value
+        options[:empty_value]
+      end
+
+      def lambda_value
+        row_model.public_send(self.class.lambda_name(name))
+      end
+
+      def dependencies
+        Array(options[:dependencies])
+      end
+
+      class << self
+        def lambda_name(representation_name)
+          :"__#{representation_name}"
+        end
+
+        def define_lambda_method(row_model_class, representation_name, &block)
+          row_model_class.send(:define_method, lambda_name(representation_name), &block)
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/represents.rb

@@ -0,0 +1,85 @@
+require 'csv_row_model/import/representation'
+
+module CsvRowModel
+  module Import
+    module Represents
+      extend ActiveSupport::Concern
+
+      included do
+        inherited_class_hash :representations
+      end
+
+      def representation_objects
+        @representation_objects ||= array_to_block_hash(self.class.representation_names) do |representation_name|
+          Representation.new(representation_name, self.class.representations[representation_name], self)
+        end
+      end
+
+      def representation_value(representation_name)
+        representation_objects[representation_name].try(:value)
+      end
+
+      def representations
+        attributes_from_method_names(self.class.representation_names)
+      end
+
+      def all_attributes
+        attributes.merge!(representations)
+      end
+
+      def valid?(*args)
+        super
+        filter_errors
+        errors.empty?
+      end
+
+      protected
+
+      # remove each dependent attribute from errors if it's representation dependencies are in the errors
+      def filter_errors
+        self.class.representation_names.each do |representation_name|
+          next unless errors.messages.slice(*representation_objects[representation_name].dependencies).present?
+          errors.delete representation_name
+        end
+      end
+
+      class_methods do
+        # @return [Array<Symbol>] names of all representations
+        def representation_names
+          representations.keys
+        end
+
+        protected
+
+        # Defines a representation for singular resources
+        #
+        # @param [Symbol] representation_name name of representation to add
+        # @param [Proc] block to define the attribute
+        # @param options [Hash]
+        # @option options [Hash] :memoize whether to memoize the attribute (default: true)
+        # @option options [Hash] :dependencies the dependencies with other attributes/representations (default: [])
+        def represents_one(*args, &block)
+          define_representation_method(*args, &block)
+        end
+
+        # Defines a representation for multiple resources
+        #
+        # @param [Symbol] representation_name name of representation to add
+        # @param [Proc] block to define the attribute
+        # @param options [Hash]
+        # @option options [Hash] :memoize whether to memoize the attribute (default: true)
+        # @option options [Hash] :dependencies the dependencies with other attributes/representations (default: [])
+        def represents_many(representation_name, options={}, &block)
+          define_representation_method(representation_name, options.merge(empty_value: []), &block)
+        end
+
+        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) }
+          Representation.define_lambda_method(self, representation_name, &block)
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/import.rb

@@ -1,7 +1,8 @@
 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/model/comparison'
+require 'csv_row_model/import/represents'
 
 module CsvRowModel
   # Include this to with {Model} to have a RowModel for importing csvs.
@@ -11,9 +12,9 @@ module CsvRowModel
     include Concerns::Inspect
 
     include Base
+    include CsvStringModel
     include Attributes
     include DynamicColumns
-
-    include Model::Comparison # can't be added on Model module because Model does not have attributes implemented
+    include Represents
   end
 end

data/lib/csv_row_model/model/base.rb

@@ -4,6 +4,8 @@ module CsvRowModel
       extend ActiveSupport::Concern
 
       included do
+        attr_reader :context
+
         # @return [Model] return the parent, if this instance is a child
         attr_reader :parent
 
@@ -13,12 +15,13 @@ module CsvRowModel
         validate_attributes :parent
       end
 
-      # @param [NilClass] source not used here, see {Input}
       # @param [Hash] options
       # @option options [String] :parent if the instance is a child, pass the parent
-      def initialize(source=nil, options={})
+      # @option options [Hash] :context extra data you want to work with the model
+      def initialize(options={})
         @initialized_at = DateTime.now
         @parent = options[:parent]
+        @context =  OpenStruct.new(options[:context] || {})
       end
 
       # Safe to override.
@@ -34,19 +37,6 @@ module CsvRowModel
       def abort?
         false
       end
-
-      class_methods do
-        # @return [Class] the Class with validations of the csv_string_model
-        def csv_string_model_class
-          @csv_string_model_class ||= inherited_custom_class(:csv_string_model_class, CsvStringModel)
-        end
-
-        protected
-        # Called to add validations to the csv_string_model_class
-        def csv_string_model(&block)
-          csv_string_model_class.class_eval(&block)
-        end
-      end
     end
   end
 end

data/lib/csv_row_model/model/children.rb

@@ -15,6 +15,7 @@ module CsvRowModel
       #
       # @return [Model] return the child if it is valid, otherwise returns nil
       def append_child(source, options={})
+        return nil unless source
         self.class.has_many_relationships.each do |relation_name, child_class|
           child_row_model = child_class.new(source, options.reverse_merge(parent: self))
           if child_row_model.valid?
@@ -58,7 +59,7 @@ module CsvRowModel
             #
             # equal to: @relation_name ||= []
             #
-            variable_name = "@#{relation_name}"
+            variable_name = :"@#{relation_name}"
             instance_variable_get(variable_name) || instance_variable_set(variable_name, [])
           end
         end

data/lib/csv_row_model/model/columns.rb

@@ -8,7 +8,7 @@ module CsvRowModel
 
       # @return [Hash] a map of `column_name => public_send(column_name)`
       def attributes
-        attributes_from_column_names self.class.column_names
+        attributes_from_method_names self.class.column_names
       end
 
       def to_json
@@ -21,15 +21,12 @@ module CsvRowModel
 
       protected
 
-      def attributes_from_column_names(column_names)
-        array_to_block_hash(column_names) { |column_name| public_send(column_name) }
+      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
+        array.zip(array.map { |column_name| block.call(column_name) }).to_h
       end
 
       class_methods do
@@ -38,12 +35,6 @@ module CsvRowModel
           columns.keys
         end
 
-        # @param [Symbol] column_name name of column to find option
-        # @return [Hash] options for the column_name
-        def options(column_name)
-          columns[column_name]
-        end
-
         # @param [Symbol] column_name name of column to find index
         # @return [Integer] index of the column_name
         def index(column_name)
@@ -59,16 +50,28 @@ module CsvRowModel
         # @param [Hash, OpenStruct] context name of column to check
         # @return [Array] column headers for the row model
         def headers(context={})
-          columns.map { |name, options| options[:header] || format_header(name, context) }
+          context = OpenStruct.new(context)
+          columns.map.with_index do |(column_name, options), index|
+            options[:header] || format_header(column_name, index, context)
+          end
         end
 
         # Safe to override
         #
         # @return [String] formatted header
-        def format_header(column_name, context={})
+        def format_header(column_name, column_index, context)
           column_name
         end
 
+        # Safe to override. Method applied to each cell by default
+        #
+        # @param cell [String] the cell's string
+        # @param column_name [Symbol] the cell's column_name
+        # @param column_index [Integer] the column_name's index
+        def format_cell(cell, column_name, column_index, context)
+          cell
+        end
+
         protected
 
         VALID_OPTIONS_KEYS = %i[type parse validate_type default header header_matchs].freeze
@@ -97,7 +100,7 @@ module CsvRowModel
 
         def merge_options(column_name, options={})
           column_name = column_name.to_sym
-          column(column_name, (options(column_name) || {}).merge(options))
+          column(column_name, options)
         end
       end
     end

data/lib/csv_row_model/model/comparison.rb

@@ -4,7 +4,7 @@ module CsvRowModel
       extend ActiveSupport::Concern
 
       def eql?(other)
-        other.attributes == attributes
+        other.try(:attributes) == attributes
       end
 
       def hash

data/lib/csv_row_model/model/dynamic_column_cell.rb

@@ -0,0 +1,44 @@
+module CsvRowModel
+  module Model
+    class DynamicColumnCell
+      attr_reader :column_name, :row_model
+
+      def initialize(column_name, row_model)
+        @column_name = column_name
+        @row_model = row_model
+      end
+
+      def value
+        @value ||= row_model.class.format_dynamic_column_cells(unformatted_value, column_name, dynamic_column_index, row_model.context)
+      end
+
+      def dynamic_column_index
+        @dynamic_column_index ||= row_model.class.dynamic_column_index(column_name)
+      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 Cell 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.send(:define_method, process_cell_method_name(column_name), &block)
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/model/dynamic_columns.rb

@@ -1,3 +1,5 @@
+require 'csv_row_model/model/dynamic_column_cell'
+
 module CsvRowModel
   module Model
     module DynamicColumns
@@ -8,7 +10,7 @@ module CsvRowModel
 
       # See Model::Columns#attributes
       def attributes
-        super.merge(attributes_from_column_names(self.class.dynamic_column_names))
+        super.merge!(attributes_from_method_names(self.class.dynamic_column_names))
       end
 
       class_methods do
@@ -20,30 +22,44 @@ module CsvRowModel
           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
+        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
+        end
+
         # See Model::Columns::headers
         def headers(context={})
           super + dynamic_column_headers(context)
         end
 
         def dynamic_column_headers(context={})
-          dynamic_column_names.map do |column_name|
-            Array(OpenStruct.new(context).public_send(column_name)).each do |header_model|
-              header_proc = dynamic_column_options(column_name)[:header] || ->(header_model) { header_model }
+          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
         end
 
         # @return [Integer] index of dynamic_column of all columns
-        def dynamic_index(column_name)
+        def dynamic_column_index(column_name)
           offset = dynamic_column_names.index(column_name)
           offset ? columns.size + offset : nil
         end
 
-        def dynamic_column_options(column_name)
-          dynamic_columns[column_name]
-        end
-
         # @return [Array<Symbol>] column names for the row model
         def dynamic_column_names
           dynamic_columns.keys
@@ -59,9 +75,8 @@ module CsvRowModel
 
         # define a dynamic_column, must be after all normal columns
         #
-        # options to be implemented later
-        #
         # @param column_name [Symbol] column_name
+        # @option options [String] :header human friendly string of the column name, by default format_header(column_name)
         def dynamic_column(column_name, options={})
           extra_keys = options.keys - VALID_OPTIONS_KEYS
           raise ArgumentError.new("invalid options #{extra_keys}") unless extra_keys.empty?

data/lib/csv_row_model/model.rb

@@ -1,16 +1,15 @@
-require 'csv_row_model/model/csv_string_model'
-
 require 'csv_row_model/model/base'
 require 'csv_row_model/model/columns'
 require 'csv_row_model/model/children'
 require 'csv_row_model/model/dynamic_columns'
+require 'csv_row_model/model/comparison'
 
 module CsvRowModel
   # Base module for representing a RowModel---a model that represents row(s).
   module Model
     extend ActiveSupport::Concern
 
-    include Concerns::InheritedClassVar
+    include InheritedClassVar
 
     include ActiveWarnings
     include Validators::ValidateAttributes
@@ -20,5 +19,7 @@ module CsvRowModel
     include Columns
     include Children
     include DynamicColumns
+
+    include Comparison
   end
 end