activerecord-bixformer 0.1.0

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

@@ -0,0 +1,170 @@
+module ActiveRecord
+  module Bixformer
+    module Generator
+      class ActiveRecord < ::ActiveRecord::Bixformer::Generator::Base
+        private
+
+        def association_generator
+          :new_as_association_for_import
+        end
+
+        def generate_model_value(model)
+          generate_attributes_value(model).merge(generate_association_value(model))
+        end
+
+        def generate_attributes_value(model)
+          attribute_value_map    = model.generate_import_value_map
+          required_attributes    = @modeler.config_value_for(model, :required_attributes, [])
+          identified_column_name = identified_column_name_of(model)
+
+          # 必須な属性が渡されていない場合には、取り込みしない
+          return {} if required_attributes.any? { |attribute_name| ! presence_value?(attribute_value_map[attribute_name]) }
+
+          set_required_condition(model, attribute_value_map)
+          set_parent_key(model, attribute_value_map, identified_column_name)
+          set_activerecord_id(model, attribute_value_map, identified_column_name)
+
+          # 空でない要素が無いなら、空ハッシュで返す
+          presence_value?(attribute_value_map) ? attribute_value_map : {}
+        end
+
+        def generate_association_value(parent_model)
+          association_value_map = {}.with_indifferent_access
+
+          parent_model.association_map.each do |association_name, model_or_models|
+            association_value = if model_or_models.is_a?(::Array)
+                                  model_or_models.map { |m| generate_model_value(m) }.reject { |v| ! presence_value?(v) }
+                                else
+                                  generate_model_value(model_or_models)
+                                end
+
+            # 取り込み時は、オプショナルな関連では、空と思われる値は取り込まない
+            next if ! presence_value?(association_value) &&
+                    parent_model.optional_attributes.include?(association_name.to_s)
+
+            association_value_map["#{association_name}_attributes".to_sym] = association_value
+          end
+
+          association_value_map
+        end
+
+        def set_required_condition(model, attribute_value_map)
+          # 結果ハッシュが空なら、取り込みしないように追加はしない
+          return unless presence_value?(attribute_value_map)
+
+          # 設定するのはルートの場合のみ
+          return if model.parent
+
+          attribute_value_map.merge!(@modeler.required_condition)
+        end
+
+        def set_parent_key(model, attribute_value_map, identified_column_name)
+          # 結果ハッシュが空なら、取り込みしないように追加はしない
+          return unless presence_value?(attribute_value_map)
+
+          # 設定するのは親がいる場合のみ
+          return unless model.parent
+
+          parent_id = model.parent&.activerecord_id
+
+          if parent_id
+            # 親のレコードが見つかっているなら、それも結果ハッシュに追加する
+            attribute_value_map[model.parent_foreign_key] = parent_id
+          else
+            # 見つかっていないなら、間違った値が指定されている可能性があるので、キー自体を削除
+            attribute_value_map.delete(model.parent_foreign_key)
+          end
+        end
+
+        def set_activerecord_id(model, attribute_value_map, identified_column_name)
+          # 更新の場合は、インポートデータを元にデータベースから対象のレコードを検索してIDを取得
+          model.activerecord_id = verified_activerecord_id(model, attribute_value_map, identified_column_name)
+
+          if model.activerecord_id
+            # 更新なら、ID属性を改めて設定
+            attribute_value_map[identified_column_name] = model.activerecord_id
+          else
+            # 見つかっていないなら、間違った値が指定されている可能性があるので、キー自体を削除
+            attribute_value_map.delete(identified_column_name)
+          end
+        end
+
+        def verified_activerecord_id(model, attribute_value_map, identified_column_name)
+          # 更新対象のレコードを特定できるかチェック
+          identified_value = attribute_value_map[identified_column_name]
+
+          uniqueness_condition = if identified_value
+                                   { identified_column_name => identified_value }
+                                 else
+                                   find_unique_condition(model, attribute_value_map, identified_column_name)
+                                 end
+
+          # レコードが特定できないなら、更新処理ではないので終了
+          return nil unless uniqueness_condition
+
+          # 更新対象のレコードを正しく特定できているか確認するための検証条件を取得
+          required_condition = if model.parent
+                                 key = model.parent_foreign_key
+
+                                 { key => attribute_value_map[key] }
+                               else
+                                 @modeler.required_condition
+                               end
+
+          # 検証条件は、必ず値がなければならない
+          return nil if required_condition.any? { |_k, v| ! presence_value?(v) }
+
+          # インポートされてきた、レコードを特定する条件が、誤った値でないかどうかを、
+          # 特定されるレコードが、更新すべき正しいレコードであるかチェックするための
+          # 検証条件とマージして、データベースに登録されているか確認する
+          verified_condition = uniqueness_condition.merge(required_condition)
+
+          find_verified_activerecord_by!(model.activerecord_constant, verified_condition).__send__(identified_column_name)
+        rescue ::ActiveRecord::RecordNotFound => e
+          # ID属性が指定されているのに、データベースに見つからない場合はエラーにする
+          raise e if identified_value
+        end
+
+        def find_unique_condition(model, attribute_value_map, identified_column_name)
+          unique_indexes = @modeler.config_value_for(model, :unique_indexes, [])
+
+          # ユニーク条件が指定されていないなら終了
+          return nil if unique_indexes.empty?
+
+          unique_condition = unique_indexes.map do |key|
+            [key, attribute_value_map[key]]
+          end.to_h
+
+          # ユニーク条件は、必ず値がなければならない
+          return nil if unique_condition.any? { |_k, v| ! presence_value?(v) }
+
+          unique_condition
+        end
+
+        def find_verified_activerecord_by!(klass, verified_uniqueness_condition)
+          klass.find_by!(verified_uniqueness_condition)
+        end
+
+        def identified_column_name_of(model)
+          model.activerecord_constant.primary_key
+        end
+
+        def presence_value?(value)
+          # 空でない要素であるか or 空でない要素を含んでいるかどうか
+          case value
+          when ::Hash
+            value.values.any? { |v| presence_value?(v) }
+          when ::Array
+            value.any? { |v| presence_value?(v) }
+          when ::String
+            ! value.blank?
+          when ::TrueClass, ::FalseClass
+            true
+          else
+            value ? true : false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module ActiveRecord
+  module Bixformer
+    module Generator
+      class Base
+        attr_reader :data_source
+
+        def initialize(modeler, data_source)
+          @modeler     = modeler
+          @data_source = data_source
+        end
+
+        def compile
+          return @model if @model
+
+          model_name                = @modeler.model_name
+          model_type, model_options = @modeler.parse_to_type_and_options(@modeler.entry_definition[:type])
+
+          @model = @modeler.new_module_instance(:model, model_type, model_name, model_options)
+
+          @model.data_source = @data_source
+
+          compile_model(@model)
+
+          @model
+        end
+
+        def generate
+          generate_model_value(compile)
+        end
+
+        private
+
+        def compile_model(model)
+          model.setup_with_modeler(@modeler)
+
+          compile_associations(model)
+        end
+
+        def compile_associations(parent_model)
+          association_definitions = @modeler.config_value_for(parent_model, :entry_definition, {})[:associations] || {}
+
+          association_definitions.each do |association_name, association_definition|
+            association_type, association_options = @modeler.parse_to_type_and_options(association_definition[:type])
+            association_constant                  = @modeler.find_module_constant(:model, association_type)
+
+            model_or_models = association_constant.__send__(
+              association_generator, parent_model, association_name, association_options
+            )
+
+            parent_model.add_association(model_or_models)
+
+            if model_or_models.is_a?(::Array)
+              model_or_models.each { |model| compile_model(model) }
+            else
+              compile_model(model_or_models)
+            end
+          end
+        end
+
+        def association_generator
+          raise ::NotImplementedError.new "You must implement #{self.class}##{__method__}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+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/model/base.rb

