csv_row_model 0.1.0 → 0.1.1

data/csv_row_model.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = "csv_row_model"
   spec.version       = CsvRowModel::VERSION
   spec.authors       = ["Steve Chung"]
-  spec.email         = ["steve.chung7@gmail.com"]
+  spec.email         = ["hello@stevenchung.ca"]
 
   spec.summary       = "Import and export your custom CSVs with a intuitive shared Ruby interface."
   spec.homepage      = "https://github.com/s12chung/csv_row_model"

data/lib/csv_row_model.rb

@@ -3,6 +3,8 @@ autoload = false
 
 class Boolean; end unless defined? Boolean
 
+require 'csv_row_model/version'
+
 require 'active_model'
 require 'active_support/all'
 require 'active_warnings'
@@ -11,25 +13,23 @@ require 'csv'
 if autoload && defined?(Rails)
   require 'csv_row_model/engine'
 else
-  require 'csv_row_model/version'
-
   require 'csv_row_model/concerns/inspect'
-  require 'csv_row_model/concerns/deep_class_var'
+  require 'csv_row_model/concerns/inherited_class_var'
 
   require 'csv_row_model/validators/validate_attributes'
 
   require 'csv_row_model/model'
-  require 'csv_row_model/model/single_model'
+  require 'csv_row_model/model/file_model'
 
   require 'csv_row_model/import'
-  require 'csv_row_model/import/single_model'
+  require 'csv_row_model/import/file_model'
   require 'csv_row_model/import/csv'
   require 'csv_row_model/import/file'
 
 
   require 'csv_row_model/export'
-  require 'csv_row_model/export/csv'
-  require 'csv_row_model/export/single_model'
+  require 'csv_row_model/export/file'
+  require 'csv_row_model/export/file_model'
 end
 
 require 'csv_row_model/validators/default_change'

data/lib/csv_row_model/concerns/{deep_class_var.rb → inherited_class_var.rb}

@@ -1,13 +1,13 @@
 module CsvRowModel
   module Concerns
-    module DeepClassVar
+    module InheritedClassVar
       extend ActiveSupport::Concern
 
       class_methods do
         # Clears the cache for a variable
         # @param variable_name [Symbol] variable_name to cache against
         def clear_class_cache(variable_name)
-          instance_variable_set deep_class_cache_variable_name(variable_name), nil
+          instance_variable_set inherited_class_variable_name(variable_name), nil
         end
 
         protected
@@ -44,8 +44,8 @@ module CsvRowModel
         # @param default_value [Object] default value of the class variable
         # @param merge_method [Symbol] method to merge values of the class variable
         # @return [Object] a class variable merged across ancestors until deep_class_module
-        def deep_class_var(variable_name, default_value, merge_method)
-          deep_class_cache(variable_name) do
+        def inherited_class_var(variable_name, default_value, merge_method)
+          class_cache(variable_name) do
             value = default_value
 
             inherited_ancestors.each do |ancestor|
@@ -59,25 +59,25 @@ module CsvRowModel
 
         # @param variable_name [Symbol] variable_name to cache against
         # @return [String] the cache variable name for the cache
-        def deep_class_cache_variable_name(variable_name)
-          "#{variable_name}_deep_class_cache"
+        def inherited_class_variable_name(variable_name)
+          "#{variable_name}_inherited_class_cache"
         end
 
         # Clears the cache for a variable and the same variable for all it's dependant descendants
         # @param variable_name [Symbol] variable_name to cache against
-        def clear_deep_class_cache(variable_name)
+        def deep_clear_class_cache(variable_name)
           ([self] + descendants).each do |descendant|
             descendant.try(:clear_class_cache, variable_name)
           end
         end
 
-        # Memozies a deep_class_cache_variable_name
+        # Memozies a inherited_class_variable_name
         # @param variable_name [Symbol] variable_name to cache against
-        def deep_class_cache(variable_name)
+        def class_cache(variable_name)
           #
-          # equal to: (has @)variable_name_deep_class_cache ||= Cache.new(klass, variable_name)
+          # equal to: (has @)inherited_class_variable_name ||= yield
           #
-          cache_variable_name = deep_class_cache_variable_name(variable_name)
+          cache_variable_name = inherited_class_variable_name(variable_name)
           instance_variable_get(cache_variable_name) || instance_variable_set(cache_variable_name, yield)
         end
       end

data/lib/csv_row_model/export.rb

@@ -24,7 +24,7 @@ module CsvRowModel
     # @param [Hash]  context
     def initialize(source_model, context={})
       @source_model = source_model
-      @context = context
+      @context = OpenStruct.new(context)
     end
 
     def to_rows
@@ -37,34 +37,9 @@ module CsvRowModel
     end
 
     class_methods do
-
-      # @return [Array] column headers for the row model
-      def column_headers
-        @column_headers ||= begin
-          columns.map do |name, options|
-            options[:header] || format_header(name)
-          end
-        end
-      end
-
-      # Safe to override
-      #
-      # @return [String] formatted header
-      def format_header(column_name)
-        column_name
-      end
-
-
-      # @return [Boolean] by default false
-      def single_model?
-        false
+      def setup(csv, with_headers: true)
+        csv << headers if with_headers
       end
     end
-
-    private
-
-    def is_column_name? column_name
-      column_name.is_a?(Symbol) && self.class.index(column_name)
-    end
   end
 end

data/lib/csv_row_model/export/file.rb

