csv_row_model 0.1.0

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "csv_row_model"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/csv_row_model.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'csv_row_model/version'
+
+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.summary       = "Import and export your custom CSVs with a intuitive shared Ruby interface."
+  spec.homepage      = "https://github.com/s12chung/csv_row_model"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel", "~> 4.2"
+  spec.add_dependency "active_warnings", ">= 0.1.2"
+end

data/lib/csv_row_model.rb

@@ -0,0 +1,46 @@
+autoload = false
+# autoload = true #uncomment for testing purposes only, not covered by rspec
+
+class Boolean; end unless defined? Boolean
+
+require 'active_model'
+require 'active_support/all'
+require 'active_warnings'
+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/validators/validate_attributes'
+
+  require 'csv_row_model/model'
+  require 'csv_row_model/model/single_model'
+
+  require 'csv_row_model/import'
+  require 'csv_row_model/import/single_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'
+end
+
+require 'csv_row_model/validators/default_change'
+
+require 'csv_row_model/validators/number_validator'
+require 'csv_row_model/validators/boolean_format'
+require 'csv_row_model/validators/date_format'
+require 'csv_row_model/validators/float_format'
+require 'csv_row_model/validators/integer_format'
+
+module CsvRowModel
+  class RowModelClassNotDefined < StandardError; end
+  class AccessedInvalidAttribute < StandardError; end
+end

data/lib/csv_row_model/concerns/deep_class_var.rb

@@ -0,0 +1,86 @@
+module CsvRowModel
+  module Concerns
+    module DeepClassVar
+      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
+        end
+
+        protected
+
+        # @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)
+          included_model_index = ancestors.index(included_module)
+          included_model_index == 0 ? [included_module] : ancestors[0..(included_model_index - 1)]
+        end
+
+        # @param accessor_method_name [Symbol] method to access the inherited_custom_class
+        # @param base_parent_class [Class] class that the custom class inherits from if there's no parent
+        # @return [Class] a custom class with the inheritance following self. for example:
+        #
+        # grandparent -> parent -> self
+        #
+        # grandparent has inherited_custom_class, but parent, doesn't.
+        #
+        # then: base_parent_class -> grandparent::inherited_custom_class -> self::inherited_custom_class
+        def inherited_custom_class(accessor_method_name, base_parent_class)
+          parent_class = inherited_ancestors[1..-1].find do |klass|
+            klass.respond_to?(accessor_method_name)
+          end.try(accessor_method_name)
+          parent_class ||= base_parent_class
+
+          klass = Class.new(parent_class)
+          # how else can i get the current scopes name...
+          klass.send(:define_singleton_method, :name, &eval("-> { \"#{name}#{base_parent_class.name.demodulize}\" }"))
+          klass
+        end
+
+        # @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
+        def deep_class_var(variable_name, default_value, merge_method)
+          deep_class_cache(variable_name) do
+            value = default_value
+
+            inherited_ancestors.each do |ancestor|
+              ancestor_value = ancestor.instance_variable_get(variable_name)
+              value = ancestor_value.public_send(merge_method, value) if ancestor_value.present?
+            end
+
+            value
+          end
+        end
+
+        # @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"
+        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)
+          ([self] + descendants).each do |descendant|
+            descendant.try(:clear_class_cache, variable_name)
+          end
+        end
+
+        # Memozies a deep_class_cache_variable_name
+        # @param variable_name [Symbol] variable_name to cache against
+        def deep_class_cache(variable_name)
+          #
+          # equal to: (has @)variable_name_deep_class_cache ||= Cache.new(klass, variable_name)
+          #
+          cache_variable_name = deep_class_cache_variable_name(variable_name)
+          instance_variable_get(cache_variable_name) || instance_variable_set(cache_variable_name, yield)
+        end
+      end
+    end
+  end
+end

data/lib/csv_row_model/concerns/inspect.rb

@@ -0,0 +1,10 @@
+module CsvRowModel
+  module Concerns
+    module Inspect
+      def inspect
+        s = self.class.send(:inspect_methods).map { |method| "#{method}=#{public_send(method).inspect}" }.join(", ")
+        "#<#{self.class.name}:#{object_id} #{s}>"
+      end
+    end
+  end
+end

data/lib/csv_row_model/engine.rb

@@ -0,0 +1,5 @@
+module CsvRowModel
+  class Engine < ::Rails::Engine
+    config.autoload_paths += %W[#{config.root}/lib/]
+  end
+end

data/lib/csv_row_model/export.rb

@@ -0,0 +1,70 @@
+module CsvRowModel
+  # Include this to with {Model} to have a RowModel for exporting to CSVs.
+  module Export
+    extend ActiveSupport::Concern
+
+    included do
+      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
+
+      validates :source_model, presence: true
+    end
+
+    # @param [Model] source_model object to export to CSV
+    # @param [Hash]  context
+    def initialize(source_model, context={})
+      @source_model = source_model
+      @context = context
+    end
+
+    def to_rows
+      [to_row]
+    end
+
+    # @return [Array] an array of public_send(column_name) of the CSV model
+    def to_row
+      attributes.values
+    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
+      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/csv.rb

@@ -0,0 +1,43 @@
+require 'csv'
+
+module CsvRowModel
+  module Export
+    class Csv
+      attr_reader :export_model_class, :csv, :file
+
+      # @param [Export] export_model export model class
+      def initialize(export_model_class)
+        @export_model_class = export_model_class
+        @file = Tempfile.new("#{export_model_class}.csv")
+      end
+
+      def header
+        export_model_class.column_headers
+      end
+
+      def append_header
+        csv << header
+      end
+
+      def append_model(model, context={})
+        export_model_class.new(model, context).to_rows.each do |row|
+          csv << row
+        end
+      end
+
+      def generate(with_header: true)
+        CSV.open(file.path,"wb") do |csv|
+          @csv = csv
+          append_header if with_header && !export_model_class.single_model?
+          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

@@ -0,0 +1,47 @@
+module CsvRowModel
+  module Export
+    module SingleModel
+      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|
+          result = []
+          row.each do |cell|
+            if 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]}"
+            else
+              result << cell.to_s
+            end
+          end
+          result
+        end
+      end
+
+      # Safe to override
+      #
+      # @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]}
+      end
+
+    end
+  end
+end

data/lib/csv_row_model/import.rb

@@ -0,0 +1,125 @@
+require 'csv_row_model/import/attributes'
+require 'csv_row_model/import/presenter'
+
+module CsvRowModel
+  # Include this to with {Model} to have a RowModel for importing csvs.
+  module Import
+    extend ActiveSupport::Concern
+
+    included do
+      include Concerns::Inspect
+      include Attributes
+
+      attr_reader :attr_reader, :source_header, :source_row, :context, :index, :previous
+
+      self.column_names.each { |*args| define_attribute_method(*args) }
+
+      validates :source_row, presence: true
+    end
+
+    # @param [Array] source_row 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 [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)
+
+      previous.try(:free_previous)
+      super(source_row, options)
+    end
+
+    # @return [Hash] a map of `column_name => source_row[index_of_column_name]`
+    def mapped_row
+      return {} unless source_row
+      @mapped_row ||= self.class.column_names.zip(source_row).to_h
+    end
+
+    # Free `previous` from memory to avoid making a linked list
+    def free_previous
+      @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)
+                                  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?
+    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
+    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
+
+      # @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