csv_row_model 0.1.0

data/lib/csv_row_model/import/presenter.rb

@@ -0,0 +1,160 @@
+module CsvRowModel
+  module Import
+    class Presenter
+      include Concerns::DeepClassVar
+      include Concerns::Inspect
+      include ActiveWarnings
+
+      attr_reader :row_model
+
+      delegate :context, to: :row_model
+
+      def initialize(row_model)
+        @row_model = row_model
+      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
+      end
+
+      def valid?(*args)
+        super
+        filter_errors
+        errors.empty?
+      end
+
+      # @return [Presenter] returns the presenter of the previous row_model
+      def previous
+        row_model.previous.try(:presenter)
+      end
+
+      protected
+
+      # add errors from row_model and remove each dependent attribute from errors if it's row_model_dependencies
+      # are in the errors
+      def filter_errors
+        using_warnings? ? row_model.using_warnings { _filter_errors } : _filter_errors
+      end
+
+      def _filter_errors
+        row_model.valid?
+        self.class.attribute_names.each do |attribute_name|
+          next unless errors.messages[attribute_name] &&
+            row_model.errors.messages.slice(*self.class.options(attribute_name)[:dependencies]).present?
+          errors.delete attribute_name
+        end
+
+        errors.messages.reverse_merge!(row_model.errors.messages)
+      end
+
+      # @param [Symbol] attribute_name the attribute to check
+      # @return [Boolean] if the dependencies are valid
+      def valid_dependencies?(attribute_name)
+        row_model.valid? || (row_model.errors.keys & self.class.options(attribute_name)[:dependencies]).empty?
+      end
+
+      # equal to: @method_name ||= yield
+      # @param [Symbol] method_name method_name in description
+      # @return [Object] the memoized result
+      def memoize(method_name)
+        variable_name = "@#{method_name}"
+        instance_variable_get(variable_name) || instance_variable_set(variable_name, yield)
+      end
+
+      class << self
+        def deep_class_module
+          Presenter
+        end
+
+        # @return [Array<Symbol>] attribute names for the Mapper
+        def attribute_names
+          attributes.keys
+        end
+
+        # @return [Hash{Symbol => Array}] map of `attribute_name => [options, block]`
+        def attributes
+          deep_class_var :@_mapper_attributes, {}, :merge
+        end
+
+        # @param [Symbol] attribute_name name of attribute to find option
+        # @return [Hash] options for the attribute_name
+        def options(attribute_name)
+          attributes[attribute_name].first
+        end
+
+        # @param [Symbol] attribute_name name of attribute to find block
+        # @return [Proc, Lambda] block called for attribute
+        def block(attribute_name)
+          attributes[attribute_name].last
+        end
+
+        # @return [Hash{Symbol => Array}] map of `dependency => [array of mapper attributes dependent on dependency]`
+        def dependencies
+          deep_class_cache(:@_mapper_dependencies) do
+            dependencies = {}
+            attribute_names.each do |attribute_name|
+              options(attribute_name)[:dependencies].each do |dependency|
+                dependencies[dependency] ||= []
+                dependencies[dependency] << attribute_name
+              end
+            end
+            dependencies
+          end
+        end
+
+        protected
+        def inspect_methods
+          @inspect_methods ||= %i[row_model].freeze
+        end
+
+        def merge_attribute(attribute_hash)
+          @_mapper_attributes ||= {}
+          clear_deep_class_cache(:@_mapper_attributes)
+          clear_deep_class_cache(:@_mapper_dependencies)
+          @_mapper_attributes.merge! attribute_hash
+        end
+
+        # Adds column to the row model
+        #
+        # @param [Symbol] attribute_name name of attribute to add
+        # @param [Proc] block to calculate the attribute
+        # @param options [Hash]
+        # @option options [Hash] :memoize whether to memoize the attribute (default: true)
+        # @option options [Hash] :dependencies the dependcies it has with the underlying row_model (default: [])
+        def attribute(attribute_name, options={}, &block)
+          default_options = { memoize: true, dependencies: [] }
+          invalid_options = options.keys - default_options.keys
+          raise ArgumentError.new("Invalid option(s): #{invalid_options}") if invalid_options.present?
+
+          options = options.reverse_merge(default_options)
+
+          merge_attribute(attribute_name.to_sym => [options, block])
+          define_attribute_method(attribute_name)
+        end
+
+        # Define the attribute_method
+        # @param [Symbol] attribute_name name of attribute to add
+        def define_attribute_method(attribute_name)
+          define_method("__#{attribute_name}", &block(attribute_name))
+
+          define_method(attribute_name) do
+            return unless valid_dependencies?(attribute_name)
+            self.class.options(attribute_name)[:memoize] ?
+              memoize(attribute_name) { public_send("__#{attribute_name}") } :
+              public_send("__#{attribute_name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/single_model.rb

@@ -0,0 +1,41 @@
+module CsvRowModel
+  # Include this to with {Model} to have a RowModel for importing csvs that
+  # represents just one model.
+  # It needs CsvRowModel::Import
+  module Import
+    module SingleModel
+      extend ActiveSupport::Concern
+
+      class_methods do
+
+        # @return [Symbol] returns type of import
+        def type
+          :single_model
+        end
+
+        # Safe to override
+        #
+        # @param cell [String] the cell's string
+        # @return [Integer] returns index of the header_match that cell match
+        def index_header_match(cell)
+          match = header_matchers.each_with_index.select do |matcher, index|
+            cell.match(matcher)
+          end.first
+          match ? match[1] : nil
+        end
+
+        # @return [Array] header_matchs matchers for the row model
+        def header_matchers
+          @header_matchers ||= begin
+            columns.map do |name, options|
+              matchers = options[:header_matchs] || [name.to_s]
+              Regexp.new(matchers.join('|'),Regexp::IGNORECASE)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/csv_row_model/model.rb

@@ -0,0 +1,68 @@
+require 'csv_row_model/model/csv_string_model'
+
+require 'csv_row_model/model/columns'
+require 'csv_row_model/model/children'
+
+module CsvRowModel
+  # Base module for representing a RowModel---a model that represents row(s).
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      include Concerns::DeepClassVar
+
+      include ActiveWarnings
+      include Validators::ValidateAttributes
+
+      include Columns
+      include Children
+
+      # @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
+    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={})
+      @initialized_at = DateTime.now
+      @parent = options[:parent]
+    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
+    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
+
+      def deep_class_module
+        Model
+      end
+    end
+  end
+end

