activerecord-bixformer 0.1.1 → 0.2.0

data/lib/activerecord-bixformer/generator/csv_row.rb

@@ -1,40 +0,0 @@
-module ActiveRecord
-  module Bixformer
-    module Generator
-      class CsvRow < ::ActiveRecord::Bixformer::Generator::Base
-        private
-
-        def association_generator
-          :new_as_association_for_export
-        end
-
-        def generate_model_value(model)
-          generate_attributes_value(model).merge(generate_association_value(model))
-        end
-
-        def generate_attributes_value(model)
-          model.generate_export_value_map.map do |attribute_name, attribute_value|
-            [model.csv_title(attribute_name), attribute_value]
-          end.to_h
-        end
-
-        def generate_association_value(parent_model)
-          parent_model.association_map.values.inject({}) do |association_value, model_or_models|
-            models = model_or_models.is_a?(::Array) ? model_or_models : [model_or_models]
-
-            # 全関連レコードの生成結果を単一ハッシュにマージ
-            association_value.merge(
-              models.inject({}) do |current_association_value, model|
-                # 関連レコードの全生成結果を単一ハッシュにマージ
-                current_association_value.merge(
-                  # キーをCSVカラム名に置き換えたハッシュを作成
-                  generate_model_value(model)
-                )
-              end
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/activerecord-bixformer/modeler/base.rb

@@ -1,160 +0,0 @@
-module ActiveRecord
-  module Bixformer
-    module Modeler
-      class Base
-        attr_reader :format
-
-        def initialize(format)
-          @format = format
-          @module_load_namespaces_of = {}
-          @module_constant_of = {}
-        end
-
-        def model_name
-        end
-
-        def entry_definition
-          {}
-        end
-
-        def optional_attributes
-          []
-        end
-
-        def required_attributes
-          []
-        end
-
-        def unique_indexes
-          []
-        end
-
-        def required_condition
-          {}
-        end
-
-        def default_values
-          {}
-        end
-
-        def translation_config
-          {
-            scope: :bixformer,
-            extend_scopes: []
-          }
-        end
-
-        def module_load_namespaces(module_type)
-          [
-            "::ActiveRecord::Bixformer::#{module_type.to_s.camelize}::#{format.to_s.camelize}",
-            "::ActiveRecord::Bixformer::#{module_type.to_s.camelize}",
-          ]
-        end
-
-        def config_value_for(model, config_name, default_value = nil)
-          model_names_without_root = (model.parents.map(&:name) + [model.name]).drop(1)
-
-          # 指定された設定の全設定値を取得
-          entire_config_value = __send__(config_name)
-
-          if entire_config_value.is_a?(::Hash)
-            # Hashなら、with_indifferent_accessしておく
-            entire_config_value = entire_config_value.with_indifferent_access
-          elsif entire_config_value.is_a?(::Array) && entire_config_value.last.is_a?(::Hash)
-            # Arrayで最後の要素がHashなら、with_indifferent_accessしておく
-            config_value = entire_config_value.pop
-
-            entire_config_value.push config_value.with_indifferent_access
-          end
-
-          # その中から、指定のmodelに対応する設定部分を抽出
-          config_value = if config_name == :entry_definition
-                           find_entry_definition(entire_config_value, model_names_without_root)
-                         else
-                           find_nested_config_value(entire_config_value, model_names_without_root)
-                         end
-
-          if config_value.is_a?(::Array)
-            # Arrayで最後の要素がHashの場合、それは子要素の設定値なので、結果に含めない
-            config_value.pop if config_value.last.is_a?(::Hash)
-
-            # Arrayなら、要素は文字列化しておく
-            config_value = config_value.map { |v| v.to_s }
-          end
-
-          config_value || default_value
-        end
-
-        def new_module_instance(module_type, name_or_instance, *initializers)
-          name_or_instance = :base unless name_or_instance
-
-          name_or_instance = name_or_instance.to_s if name_or_instance.is_a?(::Symbol)
-
-          return name_or_instance unless name_or_instance.is_a?(::String)
-
-          if initializers.size > 0
-            find_module_constant(module_type, name_or_instance).new(*initializers)
-          else
-            find_module_constant(module_type, name_or_instance).new
-          end
-        end
-
-        def find_module_constant(module_type, name)
-          name = :base unless name
-
-          module_constant = @module_constant_of["#{module_type}/#{name}"]
-
-          return module_constant if module_constant
-
-          namespaces = @module_load_namespaces_of[module_type] ||= module_load_namespaces(module_type)
-
-          namespaces.each do |namespace|
-            constant = "#{namespace}::#{name.to_s.camelize}".safe_constantize
-
-            return @module_constant_of["#{module_type}/#{name}"] = constant if constant
-          end
-
-          raise ::ArgumentError.new "Not found module named #{name.to_s.camelize} in module_load_namespaces('#{module_type}')"
-        end
-
-        def parse_to_type_and_options(value)
-          value = value.dup if value.is_a?(::Array) || value.is_a?(::Hash)
-          type  = value.is_a?(::Array) ? value.shift : value
-
-          arguments = if value.is_a?(::Array) && value.size == 1 && value.first.is_a?(::Hash)
-                        value.first
-                      elsif value.is_a?(::Array)
-                        value
-                      else
-                        nil
-                      end
-
-          [type, arguments]
-        end
-
-        private
-
-        def find_nested_config_value(config, keys)
-          return config ? config.dup : nil if keys.empty?
-
-          key = keys.shift
-
-          # config が Array なら、子要素は最後の要素にハッシュで定義してあるはず
-          config_map = config.is_a?(::Array) ? config.last : config
-
-          return nil unless config_map.is_a?(::Hash)
-
-          find_nested_config_value(config_map[key], keys)
-        end
-
-        def find_entry_definition(config, keys)
-          return config ? config.dup : nil if keys.empty?
-
-          key = keys.shift
-
-          find_entry_definition(config[:associations][key], keys)
-        end
-      end
-    end
-  end
-end

data/lib/activerecord-bixformer/modeler/csv.rb

@@ -1,11 +0,0 @@
-module ActiveRecord
-  module Bixformer
-    module Modeler
-      class Csv < ::ActiveRecord::Bixformer::Modeler::Base
-        def initialize
-          super(:csv)
-        end
-      end
-    end
-  end
-end

data/lib/activerecord-bixformer/runner/base.rb

@@ -1,47 +0,0 @@
-require 'active_record'
-
-module ActiveRecord
-  module Bixformer
-    module Runner
-      class Base
-        attr_reader :errors
-
-        def initialize(format)
-          @format   = format
-          @modelers = []
-          @errors   = []
-        end
-
-        def add_modeler(*modelers)
-          modelers.each do |modeler|
-            unless modeler.format.to_s == @format.to_s
-              raise ArgumentError.new "modeler format unmatches to #{@format} as runner format : #{modeler.format}"
-            end
-
-            @modelers.push modeler
-          end
-        end
-
-        private
-
-        def available_modelers
-          if @modelers.empty?
-            raise ArgumentError.new "Not exist any available modelers. You have to regist modeler by add_modeler."
-          end
-
-          @modelers
-        end
-
-        def active_modeler(force_detect = nil)
-          return @active_modeler if ! force_detect && @active_modeler
-
-          @active_modeler = detect_modeler
-        end
-
-        def detect_modeler
-          available_modelers.first
-        end
-      end
-    end
-  end
-end

data/lib/activerecord-bixformer/runner/csv.rb

@@ -1,123 +0,0 @@
-require 'csv'
-
-module ActiveRecord
-  module Bixformer
-    module Runner
-      class Csv < ::ActiveRecord::Bixformer::Runner::Base
-        def initialize
-          super(:csv)
-        end
-
-        def import(csv_data, options = {})
-          modeler        = active_modeler(true)
-          model_constant = modeler.model_name.to_s.camelize.constantize
-
-          @errors           = []
-          options[:headers] = true
-
-          model_attributes_list = parse_csv_rows(::CSV.parse(csv_data, options))
-
-          model_constant.transaction do
-            model_attributes_list.each.with_index(1) do |model_attributes, index|
-              next unless model_attributes&.present?
-
-              identified_value = model_attributes[model_constant.primary_key]
-
-              activerecord = if identified_value
-                               find_activerecord(model_constant, identified_value)
-                             else
-                               build_activerecord(model_constant, model_attributes)
-                             end
-
-              unless save_activerecord(activerecord, model_attributes)
-                @errors += make_error_messages(activerecord, index)
-              end
-            end
-
-            raise ::ActiveRecord::Rollback unless @errors.empty?
-          end
-
-          @errors.empty? ? true : false
-        end
-
-        def export(active_records_or_relation, options = {})
-          modeler    = active_modeler(true)
-          generator  = modeler.new_module_instance(:generator, :csv_row, modeler, active_records_or_relation.first)
-          csv_titles = make_csv_titles(generator)
-
-          ::CSV.generate(options) do |csv|
-            csv << csv_titles
-
-            active_records_or_relation.each do |activerecord|
-              generator = modeler.new_module_instance(:generator, :csv_row, modeler, activerecord)
-
-              csv << make_csv_row(generator, csv_titles)
-            end
-          end
-        end
-
-        private
-
-        def make_csv_titles(generator)
-          generator.compile.available_csv_titles
-        end
-
-        def make_csv_row(generator, csv_titles)
-          model_attributes = generator.generate
-
-          csv_titles.map { |title| model_attributes[title] }
-        end
-
-        def parse_csv_rows(csv_rows)
-          modeler = active_modeler
-
-          csv_rows.map do |csv_row|
-            generator = modeler.new_module_instance(:generator, :active_record, modeler, csv_row)
-
-            parse_csv_row(generator)
-          end
-        end
-
-        def parse_csv_row(generator)
-          generator.generate
-        end
-
-        def find_activerecord(model_class, id)
-          model_class.find(id)
-        end
-
-        def build_activerecord(model_class, attributes)
-          model_class.new(attributes)
-        end
-
-        def save_activerecord(activerecord, assigned_attributes)
-          # CSVで削除が可能だが、削除フラグは _destroy というattributesに入っており、こんなcolumnは存在しないので、このままだとエラーになる
-          # そのため、ここで要素から削除しておく
-          is_destroy = assigned_attributes.delete(:_destroy)
-
-          if activerecord.persisted?
-            if is_destroy
-              activerecord.destroy
-            else
-              activerecord.update(assigned_attributes)
-            end
-          else
-            activerecord.save
-          end
-        end
-
-        def make_error_messages(activerecord, csv_row_index)
-          activerecord.errors.full_messages.map do |msg|
-            I18n.t(
-              :"bixformer.csv.errors.format", {
-                default: "Entry(%{csv_row_index}): %{message}",
-                csv_row_index: csv_row_index,
-                message: msg
-              }
-            )
-          end
-        end
-      end
-    end
-  end
-end