activerecord-bixformer 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8cda410932eeba35b07cff8afac9eb446b02cbc
-  data.tar.gz: 3a26402ab54b8acfc7044f504144f90331757578
+  metadata.gz: 525850c477621e80252c030d003cdfafedb124ad
+  data.tar.gz: c1b5d75f0fedc2d7cd5b0506f7d4d17e5ee3ec40
 SHA512:
-  metadata.gz: 65823e13adc7ae8db2e61eb0f216b940ba55ab808430f2cfed3f2669a9fec76922ffd44b8e167ccc9562ad065cf19f61bd46fe2d8f994bf43efafafe6393ece1
-  data.tar.gz: 68834b09f518dc2af1f79827e3ca5130c17c6efb45013a4f603ab9c08374b4f3fdab90284d1229c13c852c2ae3c1c2cd1ed6efb746e5ae378d3716332a2d3a82
+  metadata.gz: fdb0105819005d89f3c70ef030c2ce2316683f981687f7cf35a038074b7771646c4ed9f0350a00b7624a3f6711ef3d4a9ab20fc6636f6f934b98f4fe72e9bcfc
+  data.tar.gz: 4d8a6bab8708bfd6fb640ed0baaa7665db1dd66ac53207d0011dfceb4af18da9d821a751d14172e1f9e76628cc454881cd29ba924d595c25e7750390d0547c58

data/README-ja.md

@@ -35,7 +35,7 @@ gem 'activerecord-bixformer'
 
 本フレームワークの構成要素と役割は以下のようになっています。
 
-### Modeler
+### Plan
 
 インポート/エクスポートの一連の処理をどのように処理するかを定義する設定ファイルの役割です。  
 処理実行時に、複数登録された本クラスのインスタンス群から採用するものを決定するフローになっていて、
@@ -51,27 +51,27 @@ gem 'activerecord-bixformer'
 ActiveRecord のモデルに対応して、そのモデルのインポート/エクスポート処理を担当するクラスです。  
 
 ActiveRecord::Bixformer::Model::Base を継承した独自クラスを定義し、  
-Modelerを適切に定義することで、それを使用して処理内容を切り替えることができます。  
+Planを適切に定義することで、それを使用して処理内容を切り替えることができます。  
 
 ### Attribute
 
 ActiveRecord のモデルの持つ属性に対応して、その属性のインポート/エクスポート処理を担当するクラスです。  
 
 ActiveRecord::Bixformer::Attribute::Base を継承した独自クラスを定義し、  
-Modelerを適切に定義することで、それを使用して処理内容を切り替えることができます。  
+Planを適切に定義することで、それを使用して処理内容を切り替えることができます。  
 
 # 使い方
 
-## 1. Modelerの実装
+## 1. Planの実装
 
-ActiveRecord::Bixformer::Modeler::Base を継承して、以下のメソッドを適切に設定して下さい。  
+ActiveRecord::Bixformer::Plan::Base を継承して、以下のメソッドを適切に設定して下さい。  
 
 ### model_name
 
 インポート/エクスポート対象のモデル名を返して下さい。  
 例えばusersテーブルのデータが対象であれば、 `:user` です。  
 
-### entry_definition
+### entry
 
 インポート/エクスポート対象の属性と、それをどのように処理するかを定義した以下のようなハッシュを返して下さい。  
 
@@ -110,7 +110,7 @@ ActiveRecord::Bixformer::Modeler::Base を継承して、以下のメソッド
 
 ```ruby
 [
-  # 対象モデル（上の例なら user ）の属性名。 entry_definition で定義されていること
+  # 対象モデル（上の例なら user ）の属性名。 entry で定義されていること
   :name,
   
   # 関連名も指定可能。この場合は、その関連モデルの処理対象の属性全てが有効な値でない場合
@@ -225,8 +225,8 @@ end
 
 ### module_load_namespaces
 
-`entry_definition` で指定されたクラス名のクラスを探索する namespace を定義した配列を返して下さい。  
-ActiveRecord::Bixformer::Modeler::Base には、以下のように定義されています。  
+`entry` で指定されたクラス名のクラスを探索する namespace を定義した配列を返して下さい。  
+ActiveRecord::Bixformer::Plan::Base には、以下のように定義されています。  
 
 ```ruby
 def module_load_namespaces(module_type)
