csv_row_model 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5498738789715db182f898e6d048cf27368bc5b9
-  data.tar.gz: f70ad9d361f804afd025e3c5214dc63c2734f603
+  metadata.gz: 1875456398a0d03c7704e622ef2fb992c628d436
+  data.tar.gz: 8da58e2819b99eb9be2caa92e319ec505fa7f6b5
 SHA512:
-  metadata.gz: 60d6189fe5d90a7efb8e5630080f8b2d259fcef21beab143d54781b695c512b567c5f1bef27d11a329de9ba83145a03e5684208d7dde30c55639b09c1bbb55b6
-  data.tar.gz: 266ba89a88b2df74e1fa75f33bd9651fb27bb012d5707ac41567fbcbc3cded3cd97e4536d45170c1140ddef0ea9bd35ad2a4d1d05f15e83f22c0d4abf8f4620c
+  metadata.gz: be79b067b838f8541dc176f82ba86dab9d4719354d8c500ed93f50bafc14e0eeeb9564e528c85fa619116d1b2274de0c217d7ab4ae81d2e6a9549f3eea3ead6c
+  data.tar.gz: 09c668f2d08663000b284c91d1b1c77fea8109fc84b392143035fb39f9cca3f9ed6707084a8d0b3308d133384dfa7fc3fc517dc39d928b77f03d727599b2fccc

data/README.md

@@ -124,7 +124,7 @@ def original_attribute(column_name)
   value = mapped_row[column_name]
 
   # 2. Clean or format each cell
-  value = self.class.format_cell(value)
+  value = self.class.format_cell(cell, column_name, column_index)
 
   if value.present?
     # 3a. Parse the cell value (which does nothing if no parsing is specified)
@@ -428,4 +428,82 @@ class ImportFile < CsvRowModel::Import::File
     ...
   end
 end