@@ -0,0 +1,150 @@
+module ActiveRecord
+  module Bixformer
+    module Model
+      class Base
+        attr_accessor :data_source,
+                      :activerecord_id
+
+        attr_reader :name,
+                    :parent,
+                    :attribute_map,
+                    :optional_attributes,
+                    :association_map,
+                    :translator,
+                    :modeler
+
+        class << self
+          def new_as_association_for_import(parent, association_name, options)
+            raise ::NotImplementedError.new "You must implement #{self.class}##{__method__}"
+          end
+
+          def new_as_association_for_export(parent, association_name, options)
+            model = self.new(association_name, options)
+
+            model.data_source = parent.data_source && parent.data_source.__send__(association_name) # parent.data_source is ActiveRecord::Base
+
+            unless model.data_source.is_a?(::ActiveRecord::Base)
+              parent_name = model.parents.map(&:name).join('.')
+
+              raise ::ArgumentError.new "#{parent_name}.#{association_name} is not a ActiveRecord instance"
+            end
+
+            model
+          end
+        end
+
+        def initialize(model_or_association_name, options)
+          @name            = model_or_association_name.to_s
+          @options         = options
+          @association_map = {}
+        end
+
+        def setup_with_modeler(modeler)
+          @modeler = modeler
+
+          entry_definition = @modeler.config_value_for(self, :entry_definition, {})
+
+          @attribute_map = (entry_definition[:attributes] || {}).map do |attribute_name, attribute_value|
+            attribute_type, attribute_options = @modeler.parse_to_type_and_options(attribute_value)
+
+            attribute = @modeler.new_module_instance(:attribute, attribute_type, self, attribute_name, attribute_options)
+
+            [attribute_name, attribute]
+          end.to_h
+
+          @optional_attributes = @modeler.config_value_for(self, :optional_attributes, [])
+          @default_values   = @modeler.config_value_for(self, :default_values, {})
+
+          # At present, translation function is only i18n
+          @translator = ::ActiveRecord::Bixformer::Translator::I18n.new
+
+          @translator.config = @modeler.translation_config.dup
+          @translator.model    = self
+        end
+
+        def set_parent(model)
+          @parent = model
+        end
+
+        def parents
+          @parent ? [*parent.parents, @parent] : []
+        end
+
+        def parent_foreign_key
+          return nil unless @parent
+
+          @parent_foreign_key ||= @parent.activerecord_constant.reflections[@name].foreign_key
+        end
+
+        def add_association(model_or_models)
+          models = model_or_models.is_a?(::Array) ? model_or_models : [model_or_models]
+
+          association_name = models.first.name
+
+          @association_map[association_name] = model_or_models
+
+          models.each { |model| model.set_parent(self) }
+        end
+
+        def activerecord_constant
+          @activerecord_constant ||=
+            if @parent
+              @parent.activerecord_constant.reflections[@name].table_name.classify.constantize
+            else
+              @name.camelize.constantize
+            end
+        end
+
+        def generate_export_value_map
+          @attribute_map.keys.map do |attribute_name|
+            [attribute_name, make_export_value(attribute_name)]
+          end.to_h.with_indifferent_access
+        end
+
+        def generate_import_value_map
+          value_map = {}.with_indifferent_access
+
+          @attribute_map.keys.each do |attribute_name|
+            attribute_value = make_import_value(attribute_name)
+
+            attribute_value = @default_values[attribute_name] unless presence_value?(attribute_value)
+
+            # 取り込み時は、オプショナルな属性では、空と思われる値は取り込まない
+            next if ! presence_value?(attribute_value) &&
+                    @optional_attributes.include?(attribute_name.to_s)
+
+            value_map[attribute_name] = attribute_value
+          end
+
+          value_map
+        end
+
+        private
+
+        def make_export_value(attribute_name)
+          return nil unless @data_source
+
+          attribute                   = @attribute_map[attribute_name]
+          data_source_attribute_value = @data_source.__send__(attribute_name)
+
+          attribute.make_export_value(data_source_attribute_value)
+        end
+
+        def make_import_value(attribute_name)
+          raise ::NotImplementedError.new "You must implement #{self.class}##{__method__}"
+        end
+
+        def presence_value?(value)
+          case value
+          when ::String
+            ! value.blank?
+          when ::TrueClass, ::FalseClass
+            true
+          else
+            value ? true : false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-bixformer/model/csv/base.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module Bixformer
+    module Model
+      module Csv
+        class Base < ::ActiveRecord::Bixformer::Model::Base
+          class << self
+            def new_as_association_for_import(parent, association_name, options)
+              model = self.new(association_name, options)
+
+              model.data_source = parent.data_source # parent.data_source is CSV::Row
+
+              model
+            end
+          end
+
+          def csv_title(attribute_name)
+            @translator.translate_attribute(attribute_name)
+          end
+
+          def available_csv_titles
+            [
+              *@attribute_map.keys.map do |attribute_name|
+                csv_title(attribute_name)
+              end,
+              *@association_map.values.flat_map do |model_or_models|
+                models = model_or_models.is_a?(::Array) ? model_or_models : [model_or_models]
+
+                models.flat_map { |m| m.available_csv_titles }
+              end
+            ]
+          end
+
+          private
+
+          def make_import_value(attribute_name)
+            return nil unless @data_source
+
+            attribute                   = @attribute_map[attribute_name]
+            data_source_attribute_value = @data_source[csv_title(attribute_name)]
+
+            attribute.make_import_value(data_source_attribute_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-bixformer/model/csv/indexed.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Bixformer
+    module Model
+      module Csv
+        class Indexed < ::ActiveRecord::Bixformer::Model::Csv::Base
+          class << self
+            def new_as_association_for_import(parent, association_name, options)
+              options    = options.is_a?(Hash) ? options : {}
+              limit_size = options[:size] || 1
+
+              (1..limit_size).map do |index|
+                model = self.new(association_name, options.merge(index: index))
+
+                model.data_source = parent.data_source # parent.data_source is CSV::Row
+
+                model
+              end
+            end
+
+            def new_as_association_for_export(parent, association_name, options)
+              options      = options.is_a?(Hash) ? options : {}
+              limit_size   = options[:size] || 1
+              associations = parent.data_source ? parent.data_source.__send__(association_name).to_a : []
+
+              (1..limit_size).map do |index|
+                model = self.new(association_name, options.merge(index: index))
+
+                model.data_source = associations[index - 1]
+
+                model
+              end
+            end
+          end
+
+          def setup_with_modeler(modeler)
+            super
+
+            @translator.model_arguments = { index: @options[:index] }
+
+            @translator.attribute_arguments_map = @attribute_map.keys.map do |attribute_name|
+              [attribute_name, { index: @options[:index] }]
+            end.to_h
+          end
+
+          def csv_title(attribute_name)
+            if parents.find { |parent| parent.is_a?(ActiveRecord::Bixformer::Model::Csv::Indexed) }
+              parents.map { |parent| parent.translator.translate_model }.join + super
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+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