csv_row_model 0.4.1 → 1.0.0.beta1

data/lib/csv_row_model/export/file.rb

@@ -1,16 +1,16 @@
 module CsvRowModel
   module Export
     class File
-      attr_reader :export_model_class, :csv, :file, :context
+      attr_reader :row_model_class, :csv, :file, :context
 
       # @param [Export] export_model export model class
-      def initialize(export_model_class, context={})
-        @export_model_class = export_model_class
+      def initialize(row_model_class, context={})
+        @row_model_class = row_model_class
         @context = context.to_h.symbolize_keys
       end
 
       def headers
-        export_model_class.headers(self.context)
+        row_model_class.headers(self.context)
       end
 
       # Add a row_model to the
@@ -18,7 +18,7 @@ module CsvRowModel
       # @param [Hash] context the extra context given to the instance of the row model
       # @return [CsvRowModel::Export] the row model appended
       def append_model(source_model, context={})
-        row_model = export_model_class.new(source_model, context.reverse_merge(self.context))
+        row_model = row_model_class.new(source_model, context.reverse_merge(self.context))
         row_model.to_rows.each do |row|
           csv << row
         end
@@ -34,10 +34,10 @@ module CsvRowModel
       # Open a block to generate a file
       # @param [Boolean] with_headers adds the header to the file if true
       def generate(with_headers: true)
-        @file = Tempfile.new([export_model_class.name, ".csv"])
+        @file = Tempfile.new([row_model_class.name, ".csv"])
         CSV.open(file.path, "wb") do |csv|
           @csv = csv
-          export_model_class.setup(csv, context, with_headers: with_headers)
+          row_model_class.setup(csv, context, with_headers: with_headers)
           yield Proxy.new(self)
         end
       ensure

data/lib/csv_row_model/export/file_model.rb

@@ -6,11 +6,11 @@ module CsvRowModel
       # @return [Array] an array of rows, where if cell is row_name, it's parsed into the header_match
       #                 and everything else is return as is.
       def to_rows
-        rows_template.map do |row|
+        rows_template.map.with_index do |row, index|
           [].tap do |result|
             row.each do |cell|
               if header? cell
-                result << self.class.format_header(cell, context)
+                result << self.class.format_header(cell, index, context)
               else
                 result << cell.to_s
               end

data/lib/csv_row_model/export.rb

@@ -1,7 +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/model/comparison'
 
 module CsvRowModel
   # Include this to with {Model} to have a RowModel for exporting to CSVs.
@@ -11,7 +10,5 @@ module CsvRowModel
     include Base
     include Attributes
     include DynamicColumns
-
-    include Model::Comparison # can't be added on Model module because Model does not have attributes implemented
   end
 end

data/lib/csv_row_model/import/attributes.rb

@@ -1,4 +1,4 @@
-require 'csv_row_model/validators/boolean_format'
+require 'csv_row_model/import/cell'
 
 module CsvRowModel
   module Import
@@ -9,86 +9,37 @@ module CsvRowModel
         self.column_names.each { |*args| define_attribute_method(*args) }
       end
 
-      # Classes with a validations associated with them in csv_row_model/validators
-      PARSE_VALIDATION_CLASSES = [Boolean, Integer, Float, Date, DateTime].freeze
-
-      # Mapping of column type classes to a parsing lambda. These are applied after {Import.format_cell}.
-      # Can pass custom Proc with :parse option.
-      CLASS_TO_PARSE_LAMBDA = {
-        nil      => ->(s) { s },
-        Boolean  => ->(s) { s =~ BooleanFormatValidator::FALSE_BOOLEAN_REGEX ? false : true },
-        String   => ->(s) { s },
-        Integer  => ->(s) { s.to_i },
-        Float    => ->(s) { s.to_f },
-        DateTime => ->(s) { s.present? ? DateTime.parse(s) : s },
-        Date     => ->(s) { s.present? ? Date.parse(s) : s }
-      }.freeze
+      def cell_objects
+        @cell_objects ||= begin
+          csv_string_model.valid?
+          _cell_objects(csv_string_model.errors)
+        end
+      end
 
       # @return [Hash] a map of `column_name => original_attribute(column_name)`
       def original_attributes