data/lib/csv_row_model/model/children.rb

@@ -0,0 +1,79 @@
+module CsvRowModel
+  module Model
+    module Children
+      extend ActiveSupport::Concern
+
+      # @return [Boolean] returns true, if the instance is a child
+      def child?
+        !!parent
+      end
+
+      # Appends child to the parent and returns it
+      #
+      # @return [Model] return the child if it is valid, otherwise returns nil
+      def append_child(source, options={})
+        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?
+            public_send(relation_name) << child_row_model
+            return child_row_model
+          end
+        end
+        nil
+      end
+
+      # Convenience method to return an array of calling `public_send(method_name)` on it's children
+      #
+      # @return [Array] results of `public_send(method_name)` in a flattened array
+      def children_public_send(method_name)
+        self.class.has_many_relationships.keys.map do |relation_name|
+          public_send(relation_name).map(&method_name)
+        end.flatten(1)
+      end
+
+      # Convenience method to return an array of calling `public_send(method_name)` on itself and it's children
+      #
+      # @return [Array] results of `public_send(method_name)` in a flattened array
+      def deep_public_send(method_name)
+        result = [public_send(method_name)]
+        result + children_public_send(method_name)
+      end
+
+      class_methods do
+        # Won't work for Export right now
+        #
+        # @return [Hash] map of `relation_name => CsvRowModel::Import or CsvRowModel::Export class`
+        def has_many_relationships
+          deep_class_var :@_has_many_relationships, {}, :merge
+        end
+
+        protected
+        def merge_has_many_relationships(relation_hash)
+          @_has_many_relationships ||= {}
+          clear_deep_class_cache(:@_has_many_relationships)
+          @_has_many_relationships.merge! relation_hash
+        end
+
+        # Defines a relationship between a row model (only one relation per model for now).
+        #
+        # @param [Symbol] relation_name the name of the relation
+        # @param [CsvRowModel::Import] row_model_class class of the relation
+        def has_many(relation_name, row_model_class)
+          raise "for now, CsvRowModel's has_many may only be called once" if @_has_many_relationships.present?
+
+          relation_name = relation_name.to_sym
+
+          merge_has_many_relationships(relation_name => row_model_class)
+
+          define_method(relation_name) do
+            #
+            # equal to: @relation_name ||= []
+            #
+            variable_name = "@#{relation_name}"
+            instance_variable_get(variable_name) || instance_variable_set(variable_name, [])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/model/columns.rb