@@ -0,0 +1,49 @@
+module CsvRowModel
+  module Export
+    class File
+      attr_reader :export_model_class, :csv, :file, :context
+
+      # @param [Export] export_model export model class
+      def initialize(export_model_class, context={})
+        @export_model_class = export_model_class
+        @context = context.to_h.symbolize_keys
+      end
+
+      def headers
+        export_model_class.headers
+      end
+
+      # Add a row_model to the
+      # @param [] source_model the source model of the export row model
+      # @param [Hash] context the extra context given to the instance of the row model
+      def append_model(source_model, context={})
+        export_model_class.new(source_model, context.to_h.reverse_merge(self.context)).to_rows.each do |row|
+          csv << row
+        end
+      end
+      alias_method :<<, :append_model
+
+      # @return [Boolean] true, if a csv file is generated
+      def generated?
+        !!file
+      end
+
+      # 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"])
+        CSV.open(file.path, "wb") do |csv|
+          @csv = csv
+          export_model_class.setup(csv, with_headers: with_headers)
+          yield self
+        end
+      ensure
+        @csv = nil
+      end
+
+      def to_s
+        file.read
+      end
+    end
+  end
+end

data/lib/csv_row_model/export/{single_model.rb → file_model.rb}

@@ -1,27 +1,15 @@
 module CsvRowModel
   module Export
-    module SingleModel
+    module FileModel
       extend ActiveSupport::Concern
 
-      included do
-
-        alias_method :is_row_name?, :is_column_name?
-
-        class << self
-          # @return [Boolean] by default false
-          def single_model?
-            true
-          end
-        end
-      end
-
       # @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_temaplate.map do |row|
+        rows_template.map do |row|
           result = []
           row.each do |cell|
-            if is_row_name? cell
+            if self.class.is_row_name? cell
               header_matchs = self.class.options(cell)[:header_matchs]
               result << "#{header_matchs ? header_matchs.first : self.class.format_header(cell)}"
               result << "#{attributes[cell]}"
@@ -38,10 +26,13 @@ module CsvRowModel
       # @return [Array<Array>] an array of arrays, where every represents a row and every row
       #                        can have strings and row_name (column_name). By default,
       #                        returns a row_name for every row
-      def rows_temaplate
-        @rows_temaplate ||= self.class.row_names.map{ |row_name| [row_name]}
+      def rows_template
+        @rows_template ||= self.class.row_names.map{ |row_name| [row_name]}
       end
 
+      class_methods do
+        def setup(csv, with_headers: true); end
+      end
     end
   end
 end

data/lib/csv_row_model/import.rb

@@ -95,17 +95,31 @@ module CsvRowModel
     end
 
     class_methods do
-      # by default import model is a collection model
-      def type
-        :collection_model
-      end
-
       # See {Model#column}
       def column(column_name, options={})
         super
         define_attribute_method(column_name)
       end
 
+      # @param [Import::Csv] csv 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, context={}, previous=nil)
+        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, context: context, previous: previous)
+
+          return row_model if csv.end_of_file?
+
+          next_row_is_parent = !row_model.append_child(csv.next_row)
+          return row_model if next_row_is_parent
+        end
+      end
+
       # @return [Class] the Class of the Presenter
       def presenter_class
         @presenter_class ||= inherited_custom_class(:presenter_class, Presenter)

data/lib/csv_row_model/import/attributes.rb

@@ -20,28 +20,29 @@ module CsvRowModel
 
       # @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
+        self.class.column_names.each { |column_name| original_attribute(column_name) }
+        @original_attributes
       end
 
       # @return [Object] the column's attribute before override
       def original_attribute(column_name)
+        @original_attributes ||= {}
         @default_changes ||= {}
 
+        return @original_attributes[column_name] if @original_attributes.has_key? 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))
         if value.present?
-          instance_exec(value, &self.class.parse_lambda(column_name))
+          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]
-          value
         end
+        @original_attributes[column_name] = value
       end
 
       # return [Hash] a map changes from {.column}'s default option': `column_name -> [value_before_default, default_set]`

data/lib/csv_row_model/import/file.rb

@@ -3,30 +3,33 @@ require 'csv_row_model/import/file/validations'
 
 module CsvRowModel
   module Import
-    # Represents a csv file and handles parsing to return `Import` or `Mapper`
+    # Represents a csv file and handles parsing to return `Import`
     class File
       include Callbacks
       include Validations
 
       # @return [Csv]
       attr_reader :csv
-      # @return [Input,Mapper] model class returned for importing
+      # @return [Input] 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}
+      # @return [Input] the current row model set by {#next}
       attr_reader :current_row_model
-      # @return [Input, Mapper] the previous row model set by {#next}
+      # @return [Input] the previous row model set by {#next}
       attr_reader :previous_row_model
+      # @return [Hash] context passed to the {Import}
+      attr_reader :context
 
-      delegate :header, :size, :skipped_rows, to: :csv
+      delegate :header, :size, :skipped_rows, :end_of_file?, 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
+      # @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
         reset
       end
 
@@ -38,96 +41,35 @@ module CsvRowModel
       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)
+        return if end_of_file?
+
+        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, context, previous_row_model)
+          @index += 1
+          @current_row_model = @index = nil if end_of_file?
         end
-      end
 
-      # @return [Boolean] returns true, if the object is at the end of file
-      def end_of_file?
-        csv.end_of_file?
+        current_row_model
       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 to_enum(__callee__) unless block_given?
         return false if _abort?
 
         while self.next(context)
-          return false if _abort?
-          next if _skip?
+          run_callbacks :each_iteration do
+            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