-        self.class.column_names.each { |column_name| original_attribute(column_name) }
-        @original_attributes
+        array_to_block_hash(self.class.column_names) { |column_name| original_attribute(column_name) }
       end
 
       # @return [Object] the column's attribute before override
       def original_attribute(column_name)
-        return @original_attributes[column_name] if original_attribute_memoized? column_name
-
-        csv_string_model.valid?
-        return nil unless csv_string_model.errors[column_name].blank?
-
-        value = self.class.format_cell(mapped_row[column_name], column_name, self.class.index(column_name), context)
-        if value.present?
-          value = instance_exec(value, &self.class.parse_lambda(column_name))
-        elsif self.class.options(column_name)[:default]
-          original_value = value
-          value = instance_exec(value, &self.class.default_lambda(column_name))
-          @default_changes[column_name] = [original_value, value]
-        end
-        @original_attributes[column_name] = value
+        cell_objects[column_name].try(:value)
       end
 
       # return [Hash] a map changes from {.column}'s default option': `column_name -> [value_before_default, default_set]`
       def default_changes
-        original_attributes
-        @default_changes
+        array_to_block_hash(self.class.column_names) { |column_name| cell_objects[column_name].default_change }.delete_if {|k, v| v.blank? }
       end
 
       protected
-      def original_attribute_memoized?(column_name)
-        @original_attributes ||= {}
-        @default_changes     ||= {}
-        @original_attributes.has_key? column_name
+      # to prevent circular dependency with csv_string_model
+      def _cell_objects(csv_string_model_errors={})
+        array_to_block_hash(self.class.column_names) do |column_name|
+          Cell.new(column_name, mapped_row[column_name], csv_string_model_errors[column_name], self)
+        end
       end
 
       class_methods do
-        # 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
-
-        # @return [Lambda] returns a Lambda: ->(original_value) { default_exists? ? default : original_value }
-        def default_lambda(column_name)
-          default = options(column_name)[:default]
-          default.is_a?(Proc) ? ->(s) { instance_exec(&default) } : ->(s) { default.nil? ? s : default }
-        end
-
-        # @return [Lambda, Proc] returns the Lambda/Proc given in the parse option or:
-        # ->(original_value) { parse_proc_exists? ? parsed_value : original_value  }
-        def parse_lambda(column_name)
-          options = options(column_name)
-
-          raise ArgumentError.new("You need either :parse OR :type but not both of them") if options[:parse] && options[:type]
-
-          parse_lambda = options[:parse] || CLASS_TO_PARSE_LAMBDA[options[:type]]
-          return parse_lambda if parse_lambda
-          raise ArgumentError.new("type must be #{CLASS_TO_PARSE_LAMBDA.keys.reject(:nil?).join(", ")}")
-        end
-
         protected
         # See {Model#column}
         def column(column_name, options={})
@@ -97,8 +48,8 @@ module CsvRowModel
         end
 
         def merge_options(column_name, options={})
-          original_options = options(column_name)
-          add_type_validation(column_name) if !original_options[:validate_type] && options[:validate_type]
+          original_options = columns[column_name]
+          csv_string_model_class.add_type_validation(column_name, columns[column_name]) unless original_options[:validate_type]
           super
         end
 
@@ -106,23 +57,9 @@ module CsvRowModel
         # @param column_name [Symbol] the cell's column_name
         def define_attribute_method(column_name)
           return if method_defined? column_name
-          add_type_validation(column_name)
+          csv_string_model_class.add_type_validation(column_name, columns[column_name])
           define_method(column_name) { original_attribute(column_name) }
         end
-
-        # Adds the type validation based on :validate_type option
-        def add_type_validation(column_name)
-          options = options(column_name)
-          validate_type = options[:validate_type]
-
-          return unless validate_type
-
-          type = options[:type]
-          raise ArgumentError.new("invalid :type given for :validate_type for column") unless PARSE_VALIDATION_CLASSES.include? type
-          validate_type = Proc.new { validates column_name, "#{type.name.underscore}_format".to_sym => true, allow_blank: true }
-
-          csv_string_model(&validate_type)
-        end
       end
     end
   end

