activerecord-bixformer 0.1.1 → 0.2.0

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

@@ -3,47 +3,54 @@ module ActiveRecord
     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
+          def initialize(model_or_association_name, options)
+            super
+
+            @options = options.is_a?(::Hash) ? options : {}
 
-              (1..limit_size).map do |index|
-                model = self.new(association_name, options.merge(index: index))
+            @options[:size] ||= 1
+          end
 
-                model.data_source = parent.data_source # parent.data_source is CSV::Row
+          def make_export_value(activerecord_or_activerecords)
+            activerecord_or_activerecords ||= []
 
-                model
-              end
+            # has_many でしか使わない想定なので activerecord_or_activerecords は Array のはず
+            (1..options[:size]).inject({}) do |values, index|
+              update_translator(index)
+
+              values.merge(super(activerecord_or_activerecords[index-1]))
             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 : []
+          def make_import_value(csv_row, parent_activerecord_id = nil)
+            # has_many でしか使わない想定なので Array を返却
+            (1..options[:size]).map do |index|
+              update_translator(index)
 
-              (1..limit_size).map do |index|
-                model = self.new(association_name, options.merge(index: index))
+              super
+            end
+          end
 
-                model.data_source = associations[index - 1]
+          def csv_titles
+            (1..options[:size]).flat_map do |index|
+              update_translator(index)
 
-                model
-              end
+              super
             end
           end
 
-          def setup_with_modeler(modeler)
-            super
+          private
 
-            @translator.model_arguments = { index: @options[:index] }
+          def update_translator(index)
+            @translator.model_arguments = { index: index }
 
-            @translator.attribute_arguments_map = @attribute_map.keys.map do |attribute_name|
-              [attribute_name, { index: @options[:index] }]
+            @translator.attribute_arguments_map = @attributes.map do |attr|
+              [attr.name, { index: index }]
             end.to_h
           end
 
           def csv_title(attribute_name)
-            if parents.find { |parent| parent.is_a?(ActiveRecord::Bixformer::Model::Csv::Indexed) }
+            if parents.find { |parent| parent.is_a?(::ActiveRecord::Bixformer::Model::Csv::Indexed) }
               parents.map { |parent| parent.translator.translate_model }.join + super
             else
               super

data/lib/activerecord-bixformer/plan.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Bixformer
+    module Plan
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :__bixformer_format
+
+        class_attribute :__bixformer_model
+
+        class_attribute :__bixformer_namespace
+      end
+
+      module ClassMethods
+        def bixformer_for(model_name)
+          self.__bixformer_model = model_name
+        end
+
+        def bixformer_load_namespace(namespace)
+          self.__bixformer_namespace = namespace
+        end
+      end
+
+      def entry
+        {}
+      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
+    end
+  end
+end

data/lib/activerecord-bixformer/plan_accessor.rb

