csv_row_model 0.1.0

data/lib/csv_row_model/import/attributes.rb

@@ -0,0 +1,105 @@
+require 'csv_row_model/validators/boolean_format'
+
+module CsvRowModel
+  module Import
+    module Attributes
+      extend ActiveSupport::Concern
+      # Classes with a validations associated with them in csv_row_model/validators
+      PARSE_VALIDATION_CLASSES = [Boolean, Integer, Float, Date].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 },
+        Date    => ->(s) { s.present? ? Date.parse(s) : s }
+      }.freeze
+
+      # @return [Hash] a map of `column_name => original_attribute(column_name)`
+      def original_attributes
+        @original_attributes ||= begin
+          values = self.class.column_names.map { |column_name| original_attribute(column_name) }
+          self.class.column_names.zip(values).to_h
+        end
+      end
+
+      # @return [Object] the column's attribute before override
+      def original_attribute(column_name)
+        @default_changes ||= {}
+
+        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))
+        if value.present?
+          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]
+          value
+        end
+      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
+      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)
+          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
+        # Define default attribute method for a column
+        # @param column_name [Symbol] the cell's column_name
+        def define_attribute_method(column_name)
+          add_type_validation(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
+end

data/lib/csv_row_model/import/csv.rb

@@ -0,0 +1,136 @@
+module CsvRowModel
+  module Import
+    # Abstraction of Ruby's CSV library. Keeps current row and index, 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 [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
+
+      def initialize(file_path)
+        @file_path = file_path
+        reset
+      end
+
+      # http://stackoverflow.com/questions/2650517/count-the-number-of-lines-in-a-file-without-reading-entire-file-into-memory
+      # @return [Integer] the number of rows in the file, including empty new lines
+      def size
+        @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.
+      # @return [Boolean, Array] returns false, if header is already skipped, otherwise returns the header
+      def skip_header
+        start_of_file? ? (@header = 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
+
+        ruby_csv = _ruby_csv
+        @header = _read_row({}, 0, ruby_csv)
+        ruby_csv.close
+        @header
+      end
+
+      # Resets the file to the start of file
+      def reset
+        return unless valid?
+
+        @index = -1
+        @current_row = nil
+        @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
+      end
+
+      # @return [Boolean] true, if the current position is at the end of the file
+      def end_of_file?
+        index.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)
+      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
+        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)
+        return unless valid?
+
+        loop do
+          row = ruby_csv.readline
+
+          raise "empty?" if row.try(:empty?)
+
+          index += 1 if index
+
+          yield row if block_given?
+          return row
+        end
+      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
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/csv/row.rb

@@ -0,0 +1,17 @@
+module CsvRowModel
+  module Import
+    class Csv
+      class Row
+        attr_reader :row, :skipped_rows
+
+        def initialize(row, index, skipped_rows)
+          @row, @index, @skipped_rows = row, index, skipped_rows
+        end
+
+        def empty?
+          !!row.try(:empty?)
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/file.rb

@@ -0,0 +1,133 @@
+require 'csv_row_model/import/file/callbacks'
+require 'csv_row_model/import/file/validations'
+
+module CsvRowModel
+  module Import
+    # Represents a csv file and handles parsing to return `Import` or `Mapper`
+    class File
+      include Callbacks
+      include Validations
+
+      # @return [Csv]
+      attr_reader :csv
+      # @return [Input,Mapper] model class returned for importing
+      attr_reader :row_model_class
+
+      # Current index of the row model
+      # @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, Mapper] the current row model set by {#next}
+      attr_reader :current_row_model
+      # @return [Input, Mapper] the previous row model set by {#next}
+      attr_reader :previous_row_model
+
+      delegate :header, :size, :skipped_rows, to: :csv
+
+      # @param [String] file_path path of csv file
+      # @param [Import, Mapper] row_model_class model class returned for importing
+      def initialize(file_path, row_model_class)
+        @csv, @row_model_class = Csv.new(file_path), row_model_class
+        reset
+      end
+
+      # Resets the file back to the top
+      def reset
+        csv.reset
+        @index = -1
+        @current_row_model = nil
+      end
+
+      # Gets the next row model based on the context
+      #
+      # @param context [Hash] context passed to the {Import}
+      def next(context={})
+        if is_single_model?
+          return set_end_of_file if end_of_file?
+          set_single_model(context)
+        else
+          next_collection_model(context)
+        end
+      end
+
+      # @return [Boolean] returns true, if the object is at the end of file
+      def end_of_file?
+        csv.end_of_file?
+      end
+
+      # Iterates through the entire csv file and provides the `current_row_model` in a block, while handing aborts and skips
+      # via. calling {Model#abort?} and {Model#skip?}
+      #
+      # @param context [Hash] context passed to the {Import}
+      def each(context={})
+        return to_enum(__callee__, context) unless block_given?
+        return false if _abort?
+
+        while self.next(context)
+          return false if _abort?
+          next if _skip?
+
+          run_callbacks :yield do
+            yield current_row_model
+          end
+        end
+      end
+
+      protected
+
+      # @return [boolean] if type of model is collection_model
+      def is_single_model?
+        @is_single_model ||= begin
+          row_model_class.respond_to?(:type) ? (row_model_class.type == :single_model) : false
+        end
+      end
+
+      def set_current_collection_model(context)
+        @current_row_model = row_model_class.new(csv.current_row, index: csv.index, context: context, source_header: header, previous: previous_row_model)
+        @index += 1
+      end
+
+      def set_single_model(context={})
+        source_row = Array.new(row_model_class.header_matchers.size)
+        while !end_of_file?
+          csv.read_row
+          update_source_row(source_row)
+        end
+        @current_row_model = row_model_class.new(source_row, context: context)
+      end
+
+      def update_source_row(source_row)
+        current_row = csv.current_row
+        return unless current_row
+        current_row.each_with_index do |cell, position|
+          next if cell.blank?
+          index = row_model_class.index_header_match(cell)
+          next unless index
+          source_row[index] = current_row[position + 1]
+          break
+        end
+      end
+
+      def next_collection_model(context)
+        csv.skip_header
+
+        next_row_is_parent = true
+        loop do
+          @previous_row_model = current_row_model if next_row_is_parent
+
+          csv.read_row
+          return set_end_of_file if csv.end_of_file?
+
+          set_current_collection_model(context) if next_row_is_parent
+
+          next_row_is_parent = !current_row_model.append_child(csv.next_row)
+          return current_row_model if next_row_is_parent
+        end
+      end
+
+      def set_end_of_file
+        # please return nil
+        @current_row_model = @index = nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module CsvRowModel
+  module Import
+    class File
+      module Callbacks
+        extend ActiveSupport::Concern
+
+        included do
+          extend ActiveModel::Callbacks
+
+          define_model_callbacks :yield
+          define_model_callbacks :abort, :skip, only: :before
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module CsvRowModel
+  module Import
+    class File
+      module Validations
+        extend ActiveSupport::Concern
+
+        included do
+          include ActiveModel::Validations
+          include Validators::ValidateAttributes
+
+          validate_attributes :csv
+        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
+      end
+    end
+  end
+end