data/lib/csv_row_model/import/base.rb

@@ -1,31 +1,31 @@
-require 'csv_row_model/import/presenter'
-
 module CsvRowModel
   module Import
     module Base
       extend ActiveSupport::Concern
 
       included do
-        attr_reader :source_header, :source_row, :context, :index, :previous
+        attr_reader :source_header, :source_row, :line_number, :index, :previous
 
-        validates :source_row, presence: true
+        validate { errors.add(:csv, "has #{@csv_exception.message}") if @csv_exception }
       end
 
-
-      # @param [Array] source_row the csv row
+      # @param [Array] source_row_or_exception the csv row
       # @param options [Hash]
-      # @option options [Integer] :index index in the CSV file
-      # @option options [Hash] :context extra data you want to work with the model
+      # @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 [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, options={})
-        options = options.symbolize_keys.reverse_merge(context: {})
-        @source_row, @context = source_row, OpenStruct.new(options[:context])
-        @index, @source_header, @previous = options[:index], options[:source_header], options[:previous].try(:dup)
+      def initialize(source_row_or_exception=[], options={})
+        @source_row = source_row_or_exception
+        @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]
 
+        @previous = options[:previous].try(:dup)
         previous.try(:free_previous)
-        super(source_row, options)
+        super(options)
       end
 
       # @return [Hash] a map of `column_name => source_row[index_of_column_name]`
@@ -36,78 +36,45 @@ module CsvRowModel
 
       # Free `previous` from memory to avoid making a linked list
       def free_previous
+        attributes
         @previous = nil
       end
 
-      # @return [Presenter] the presenter of self
-      def presenter
-        @presenter ||= self.class.presenter_class.new(self)
-      end
-
-      # @return [Model::CsvStringModel] a model with validations related to Model::csv_string_model (values are from format_cell)
-      def csv_string_model
-        @csv_string_model ||= begin
-          if source_row
-            column_names = self.class.column_names
-            hash = column_names.zip(
-              column_names.map.with_index do |column_name, index|
-                self.class.format_cell(source_row[index], column_name, index, context)
-              end
-            ).to_h
-          else
-            hash = {}
-          end
-
-          self.class.csv_string_model_class.new(hash)
-        end
-      end
-
       # Safe to override.
       #
       # @return [Boolean] returns true, if this instance should be skipped
       def skip?
-        !valid? || presenter.skip?
+        !valid?
       end
 
       # Safe to override.
       #
       # @return [Boolean] returns true, if the entire csv file should stop reading
       def abort?
-        presenter.abort?
-      end
-
-      def valid?(*args)
-        super
-
-        proc = -> do
-          csv_string_model.valid?(*args)
-          errors.messages.merge!(csv_string_model.errors.messages.reject {|k, v| v.empty? })
-          errors.empty?
-        end
-
-        if using_warnings?
-          csv_string_model.using_warnings(&proc)
-        else
-          proc.call
-        end
+        false
       end
 
       class_methods do
-        # @param [Import::Csv] csv to read from
+        #
+        # Move to Import::File once FileModel is removed.
+        #
+        # @param [Import::File] file to read from
         # @param [Hash] context extra data you want to work with the model
         # @param [Import] prevuous the previous row model
         # @return [Import] the next model instance from the csv
-        def next(csv, source_header, context={}, previous=nil)
+        def next(file, context={})
+          csv = file.csv
           csv.skip_header
           row_model = nil
 
           loop do # loop until the next parent or end_of_file? (need to read children rows)
             csv.read_row
             row_model ||= new(csv.current_row,
-                              index: csv.index,
-                              source_header: source_header,
+                              line_number: csv.line_number,
+                              index: file.index,
+                              source_header: csv.header,
                               context: context,
-                              previous: previous)
+                              previous: file.previous_row_model)
 
             return row_model if csv.end_of_file?
 
@@ -116,20 +83,10 @@ module CsvRowModel
           end
         end
 
-        # @return [Class] the Class of the Presenter
-        def presenter_class
-          @presenter_class ||= inherited_custom_class(:presenter_class, Presenter)
-        end
-
         protected
         def inspect_methods
           @inspect_methods ||= %i[mapped_row initialized_at parent context previous].freeze
         end