@@ -248,7 +248,7 @@ CSVを扱う簡単なサンプルコードは以下のような感じになり
 ```ruby
 runner = ActiveRecord::Bixformer::Runner::Csv.new
 
-runner.add_modeler(Your::Modeler.new)
+runner.add_plan(Your::Plan.new)
 
 csv_data = runner.export(User.all, force_quotes: true)
 

data/lib/activerecord-bixformer/assignable_attributes_normalizer.rb

@@ -0,0 +1,125 @@
+module ActiveRecord
+  module Bixformer
+    class AssignableAttributesNormalizer
+      include ::ActiveRecord::Bixformer::ImportValueValidatable
+
+      def initialize(plan, model, parent_activerecord_id)
+        @plan                   = ActiveRecord::Bixformer::PlanAccessor.new(plan)
+        @model                  = model
+        @parent_activerecord_id = parent_activerecord_id
+        @identified_column_name = @model.activerecord_constant.primary_key
+      end
+
+      def normalize(model_attributes)
+        @model_attributes = model_attributes
+
+        return {} unless @model_attributes
+
+        # 必須な属性が渡されていない場合には、取り込みしない
+        return {} unless validate_required_attributes
+
+        set_required_condition   if presence_value?(@model_attributes)
+        set_parent_foreign_key   if presence_value?(@model_attributes)
+        set_identified_attribute if presence_value?(@model_attributes)
+
+        # 空でない要素が無いなら、空ハッシュで返す
+        return {} unless presence_value?(@model_attributes)
+
+        @model_attributes
+      end
+
+      private
+
+      def validate_required_attributes
+        required_attributes = @plan.pickup_value_for(@model, :required_attributes, [])
+
+        required_attributes.all? { |attribute_name| presence_value?(@model_attributes[attribute_name]) }
+      end
+
+      def set_required_condition
+        # 設定するのはルートの場合のみ
+        return if @model.parent
+
+        @model_attributes.merge!(@plan.value_of(:required_condition))
+      end
+
+      def set_parent_foreign_key
+        # 設定するのは親がいる場合のみ
+        return unless @model.parent
+
+        if @parent_activerecord_id
+          # 親のレコードが見つかっているなら、それも結果ハッシュに追加する
+          @model_attributes[@model.parent_foreign_key] = @parent_activerecord_id
+        else
+          # 見つかっていないなら、間違った値が指定されている可能性があるので、キー自体を削除
+          @model_attributes.delete(@model.parent_foreign_key)
+        end
+      end
+
+      def set_identified_attribute
+        # 更新の場合は、インポートデータを元にデータベースから対象のレコードを検索してIDを取得
+        verified_id = verified_activerecord_id
+
+        if verified_id
+          # 更新なら、ID属性を改めて設定
+          @model_attributes[@identified_column_name] = verified_id
+        else
+          # 見つかっていないなら、間違った値が指定されている可能性があるので、キー自体を削除
+          @model_attributes.delete(@identified_column_name)
+        end
+      end
+
+      def verified_activerecord_id
+        # 更新対象のレコードを特定できるかチェック
+        identified_value = @model_attributes[@identified_column_name]
+
+        uniqueness_condition = if identified_value
+                                 { @identified_column_name => identified_value }
+                               else
+                                 find_unique_condition
+                               end
+
+        # レコードが特定できないなら、更新処理ではないので終了
+        return nil unless uniqueness_condition
+
+        # 更新対象のレコードを正しく特定できているか確認するための検証条件を取得
+        required_condition = if @model.parent
+                               key = @model.parent_foreign_key
+
+                               { key => @model_attributes[key] }
+                             else
+                               @plan.value_of(:required_condition)
+                             end
+
+        # 検証条件は、必ず値がなければならない
+        return nil if required_condition.any? { |_k, v| ! presence_value?(v) }
+
+        # インポートされてきた、レコードを特定する条件が、誤った値でないかどうかを、
+        # 特定されるレコードが、更新すべき正しいレコードであるかチェックするための
+        # 検証条件とマージして、データベースに登録されているか確認する
+        verified_condition = uniqueness_condition.merge(required_condition)
+
+        @model.find_activerecord_by!(verified_condition).__send__(@identified_column_name)
+      rescue ::ActiveRecord::RecordNotFound => e
+        # ID属性が指定されているのに、データベースに見つからない場合はエラーにする
+        raise e if identified_value
+      end
+
+      def find_unique_condition
+        unique_indexes = @plan.pickup_value_for(@model, :unique_indexes, [])
+
+        # ユニーク条件が指定されていないなら終了
+        return nil if unique_indexes.empty?
+
+        unique_condition = unique_indexes.map do |key|
+          [key, @model_attributes[key]]
+        end.to_h
+
+        # ユニーク条件は、必ず値がなければならない
+        return nil if unique_condition.any? { |_k, v| ! presence_value?(v) }
+
+        unique_condition
+      end
+    end
+  end
+end

data/lib/activerecord-bixformer/attribute/booletania.rb

@@ -3,17 +3,15 @@ module ActiveRecord
     module Attribute
       class Booletania < ::ActiveRecord::Bixformer::Attribute::Base
         def make_export_value(active_record_value)
-          return nil unless @model.data_source
-
-          @model.data_source.__send__("#{@name}_text")
+          @model.activerecord_constant.__send__("#{@name}_options").find do |text, bool|
+            bool == active_record_value
+          end&.first
         end
 
         def make_import_value(value)
           return nil unless value
 
-          @model.activerecord_constant.__send__("#{@name}_options").find do |options|
-            options.first == value.strip
-          end&.last
+          @model.activerecord_constant.__send__("#{@name}_options").to_h[value.strip]
         end
       end
     end

data/lib/activerecord-bixformer/attribute/enumerize.rb

@@ -3,9 +3,11 @@ module ActiveRecord
     module Attribute
       class Enumerize < ::ActiveRecord::Bixformer::Attribute::Base
         def make_export_value(active_record_value)
-          return nil unless @model.data_source
+          active_record_value = active_record_value.to_s
 
-          @model.data_source.__send__("#{@name}_text")
+          @model.activerecord_constant.__send__(@name).options.find do |text, key|
+            key == active_record_value
+          end&.first
         end
 
         def make_import_value(value)

data/lib/activerecord-bixformer/autoload.rb

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module Bixformer
+    autoload :AssignableAttributesNormalizer, 'activerecord-bixformer/assignable_attributes_normalizer'
+    autoload :Compiler,                       'activerecord-bixformer/compiler'
+    autoload :ImportValueValidatable,         'activerecord-bixformer/import_value_validatable'
+    autoload :Plan,                           'activerecord-bixformer/plan'
+    autoload :PlanAccessor,                   'activerecord-bixformer/plan_accessor'
+
+    module Attribute
+      autoload :Base,       'activerecord-bixformer/attribute/base'
+      autoload :Boolean,    'activerecord-bixformer/attribute/boolean'
+      autoload :Booletania, 'activerecord-bixformer/attribute/booletania'
+      autoload :Date,       'activerecord-bixformer/attribute/date'
+      autoload :Enumerize,  'activerecord-bixformer/attribute/enumerize'
+      autoload :Override,   'activerecord-bixformer/attribute/override'
+      autoload :Time,       'activerecord-bixformer/attribute/time'
+    end
+
+    module Model
+      autoload :Base, 'activerecord-bixformer/model/base'
+    end
+
+    module Translator
+      autoload :I18n, 'activerecord-bixformer/translator/i18n'
+    end
+  end
+end

data/lib/activerecord-bixformer/compiler.rb

@@ -0,0 +1,45 @@
+module ActiveRecord
+  module Bixformer
+    class Compiler
+      def initialize(format, plan)
+        plan.__bixformer_format = format.to_s
+
+        @model_name = plan.class.__bixformer_model
+        @plan       = ActiveRecord::Bixformer::PlanAccessor.new(plan)
+      end
+
+      def compile
+        model_type, model_options = @plan.parse_to_type_and_options(@plan.value_of(:entry)[:type])
+
+        model = @plan.new_module_instance(:model, model_type, @model_name, model_options)
+
+        compile_model(model)
+
+        model
+      end
+
+      private
+
+      def compile_model(model)
+        model.setup(@plan.raw_value)
+
+        compile_associations(model)
+      end
+
+      def compile_associations(parent_model)
+        association_entries = @plan.pickup_value_for(parent_model, :entry, {})[:associations] || {}
+
+        association_entries.each do |association_name, association_entry|
+          association_type, association_options = @plan.parse_to_type_and_options(association_entry[:type])
+          association_constant                  = @plan.find_module_constant(:model, association_type)
+
+          association_model = association_constant.new(association_name, association_options)
+
+          parent_model.add_association(association_model)
+
+          compile_model(association_model)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'activerecord-bixformer/autoload'
+
+module ActiveRecord
+  module Bixformer
+    module Model
+      module Csv
+        autoload :Base,    'activerecord-bixformer/model/csv/base'
+        autoload :Indexed, 'activerecord-bixformer/model/csv/indexed'
+      end
+    end
+
+    module From
+      autoload :Csv, 'activerecord-bixformer/from/csv'
+    end
+
+    module To
+      autoload :Csv, 'activerecord-bixformer/to/csv'
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Bixformer
+    module From
+      class Csv < ::ActiveRecord::Bixformer::Compiler
+        def initialize(plan)
+          super(:csv, plan)
+        end
+
+        def assignable_attributes(csv_row)
+          compile.make_import_value(csv_row)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-bixformer/import_value_validatable.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module Bixformer
+    module ImportValueValidatable
+      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

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

@@ -1,65 +1,57 @@
 module ActiveRecord
   module Bixformer
     module Model
+      # @attr_reader [String] name
+      #   the name or association name of handled ActiveRecord
+      # @attr_reader [ActiveRecord::Bixformer::Model::Base] parent
+      #   the instance has parent association.
+      # @attr_reader [Hash<String, ActiveRecord::Bixformer::Attribute::Base>] attributes
+      #   the import/export target attribute names and its instance.
+      # @attr_reader [Array<String>] optional_attributes
+      #   the list of attribute name to not make key if its value is blank.
+      # @attr_reader [Hash<String, ActiveRecord::Bixformer::Model::Base>] associations
+      #   the import/export target association names and its instance.
+      # @attr_reader [ActiveRecord::Bixformer::Translator::I18n] translator
+      # @attr_reader [ActiveRecord::Bixformer::Plan::Base] plan
+      #   active plan in the import/export process.
       class Base
-        attr_accessor :data_source,
-                      :activerecord_id
+        include ::ActiveRecord::Bixformer::ImportValueValidatable
 
-        attr_reader :name,
-                    :parent,
-                    :attribute_map,
+        attr_reader :name, :parent,
+                    :attributes, :associations,
                     :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
+                    :options
 
         def initialize(model_or_association_name, options)
-          @name            = model_or_association_name.to_s
-          @options         = options
-          @association_map = {}
+          @name         = model_or_association_name.to_s
+          @options      = options
+          @associations = []
         end
 
-        def setup_with_modeler(modeler)
-          @modeler = modeler
-
-          entry_definition = @modeler.config_value_for(self, :entry_definition, {})
+        def setup(plan)
+          @plan = ActiveRecord::Bixformer::PlanAccessor.new(plan)
 
-          @attribute_map = (entry_definition[:attributes] || {}).map do |attribute_name, attribute_value|
-            attribute_type, attribute_options = @modeler.parse_to_type_and_options(attribute_value)
+          entry = @plan.pickup_value_for(self, :entry, {})
 
-            attribute = @modeler.new_module_instance(:attribute, attribute_type, self, attribute_name, attribute_options)
+          @attributes = (entry[:attributes] || {}).map do |attribute_name, attribute_value|
+            attribute_type, attribute_options = @plan.parse_to_type_and_options(attribute_value)
 
-            [attribute_name, attribute]
-          end.to_h
+            @plan.new_module_instance(:attribute, attribute_type, self, attribute_name, attribute_options)
+          end
 
-          @optional_attributes = @modeler.config_value_for(self, :optional_attributes, [])
-          @default_values   = @modeler.config_value_for(self, :default_values, {})
+          @optional_attributes = @plan.pickup_value_for(self, :optional_attributes, [])
+          @default_values      = @plan.pickup_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
+          @translator.config = @plan.value_of(:translation_config).dup
+          @translator.model  = self
+        end
+
+        def plan
+          @plan.raw_value
         end
 
         def set_parent(model)
@@ -70,22 +62,20 @@ module ActiveRecord
           @parent ? [*parent.parents, @parent] : []
         end
 
+        # @return [String] the foreign key name to associate to parent ActiveRecord.
         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
+        def add_association(model)
+          @associations.push(model)
 
-          @association_map[association_name] = model_or_models
-
-          models.each { |model| model.set_parent(self) }
+          model.set_parent(self)
         end
 
+        # @return [Constant] the constant value of handling ActiveRecord.
         def activerecord_constant
           @activerecord_constant ||=
             if @parent
@@ -95,54 +85,50 @@ module ActiveRecord
             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
+        def find_activerecord_by!(condition)
+          activerecord_constant.find_by!(condition)
         end
 
-        def generate_import_value_map
-          value_map = {}.with_indifferent_access
+        private
+
+        def make_each_attribute_import_value(parent_activerecord_id = nil, &block)
+          values     = {}.with_indifferent_access
+          normalizer = ::ActiveRecord::Bixformer::AssignableAttributesNormalizer.new(plan, self, parent_activerecord_id)
 
-          @attribute_map.keys.each do |attribute_name|
-            attribute_value = make_import_value(attribute_name)
+          @attributes.each do |attr|
+            attribute_value = block.call(attr)
 
-            attribute_value = @default_values[attribute_name] unless presence_value?(attribute_value)
+            attribute_value = @default_values[attr.name] unless presence_value?(attribute_value)
 
             # 取り込み時は、オプショナルな属性では、空と思われる値は取り込まない
             next if ! presence_value?(attribute_value) &&
-                    @optional_attributes.include?(attribute_name.to_s)
+                    @optional_attributes.include?(attr.name.to_s)
 
-            value_map[attribute_name] = attribute_value
+            values[attr.name] = attribute_value
           end
 
-          value_map
+          normalizer.normalize(values)
         end
 
-        private
-
-        def make_export_value(attribute_name)
-          return nil unless @data_source
+        def make_each_association_import_value(values, &block)
+          self_activerecord_id = values[activerecord_constant.primary_key]
 
-          attribute                   = @attribute_map[attribute_name]
-          data_source_attribute_value = @data_source.__send__(attribute_name)
+          @associations.each do |association|
+            association_value = block.call(association, self_activerecord_id)
 
-          attribute.make_export_value(data_source_attribute_value)
-        end
+            if association_value.is_a?(::Array)
+              # has_many な場合は、配列が返ってくるが、空と思われる要素は結果に含めない
+              association_value = association_value.reject { |v| ! presence_value?(v) }
+            end
 
-        def make_import_value(attribute_name)
-          raise ::NotImplementedError.new "You must implement #{self.class}##{__method__}"
-        end
+            # 取り込み時は、オプショナルな関連では、空と思われる値は取り込まない
+            next if ! presence_value?(association_value) &&
+                    @optional_attributes.include?(association.name.to_s)
 
-        def presence_value?(value)
-          case value
-          when ::String
-            ! value.blank?
-          when ::TrueClass, ::FalseClass
-            true
-          else
-            value ? true : false
+            values["#{association.name}_attributes".to_sym] = association_value
           end
+
+          values
         end
       end
     end

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

@@ -3,42 +3,50 @@ module ActiveRecord
     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)
+          def make_export_value(activerecord_or_activerecords)
+            # has_one でしか使わない想定なので activerecord_or_activerecords は ActiveRecord::Base のはず
+            values = @attributes.map do |attr|
+              attribute_value = activerecord_or_activerecords && activerecord_or_activerecords.__send__(attr.name)
 
-              model.data_source = parent.data_source # parent.data_source is CSV::Row
+              [csv_title(attr.name), attr.make_export_value(attribute_value)]
+            end.to_h.with_indifferent_access
 
-              model
+            @associations.inject(values) do |each_values, association|
+              association_value = activerecord_or_activerecords && activerecord_or_activerecords.__send__(association.name)
+
+              association_value = association_value.to_a if association_value.is_a?(::ActiveRecord::Relation)
+
+              each_values.merge(association.make_export_value(association_value))
             end
           end
 
-          def csv_title(attribute_name)
-            @translator.translate_attribute(attribute_name)
+          def make_import_value(csv_row, parent_activerecord_id = nil)
+            values = make_each_attribute_import_value(parent_activerecord_id) do |attr|
+              csv_value = csv_row[csv_title(attr.name)]
+
+              attr.make_import_value(csv_value)
+            end
+
+            make_each_association_import_value(values) do |association, self_activerecord_id|
+              association.make_import_value(csv_row, self_activerecord_id)
+            end
           end
 
-          def available_csv_titles
+          def 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
+              *@attributes.map { |attr| csv_title(attr.name) },
+              *@associations.flat_map(&:csv_titles)
             ]
           end
 
-          private
-
-          def make_import_value(attribute_name)
-            return nil unless @data_source
+          def parse_self_data_source(csv_row)
+            csv_row
+          end
 
-            attribute                   = @attribute_map[attribute_name]
-            data_source_attribute_value = @data_source[csv_title(attribute_name)]
+          private
 
-            attribute.make_import_value(data_source_attribute_value)
+          def csv_title(attribute_name)
+            @translator.translate_attribute(attribute_name)
           end
         end
       end