+```
+
+## Dynamic columns
+Dynamic columns are columns that can expand to many columns. Currently, we can only one dynamic column after all other standard columns.
+The following:
+
+```ruby
+class DynamicColumnModel
+  include CsvRowModel::Model
+
+  column :first_name
+  column :last_name
+  dynamic_column :skills
+end
+```
+
+represents this table:
+
+| first_name | last_name  | skill1 | skill2 |
+| ---------- |----------- | ------ | ------ |
+| John       | Doe        |   No   |   Yes  |
+| Mario      | Super      |   Yes  |   No   |
+| Mike       | Jackson    |   Yes  |   Yes  |
+
+
+### Export
+Dynamic column attributes are arrays, but each item in the array is defined via singular attribute method like
+normal columns:
+
+```ruby
+class DynamicColumnExportModel < DynamicColumnModel
+  include CsvRowModel::Export
+
+  def skill(skill_name)
+    # below is an override, this is the default implementation: skill_name # => "skill1", then "skill2"
+    source_model.skills.include?(skill_name) ? "Yes" : "No"
+  end
+
+  class << self
+    # this is an override with the default implementation
+    def skill_header(skill_name)
+      skill_name
+    end
+  end
+end
+
+# the `skills` context is mapped to generate an array
+export_file = CsvRowModel::Export::File.new(DynamicColumnExportModel, { skills: Skill.all  })
+export_file.generate do |csv|
+  User.all.each { |user| csv << user }
+end
+```
+
+### Import
+Like Export above, each item of the array is defined via singular attribute method like
+normal columns:
+
+```ruby
+class DynamicColumnImportModel < DynamicColumnModel
+  include CsvRowModel::Import
+
+  # this is an override with the default implementation (override highly recommended)
+  def skill(value, skill_name)
+    value
+  end
+
+  class << self
+    # Clean/format every dynamic_column attribute array
+    #
+    # this is an override with the default implementation
+    def format_dynamic_column_cells(cells, column_name)
+      cells
+    end
+  end
+end
+row_model = CsvRowModel::Import::File.new(file_path, DynamicColumnImportModel).next
+row_model.attributes # => { first_name: "John", last_name: "Doe", skills: ['No', 'Yes'] }
+row_model.skills # => ['No', 'Yes']
 ```

data/lib/csv_row_model/concerns/inherited_class_var.rb

@@ -14,7 +14,7 @@ module CsvRowModel
 
         # @param included_module [Module] module to search for
         # @return [Array<Module>] inherited_ancestors of included_module (including self)
-        def inherited_ancestors(included_module=deep_class_module)
+        def inherited_ancestors(included_module=inherited_class_module)
           included_model_index = ancestors.index(included_module)
           included_model_index == 0 ? [included_module] : ancestors[0..(included_model_index - 1)]
         end
@@ -43,7 +43,7 @@ module CsvRowModel
         # @param variable_name [Symbol] class variable name (recommend :@_variable_name)
         # @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
+        # @return [Object] a class variable merged across ancestors until inherited_class_module
         def inherited_class_var(variable_name, default_value, merge_method)
           class_cache(variable_name) do
             value = default_value

data/lib/csv_row_model/export.rb

@@ -1,21 +1,15 @@
+require 'csv_row_model/export/dynamic_columns'
+
 module CsvRowModel
   # Include this to with {Model} to have a RowModel for exporting to CSVs.
   module Export
     extend ActiveSupport::Concern
 
     included do
+      include DynamicColumns
       attr_reader :source_model, :context
 
-      self.column_names.each do |column_name|
-
-        # Safe to override
-        #
-        #
-        # @return [String] a string of public_send(column_name) of the CSV model
-        define_method(column_name) do
-          source_model.public_send(column_name)
-        end
-      end
+      self.column_names.each { |*args| define_attribute_method(*args) }
 
       validates :source_model, presence: true
     end
@@ -24,7 +18,7 @@ module CsvRowModel
     # @param [Hash]  context
     def initialize(source_model, context={})
       @source_model = source_model
-      @context = OpenStruct.new(context)
+      @context      = OpenStruct.new(context)
     end
 
     def to_rows
@@ -37,8 +31,29 @@ module CsvRowModel
     end
 
     class_methods do
-      def setup(csv, with_headers: true)
-        csv << headers if with_headers
+      def setup(csv, context={}, with_headers: true)
+        csv << headers(context) if with_headers
+      end
+
+      # See {Model#column}
+      def column(column_name, options={})
+        super
+        define_attribute_method(column_name)
+      end
+
+      # Define default attribute method for a column
+      # @param column_name [Symbol] the cell's column_name
+      def define_attribute_method(column_name)
+        define_method(column_name) do
+          self.class.format_cell(source_model.public_send(column_name), column_name, self.class.index(column_name))
+        end
+      end
+
+      # Safe to override. Method applied to each cell by default
+      #
+      # @param cell [Object] the cell's value
+      def format_cell(cell, column_name, column_index)
+        cell
       end
     end
   end

data/lib/csv_row_model/export/dynamic_columns.rb

@@ -0,0 +1,42 @@
+module CsvRowModel
+  module Export
+    module DynamicColumns
+      extend ActiveSupport::Concern
+
+      included do
+        self.dynamic_column_names.each { |*args| define_dynamic_attribute_method(*args) }
+      end
+
+      # @return [Array] an array of public_send(column_name) of the CSV model
+      def to_row
+        super.flatten
+      end
+
+      class_methods do
+        protected
+
+        # See {Model::DynamicColumns#dynamic_column}
+        def dynamic_column(column_name, options={})
+          super
+          define_dynamic_attribute_method(column_name)
+        end
+
+        # Define default attribute method for a dynamic_column
+        # @param column_name [Symbol] the cell's column_name
+        def define_dynamic_attribute_method(column_name)
+          define_method(column_name) do
+            context.public_send(column_name).map do |header_model|
+              self.class.format_cell(
+                public_send(self.class.singular_dynamic_attribute_method_name(column_name), header_model),
+                column_name,
+                self.class.dynamic_index(column_name)
+              )
+            end
+          end
+
+          define_method(singular_dynamic_attribute_method_name(column_name)) { |header_model| header_model }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/export/file.rb

@@ -34,7 +34,7 @@ module CsvRowModel
         @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)
+          export_model_class.setup(csv, context, with_headers: with_headers)
           yield self
         end
       ensure

data/lib/csv_row_model/export/file_model.rb

@@ -31,7 +31,7 @@ module CsvRowModel
       end
 
       class_methods do
-        def setup(csv, with_headers: true); end
+        def setup(csv, context, with_headers: true); end
       end
     end
   end

data/lib/csv_row_model/import.rb

@@ -1,5 +1,6 @@
 require 'csv_row_model/import/attributes'
 require 'csv_row_model/import/presenter'
+require 'csv_row_model/import/dynamic_columns'
 
 module CsvRowModel
   # Include this to with {Model} to have a RowModel for importing csvs.
@@ -9,6 +10,7 @@ module CsvRowModel
     included do
       include Concerns::Inspect
       include Attributes
+      include DynamicColumns
 
       attr_reader :attr_reader, :source_header, :source_row, :context, :index, :previous
 
@@ -54,12 +56,15 @@ module CsvRowModel
       @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)
-                                  end).to_h
+          hash = column_names.zip(
+            column_names.map.with_index do |column_name, index|
+              self.class.format_cell(source_row[index], column_name, index)
+            end
+          ).to_h
         else
           hash = {}
         end
+
         self.class.csv_string_model_class.new(hash)
       end
     end
@@ -88,7 +93,7 @@ module CsvRowModel
       end
 
       if using_warnings?
-        csv_string_model.using_warnings &proc
+        csv_string_model.using_warnings(&proc)
       else
         proc.call
       end
@@ -105,13 +110,17 @@ module CsvRowModel
       # @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)
+      def next(csv, source_header, 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)
+          row_model ||= new(csv.current_row,
+                            index: csv.index,
+                            source_header: source_header,
+                            context: context,
+                            previous: previous)
 
           return row_model if csv.end_of_file?
 
@@ -132,7 +141,7 @@ module CsvRowModel
 
       # Call to define the presenter
       def presenter(&block)
-        presenter_class.class_eval &block
+        presenter_class.class_eval(&block)
       end
     end
   end

data/lib/csv_row_model/import/attributes.rb

@@ -26,10 +26,7 @@ module CsvRowModel
 
       # @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
+        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?
@@ -51,6 +48,13 @@ module CsvRowModel
         @default_changes
       end
 
+      protected
+      def original_attribute_memoized?(column_name)
+        @original_attributes ||= {}
+        @default_changes     ||= {}
+        @original_attributes.has_key? column_name
+      end
+
       class_methods do
         # Safe to override. Method applied to each cell by default
         #
@@ -103,4 +107,4 @@ module CsvRowModel
       end
     end
   end
-end
+end

data/lib/csv_row_model/import/dynamic_columns.rb

@@ -0,0 +1,71 @@
+module CsvRowModel
+  module Import
+    module DynamicColumns
+      extend ActiveSupport::Concern
+
+      included do
+        self.dynamic_column_names.each { |*args| define_dynamic_attribute_method(*args) }
+      end
+
+      # @return [Array] dynamic_column headers
+      def dynamic_source_headers
+        source_header[self.class.columns.size..-1]
+      end
+
+      # @return [Array] dynamic_column row data
+      def dynamic_source_row
+        source_row[self.class.columns.size..-1]
+      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
+      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)
+          )
+          public_send(self.class.singular_dynamic_attribute_method_name(column_name), value, source_header)
+        end
+
+        @original_attributes[column_name] = self.class.format_dynamic_column_cells(values, column_name)
+      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
+
+        protected
+
+        # See {Model#dynamic_column}
+        def dynamic_column(column_name, options={})
+          super
+          define_dynamic_attribute_method(column_name)
+        end
+
+        # Define default attribute method for a column
+        # @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 }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/import/file.rb

@@ -47,7 +47,7 @@ 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, context, previous_row_model)
+          @current_row_model = row_model_class.next(csv, header, context, previous_row_model)
           @index += 1
           @current_row_model = @index = nil if end_of_file?
         end

data/lib/csv_row_model/import/file_model.rb

@@ -28,7 +28,7 @@ module CsvRowModel
           end
         end
 
-        def next(csv, context={}, previous=nil)
+        def next(csv, source_header, context={}, previous=nil)
           return csv.read_row unless csv.next_row
 
           source_row = Array.new(header_matchers.size)
@@ -44,7 +44,7 @@ module CsvRowModel
             end
           end
 
-          new(source_row, context: context, previous: previous)
+          new(source_row, source_header: source_header, context: context, previous: previous)
         end
       end
     end

data/lib/csv_row_model/import/presenter.rb

@@ -63,10 +63,16 @@ module CsvRowModel
         errors.messages.reverse_merge!(row_model.errors.messages)
       end
 
+      # @param [Array] Array of column_names to check
+      # @return [Boolean] if column_names are valid
+      def row_model_valid?(*column_names)
+        row_model.valid? || (row_model.errors.keys & column_names).empty?
+      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?
+        row_model_valid?(*self.class.options(attribute_name)[:dependencies])
       end
 
       # equal to: @method_name ||= yield
@@ -78,7 +84,7 @@ module CsvRowModel
       end
 
       class << self
-        def deep_class_module
+        def inherited_class_module
           Presenter
         end
 
@@ -163,4 +169,4 @@ module CsvRowModel
       end
     end
   end
-end
+end

data/lib/csv_row_model/model.rb

@@ -2,6 +2,7 @@ require 'csv_row_model/model/csv_string_model'
 
 require 'csv_row_model/model/columns'
 require 'csv_row_model/model/children'
+require 'csv_row_model/model/dynamic_columns'
 
 module CsvRowModel
   # Base module for representing a RowModel---a model that represents row(s).
@@ -16,6 +17,7 @@ module CsvRowModel
 
       include Columns
       include Children
+      include DynamicColumns
 
       # @return [Model] return the parent, if this instance is a child
       attr_reader :parent
@@ -57,10 +59,10 @@ module CsvRowModel
       protected
       # Called to add validations to the csv_string_model_class
       def csv_string_model(&block)
-        csv_string_model_class.class_eval &block
+        csv_string_model_class.class_eval(&block)
       end
 
-      def deep_class_module
+      def inherited_class_module
         Model
       end
     end

data/lib/csv_row_model/model/columns.rb

@@ -5,15 +5,24 @@ module CsvRowModel
 
       # @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
+        attributes_from_column_names self.class.column_names
       end
 
       def to_json
         attributes.to_json
       end
 
+      def headers
+        self.class.headers(context)
+      end
+
+      protected
+      def attributes_from_column_names(column_names)
+        column_names
+          .zip(column_names.map { |column_name| public_send(column_name) })
+          .to_h
+      end
+
       class_methods do
         # @return [Array<Symbol>] column names for the row model
         def column_names
@@ -43,14 +52,10 @@ module CsvRowModel
           column_name.is_a?(Symbol) && index(column_name)
         end
 
-
+        # @param [Hash, OpenStruct] context name of column to check
         # @return [Array] column headers for the row model
-        def headers
-          @headers ||= begin
-            columns.map do |name, options|
-              options[:header] || format_header(name)
-            end
-          end
+        def headers(context={})
+          @headers ||= columns.map { |name, options| options[:header] || format_header(name) }
         end
 
         # Safe to override
@@ -93,4 +98,4 @@ module CsvRowModel
       end
     end
   end
-end
+end

data/lib/csv_row_model/model/dynamic_columns.rb

@@ -0,0 +1,74 @@
+module CsvRowModel
+  module Model
+    module DynamicColumns
+      extend ActiveSupport::Concern
+
+      # See Model::Columns#attributes
+      def attributes
+        super.merge(attributes_from_column_names(self.class.dynamic_column_names))
+      end
+
+      class_methods do
+        # See Model::Columns::headers
+        def headers(context={})
+          @headers ||= super + dynamic_column_names.map do |column_name|
+            OpenStruct.new(context).public_send(column_name).each do |header_model|
+              public_send(header_method_name(column_name), header_model)
+            end
+          end.flatten
+        end
+
+        # @return [Integer] index of dynamic_column of all columns
+        def dynamic_index(column_name)
+          offset = dynamic_column_names.index(column_name)
+          offset ? columns.size + offset : nil
+        end
+
+        # @return [Array<Symbol>] column names for the row model
+        def dynamic_column_names
+          dynamic_columns.keys
+        end
+
+        # @return [Hash] column names mapped to their options
+        def dynamic_columns
+          inherited_class_var(:@_dynamic_columns, {}, :merge)
+        end
+
+        def header_method_name(column_name)
+          "#{column_name.to_s.singularize}_header"
+        end
+        def singular_dynamic_attribute_method_name(column_name)
+          column_name.to_s.singularize
+        end
+
+        protected
+
+        def merge_dynamic_columns(column_hash)
+          @_dynamic_columns ||= {}
+          deep_clear_class_cache(:@_dynamic_columns)
+          @_dynamic_columns.merge!(column_hash)
+        end
+
+        VALID_OPTIONS_KEYS = [].freeze
+
+        # define a dynamic_column, must be after all normal columns
+        #
+        # options to be implemented later
+        #
+        # @param column_name [Symbol] 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?
+
+          define_header_method(column_name)
+
+          merge_dynamic_columns(column_name.to_sym => options)
+        end
+
+        def define_header_method(column_name)
+          define_singleton_method(header_method_name(column_name)) { |header_model| header_model }
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/version.rb

@@ -1,3 +1,3 @@
 module CsvRowModel
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv_row_model
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Steve Chung
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-20 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -64,12 +64,14 @@ files:
 - lib/csv_row_model/concerns/inspect.rb
 - lib/csv_row_model/engine.rb
 - lib/csv_row_model/export.rb
+- lib/csv_row_model/export/dynamic_columns.rb
 - lib/csv_row_model/export/file.rb
 - lib/csv_row_model/export/file_model.rb
 - lib/csv_row_model/import.rb
 - lib/csv_row_model/import/attributes.rb
 - lib/csv_row_model/import/csv.rb
 - lib/csv_row_model/import/csv/row.rb
+- lib/csv_row_model/import/dynamic_columns.rb
 - lib/csv_row_model/import/file.rb
 - lib/csv_row_model/import/file/callbacks.rb
 - lib/csv_row_model/import/file/validations.rb
@@ -79,6 +81,7 @@ files:
 - lib/csv_row_model/model/children.rb
 - lib/csv_row_model/model/columns.rb
 - lib/csv_row_model/model/csv_string_model.rb
+- lib/csv_row_model/model/dynamic_columns.rb
 - lib/csv_row_model/model/file_model.rb
 - lib/csv_row_model/validators/boolean_format.rb
 - lib/csv_row_model/validators/date_format.rb
@@ -108,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Import and export your custom CSVs with a intuitive shared Ruby interface.