-
-        # Call to define the presenter
-        def presenter(&block)
-          presenter_class.class_eval(&block)
-        end
       end
     end
   end

data/lib/csv_row_model/import/cell.rb

@@ -0,0 +1,77 @@
+require 'csv_row_model/validators/boolean_format'
+
+module CsvRowModel
+  module Import
+    class Cell
+      attr_reader :column_name, :source_value, :csv_string_model_errors, :row_model
+
+      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
+      end
+
+      def value
+        @value ||= begin
+          return unless csv_string_model_errors.blank?
+          default? ? default_value : parsed_value
+        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
+          value.present? ? row_model.instance_exec(formatted_value, &parse_lambda) : value
+        end
+      end
+
+      def default_value
+        @default_value ||= begin
+          default = options[:default]
+          default.is_a?(Proc) ? row_model.instance_exec(&default) : default
+        end
+      end
+
+      def default?
+        !!options[:default] && formatted_value.blank?
+      end
+
+      def default_change
+        [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}.
+      # Can pass custom Proc with :parse option.
+      CLASS_TO_PARSE_LAMBDA = {
+        nil      => ->(s) { s }, # no type given
+        Boolean  => ->(s) { s =~ BooleanFormatValidator::FALSE_BOOLEAN_REGEX ? false : true },
+        String   => ->(s) { s },
+        Integer  => ->(s) { s.to_i },
+        Float    => ->(s) { s.to_f },
+        DateTime => ->(s) { s.present? ? DateTime.parse(s) : s },
+        Date     => ->(s) { s.present? ? Date.parse(s) : s }
+      }.freeze
+
+      # @return [Lambda, Proc] returns the Lambda/Proc given in the parse option or:
+      # ->(source_value) { parse_proc_exists? ? parsed_value : source_value  }
+      def parse_lambda
+        raise ArgumentError.new("Use :parse OR :type option, but not both for: #{column_name}") if options[:parse] && options[:type]
+
+        parse_lambda = options[:parse] || CLASS_TO_PARSE_LAMBDA[options[:type]]
+        return parse_lambda if parse_lambda
+        raise ArgumentError.new("type must be #{CLASS_TO_PARSE_LAMBDA.keys.reject(:nil?).join(", ")} for: #{column_name}")
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/csv.rb

@@ -1,22 +1,17 @@
 module CsvRowModel
   module Import
-    # Abstraction of Ruby's CSV library. Keeps current row and index, skips empty rows, handles errors.
+    # Abstraction of Ruby's CSV library. Keeps current row and line_number, skips empty rows, handles errors.
     class Csv
       # @return [String] the file path of the CSV
       attr_reader :file_path
-      # @return [Integer, nil] return `-1` at start of file, `0 to infinity` is index of row_model, `nil` is end of file (row is also `nil`)
-      attr_reader :index
+      # @return [Integer, nil] return `0` at start of file, `1 to infinity` is line_number of row_model, `nil` is end of file (row is also `nil`)
+      attr_reader :line_number
       # @return [Array, nil] the current row, or nil at the beginning or end of file
       attr_reader :current_row
-      # @return [Hash{Integer => Symbol}] hash of skipped rows from last change in position, `index => :reason`
-      attr_reader :skipped_rows
 
       include ActiveModel::Validations
 
-      validate do
-        begin; _ruby_csv
-        rescue => e; errors.add(:ruby_csv, e.message) end
-      end
+      validate { begin; _ruby_csv; rescue => e; errors.add(:ruby_csv, e.message) end }
 
       def initialize(file_path)
         @file_path = file_path
@@ -40,93 +35,61 @@ module CsvRowModel
       def header
         return unless valid?
         return @header if @header
-
-        ruby_csv = _ruby_csv
-        @header = _read_row({}, 0, ruby_csv)
-        ruby_csv.close
-        @header
+        @header = next_row
       end
 
       # Resets the file to the start of file
       def reset
-        return unless valid?
+        return false unless valid?
 
-        @index = -1
+        @line_number = 0
         @current_row = @next_row = @skipped_rows = @next_skipped_rows = nil