@@ -0,0 +1,131 @@
+module ActiveRecord
+  module Bixformer
+    class PlanAccessor
+      def initialize(plan)
+        @plan                      = plan
+        @module_constant_of        = {}
+        @module_load_namespaces_of = {}
+      end
+
+      def raw_value
+        @plan
+      end
+
+      def value_of(config_name)
+        @plan.__send__(config_name)
+      end
+
+      def pickup_value_for(model, config_name, default_value = nil)
+        model_names_without_root = (model.parents.map(&:name) + [model.name]).drop(1)
+
+        # 指定された設定の全設定値を取得
+        entire_config_value = @plan.__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
+                         find_entry(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(config, keys)
+        return config ? config.dup : nil if keys.empty?
+
+        key = keys.shift
+
+        find_entry(config[:associations][key], keys)
+      end
+
+      def module_load_namespaces(module_type)
+        [
+          @plan.class.__bixformer_namespace,
+          "::ActiveRecord::Bixformer::#{module_type.to_s.camelize}::#{@plan.__bixformer_format.camelize}",
+          "::ActiveRecord::Bixformer::#{module_type.to_s.camelize}",
+        ].compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Bixformer
+    module To
+      class Csv < ::ActiveRecord::Bixformer::Compiler
+        def initialize(plan)
+          super(:csv, plan)
+        end
+
+        def csv_title_row
+          compile.csv_titles
+        end
+
+        def csv_body_row(activerecord)
+          model    = compile
+          body_map = model.make_export_value(activerecord)
+
+          model.csv_titles.map { |title| body_map[title] }
+        end
+
+        # private
+
+        # def csv_body_map_by_model(model, activerecord_or_activerecords)
+        #   activerecord_or_activerecords = if activerecord_or_activerecords.is_a?(::ActiveRecord::Relation)
+        #                                     activerecord_or_activerecords.to_a
+        #                                   else
+        #                                     activerecord_or_activerecords
+        #                                   end
+
+        #   model.generate_export_value(activerecord_or_activerecords).merge(
+        #     csv_body_map_by_association(model, activerecord_or_activerecords)
+        #   )
+        # end
+
+        # def csv_body_map_by_association(model, activerecord_or_activerecords)
+        #   model.associations.inject({}) do |body_map, association_model|
+        #     activerecords = if activerecord_or_activerecords.is_a?(::Array)
+        #                       activerecord_or_activerecords
+        #                     else
+        #                       [activerecord_or_activerecords]
+        #                     end
+
+        #     body_map.merge(
+        #       activerecords.inject({}) do |body_each_map, activerecord|
+        #         association_value = activerecord.__send__(association_model.name)
+
+        #         body_each_map.merge(
+        #           csv_body_map_by_model(association_model, association_value)
+        #         )
+        #       end
+        #     )
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/activerecord-bixformer/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Bixformer
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/lib/activerecord-bixformer.rb

@@ -1,44 +1,3 @@
 require 'activerecord-bixformer/version'
-
-module ActiveRecord
-  module Bixformer
-    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 Generator
-      autoload :ActiveRecord, 'activerecord-bixformer/generator/active_record'
-      autoload :Base,         'activerecord-bixformer/generator/base'
-      autoload :CsvRow,       'activerecord-bixformer/generator/csv_row'
-    end
-
-    module Model
-      autoload :Base, 'activerecord-bixformer/model/base'
-
-      module Csv
-        autoload :Base,    'activerecord-bixformer/model/csv/base'
-        autoload :Indexed, 'activerecord-bixformer/model/csv/indexed'
-      end
-    end
-
-    module Modeler
-      autoload :Base, 'activerecord-bixformer/modeler/base'
-      autoload :Csv, 'activerecord-bixformer/modeler/csv'
-    end
-
-    module Runner
-      autoload :Base, 'activerecord-bixformer/runner/base'
-      autoload :Csv, 'activerecord-bixformer/runner/csv'
-    end
-
-    module Translator
-      autoload :I18n, 'activerecord-bixformer/translator/i18n'
-    end
-  end
-end
+require 'activerecord-bixformer/autoload'
+require 'activerecord-bixformer/format/csv'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-bixformer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Hiroaki Otsu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-13 00:00:00.000000000 Z
+date: 2016-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -222,6 +222,7 @@ files:
 - Rakefile
 - activerecord-bixformer.gemspec
 - lib/activerecord-bixformer.rb
+- lib/activerecord-bixformer/assignable_attributes_normalizer.rb
 - lib/activerecord-bixformer/attribute/base.rb
 - lib/activerecord-bixformer/attribute/boolean.rb
 - lib/activerecord-bixformer/attribute/booletania.rb
@@ -229,16 +230,17 @@ files:
 - lib/activerecord-bixformer/attribute/enumerize.rb
 - lib/activerecord-bixformer/attribute/override.rb
 - lib/activerecord-bixformer/attribute/time.rb
-- lib/activerecord-bixformer/generator/active_record.rb
-- lib/activerecord-bixformer/generator/base.rb
-- lib/activerecord-bixformer/generator/csv_row.rb
+- lib/activerecord-bixformer/autoload.rb
+- lib/activerecord-bixformer/compiler.rb
+- lib/activerecord-bixformer/format/csv.rb
+- lib/activerecord-bixformer/from/csv.rb
+- lib/activerecord-bixformer/import_value_validatable.rb
 - lib/activerecord-bixformer/model/base.rb
 - lib/activerecord-bixformer/model/csv/base.rb
 - lib/activerecord-bixformer/model/csv/indexed.rb
-- lib/activerecord-bixformer/modeler/base.rb
-- lib/activerecord-bixformer/modeler/csv.rb
-- lib/activerecord-bixformer/runner/base.rb
-- lib/activerecord-bixformer/runner/csv.rb
+- lib/activerecord-bixformer/plan.rb
+- lib/activerecord-bixformer/plan_accessor.rb
+- lib/activerecord-bixformer/to/csv.rb
 - lib/activerecord-bixformer/translator/i18n.rb
 - lib/activerecord-bixformer/version.rb
 homepage: https://github.com/aki2o/activerecord-bixformer

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

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

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