@@ -0,0 +1,73 @@
+module CsvRowModel
+  module Model
+    module Columns
+      extend ActiveSupport::Concern
+
+      # @return [Hash] a map of `column_name => public_send(column_name)`
+      def attributes
+        self.class.column_names
+          .zip(self.class.column_names.map { |column_name| public_send(column_name) })
+          .to_h
+      end
+
+      def to_json
+        attributes.to_json
+      end
+
+      class_methods do
+        # @return [Array<Symbol>] column names for the row model
+        def column_names
+          columns.keys
+        end
+
+        # @return [Hash] column names mapped to their options
+        def columns
+          deep_class_var(:@_columns, {}, :merge)
+        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)
+          column_names.index column_name
+        end
+
+        protected
+
+        def merge_columns(column_hash)
+          @_columns ||= {}
+          clear_deep_class_cache(:@_columns)
+          @_columns.merge!(column_hash)
+        end
+
+        VALID_OPTIONS_KEYS = %i[type parse validate_type default header header_matchs].freeze
+
+        # Adds column to the row model
+        #
+        # @param [Symbol] column_name name of column to add
+        # @param options [Hash]
+        #
+        # @option options [class] :type class you want to automatically parse to (by default does nothing, equivalent to String)
+        # @option options [Lambda, Proc] :parse for parsing the cell
+        # @option options [Boolean] :validate_type adds a validations within a {::csv_string_model} call.
+        # if true, it will add the default validation for the given :type (if applicable)
+        #
+        # @option options [Object] :default default value of the column if it is blank?, can pass Proc
+        # @option options [String] :header human friendly string of the column name, by default format_header(column_name)
+        # @option options [Hash] :header_matchs array with string to match cell to find in the row, by default column name
+        def column(column_name, options={})
+          extra_keys = options.keys - VALID_OPTIONS_KEYS
+          raise ArgumentError.new("invalid options #{extra_keys}") unless extra_keys.empty?
+
+          merge_columns(column_name.to_sym => options)
+        end
+        # alias_method :row, :column
+      end
+    end
+  end
+end

data/lib/csv_row_model/model/csv_string_model.rb

@@ -0,0 +1,16 @@
+module CsvRowModel
+  module Model
+    class CsvStringModel
+      include ActiveWarnings
+
+      def initialize(source)
+        @source = source.symbolize_keys
+      end
+
+      def method_missing(name, *args, &block)
+        return super unless @source.keys.include? name
+        @source[name]
+      end
+    end
+  end
+end

data/lib/csv_row_model/model/single_model.rb

@@ -0,0 +1,16 @@
+module CsvRowModel
+  module Model
+    module SingleModel
+      extend ActiveSupport::Concern
+
+      included do
+
+        class << self
+          alias_method :row_names, :column_names
+          alias_method :rows, :columns
+          alias_method :row, :column
+        end
+      end
+    end
+  end
+end