+
+        @ruby_csv.try(:close)
         @ruby_csv = _ruby_csv
         true
       end
 
       # @return [Boolean] true, if the current position is at the start of the file
       def start_of_file?
-        index == -1
+        line_number == 0
       end
 
       # @return [Boolean] true, if the current position is at the end of the file
       def end_of_file?
-        index.nil?
+        line_number.nil?
       end
 
       # Returns the next row __without__ changing the position of the CSV
       # @return [Array, nil] the next row, or `nil` at the end of file
       def next_row
-        @next_skipped_rows = {}
-        @next_row ||= _read_row(@next_skipped_rows)
+        @next_row ||= _read_row
       end
 
       # Returns the next row, while changing the position of the CSV
       # @return [Array, nil] the changed current row, or `nil` at the end of file
       def read_row
-        if @next_row
-          @current_row, @skipped_rows = @next_row, @next_skipped_rows
-          @next_row = nil
-          increment_index(@current_row)
-        else
-          @skipped_rows = {}
-          @current_row = _read_row(@skipped_rows) do |row|
-            increment_index(row)
-          end
-        end
+        return if end_of_file?
+
+        @current_row = @next_row || _read_row
+        @line_number = current_row.nil? ? nil : @line_number + 1
+        @next_row = nil
+
         current_row
       end
 
       protected
-      def set_end_of_file
-        @current_row = @index = nil
-      end
-
       def _ruby_csv
         CSV.open(file_path)
       end
 
-      def _read_row(skipped_rows={}, index=@index, ruby_csv=@ruby_csv)
+      def _read_row(ruby_csv=@ruby_csv)
         return unless valid?
-
-        row = ruby_csv.readline
-        raise "empty?" if row.try(:empty?)
-
-        index += 1 if index
-
-        yield row if block_given?
-        row
+        ruby_csv.readline
       rescue Exception => e
-        index += 1 if index
-        yield [] if block_given?
-
-        # thanks to the ruby CSV library, quotes can still escape to the next line
-        reason = case e.message
-                   when "empty?"; :empty
-                   when /Illegal quoting/i; :illegal_quote
-                   when /Unclosed quoted/i; :unclosed_quote
-                 end
-
-        skipped_rows.merge!(index => reason)
-
-        retry
-      end
-
-      def increment_index(current_row)
-        current_row.nil? ? set_end_of_file : @index += 1
+        changed = e.exception(e.message.gsub(/line \d+\./, "line #{line_number + 1}.")) # line numbers are usually off
+        changed.set_backtrace(e.backtrace)
+        return changed
       end
     end
   end

data/lib/csv_row_model/import/csv_string_model.rb

@@ -0,0 +1,65 @@
+module CsvRowModel
+  module Import
+    module CsvStringModel
+      extend ActiveSupport::Concern
+
+      def valid?(*args)
+        super
+        call_wrapper = using_warnings? ? csv_string_model.method(:using_warnings) : ->(&block) { block.call }
+        call_wrapper.call do
+          csv_string_model.valid?(*args)
+          errors.messages.merge!(csv_string_model.errors.messages.reject {|k, v| v.empty? })
+          errors.empty?
+        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 }
+          self.class.csv_string_model_class.new(formatted_hash)
+        end
+      end
+
+      protected
+      def _original_attribute(column_name)
+        csv_string_model.valid?
+        return nil unless csv_string_model.errors[column_name].blank?
+      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, Model)
+        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
+
+      class Model < OpenStruct
+        include ActiveWarnings
+
+        # Classes with a validations associated with them in csv_row_model/validators
+        PARSE_VALIDATION_CLASSES = [Boolean, Integer, Float, Date, DateTime].freeze
+
+        class << self
+          # Adds the type validation based on :validate_type option
+          def add_type_validation(column_name, options)
+            return unless options[:validate_type]
+
+            type = options[:type]
+            raise ArgumentError.new("invalid :type given for :validate_type for: #{column_name}") unless PARSE_VALIDATION_CLASSES.include? type
+
+            class_eval { validates column_name, :"#{type.name.underscore}_format" => true, allow_blank: true }
+          end
+        end
+      end
+    end
+  end
+end