simple_master 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3767dce67967051739f25da6dc14604e647a65bca3d6a68579b54cc0bad58009
+  data.tar.gz: ad1ffecd0e636e7072d8f1d928717ca42090a1e01426a1e619fca6a056a1720f
+SHA512:
+  metadata.gz: 28d28d28165fe704e8fa38b99a2a409b8c505c03b31366f2bb5ad7ad9bc033ca10c8e095ce725fe1b67e35cfc28da06f88d10c2dcb81545462f6cce911e2e21c
+  data.tar.gz: f92e380bbf3ff68fbd9686427d42c32f961342b73e4722f1a2634f6c2f2b72bcd97c919c33c76fdfa1f6afe208a8270b748b246eddedb6f6ee51d8e9baadd178

data/lib/simple_master/active_record/belongs_to_master_polymorphic_reflection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  module ActiveRecord
+    class BelongsToMasterPolymorphicReflection < ::ActiveRecord::Reflection::BelongsToReflection
+      def association_class
+        BelongsToPolymorphicAssociation
+      end
+    end
+  end
+end

data/lib/simple_master/active_record/belongs_to_polymorphic_association.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  module ActiveRecord
+    class BelongsToPolymorphicAssociation < ::ActiveRecord::Associations::BelongsToPolymorphicAssociation
+      def find_target(async: false)
+        klass = klass()
+        if klass < Master
+          foreign_key = owner.send(reflection.foreign_key)
+          klass.find(foreign_key)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/active_record/belongs_to_polymorphic_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  module ActiveRecord
+    class BelongsToPolymorphicBuilder < ::ActiveRecord::Associations::Builder::BelongsTo
+      def self.create_reflection(model, name, scope, options, &)
+        fail ArgumentError, "association names must be a Symbol" unless name.is_a?(Symbol)
+
+        validate_options(options)
+
+        extension = define_extensions(model, name, &)
+        options[:extend] = [*options[:extend], extension] if extension
+
+        scope = build_scope(scope)
+
+        fail "not implemented" if options[:through]
+        BelongsToMasterPolymorphicReflection.new(name, scope, options, model)
+      end
+    end
+  end
+end

data/lib/simple_master/active_record/extension.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  module ActiveRecord
+    module Extension
+      extend ActiveSupport::Concern
+
+      included do
+        def master_dirty
+          @master_dirty ||= {}
+        end
+
+        def initialize_dup(*_)
+          @master_dirty = {}
+          super
+        end
+
+        class << self
+          def simple_master_connection
+            self
+          end
+
+          def simple_master_association_options
+            @simple_master_association_options ||= {}
+          end
+
+          def belongs_to(name, scope = nil, **options)
+            unless options[:polymorphic]
+              class_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+
+              klass = compute_type(class_name.to_s)
+              if klass < SimpleMaster::Master
+                return belongs_to_master(name, options)
+              else
+                return super
+              end
+            end
+
+            reflection = BelongsToPolymorphicBuilder.build(self, name, scope, options)
+            ::ActiveRecord::Reflection.add_reflection self, name, reflection
+          end
+
+          def belongs_to_master(name, options = EMPTY_HASH)
+            simple_master_association_options[name] = options.dup
+
+            class_name = options.delete(:class_name) || ActiveSupport::Inflector.classify(name)
+            foreign_key = options.delete(:foreign_key) || ActiveSupport::Inflector.foreign_key(name)
+            primary_key = options.delete(:primary_key) || :id
+
+            warn "Options not supported! #{options}" unless options.empty?
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              Module.new {
+                def #{name}
+                  master_dirty[:#{name}] || #{class_name}.find_by_#{primary_key}(#{foreign_key})
+                end
+
+                def #{name}=(value)
+                  if value == nil
+                    self.#{foreign_key} = nil
+                    master_dirty.delete(:#{name})
+                  else
+                    @_association_#{name}_source = self.#{foreign_key} = value.#{primary_key}
+
+                    master_dirty[:#{name}] = value
+                  end
+                end
+
+                def #{foreign_key}=(value)
+                  master_dirty.delete(:#{name})
+                  super
+                end
+              }.tap { |mod| include mod }
+
+              before_save do
+                if master_dirty[:#{name}]
+                  master = master_dirty.delete(:#{name})
+                  # Skip saving the association if the key was changed after assignment
+                  if @_association_#{name}_source != #{foreign_key}
+                    next
+                  end
+                  master.save
+                  self.#{name} = master
+                end
+              end
+            RUBY
+          end
+
+          def has_one(name, scope = nil, **options)
+            return super if options[:through]
+
+            class_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+
+            klass = compute_type(class_name.to_s)
+            if klass < SimpleMaster::Master
+              has_one_master(name, options)
+            else
+              super
+            end
+          end
+
+          def has_one_master(name, options = EMPTY_HASH)
+            simple_master_association_options[name] = options.dup
+
+            class_name = options.delete(:class_name) || ActiveSupport::Inflector.classify(name)
+            foreign_key = options.delete(:foreign_key) || ActiveSupport::Inflector.foreign_key(to_s)
+            primary_key = options.delete(:primary_key) || :id
+
+            warn "Options not supported! #{options}" unless options.empty?
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              Module.new {
+                def #{name}
+                  #{class_name}.find_by(:#{foreign_key}, #{primary_key})
+                end
+              }.tap { |mod| include mod }
+            RUBY
+          end
+
+          def has_many(name, scope = nil, **options)
+            return super if options[:through]
+
+            class_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+
+            klass = compute_type(class_name.to_s)
+            if klass < SimpleMaster::Master
+              has_many_master(name, options)
+            else
+              super
+            end
+          end
+
+          def has_many_master(name, options = EMPTY_HASH)
+            simple_master_association_options[name] = options.dup
+
+            class_name = options.delete(:class_name) || ActiveSupport::Inflector.classify(name)
+            foreign_key = options.delete(:foreign_key) || ActiveSupport::Inflector.foreign_key(to_s)
+            primary_key = options.delete(:primary_key) || :id
+            inverse_of = options.delete(:inverse_of)
+
+            warn "Options not supported! #{options}" unless options.empty?
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              Module.new {
+                def #{name}
+                  master_dirty[:#{name}] || #{class_name}.all_by(:#{foreign_key}, #{primary_key})
+                end
+
+                def #{name}=(values)
+                  master_dirty[:#{name}] = values
+                end
+              }.tap { |mod| include mod }
+            RUBY
+
+            if inverse_of
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                after_save do
+                  if master_dirty[:#{name}]
+                    master_dirty.delete(:#{name}).each do |master|
+                      master.#{inverse_of} = self
+                      master.save
+                    end
+                  end
+                end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                after_save do
+                  if master_dirty[:#{name}]
+                    master_dirty.delete(:#{name}).each do |master|
+                      master.#{foreign_key} = self.id
+                      master.save
+                    end
+                  end
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/active_record/preloader_association_extension.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  module ActiveRecord
+    module PreloaderAssociationExtension
+      def run?
+        super || klass < SimpleMaster::Master
+      end
+    end
+  end
+end

data/lib/simple_master/active_record.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  module ActiveRecord
+  end
+end
+
+require "simple_master/active_record/belongs_to_master_polymorphic_reflection"
+require "simple_master/active_record/belongs_to_polymorphic_association"
+require "simple_master/active_record/belongs_to_polymorphic_builder"
+require "simple_master/active_record/extension"
+require "simple_master/active_record/preloader_association_extension"

data/lib/simple_master/loader/dataset_loader.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Loader
+    class DatasetLoader < Loader
+      # options: dataset: ...
+      def read_raw(table)
+        dataset.table(table.klass)
+      end
+
+      def build_records(_klass, raw)
+        raw.all
+      end
+
+      def dataset
+        @options[:dataset]
+      end
+    end
+  end
+end

data/lib/simple_master/loader/marshal_loader.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Loader
+    class MarshalLoader < Loader
+      def read_raw(table)
+        File.read("#{@options[:path]}/#{table.klass.table_name}.marshal")
+      end
+
+      def build_records(_klass, raw)
+        Marshal.load(raw) # rubocop:disable Security/MarshalLoad
+      end
+    end
+  end
+end

data/lib/simple_master/loader/query_loader.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Loader
+    class QueryLoader < Loader
+      def read_raw(table)
+        klass = table.klass
+        unless klass.table_available?
+          return { columns: EMPTY_ARRAY, rows: EMPTY_ARRAY }
+        end
+
+        result = klass.query_select_all
+
+        { columns: result.columns, rows: result.rows }
+      end
+
+      def build_records(klass, raw)
+        columns = raw[:columns].map(&:to_sym)
+
+        column_assign_methods = columns.map { :"#{_1}=" }
+        columns_hash = klass.columns_hash
+        sti_column_index = columns.find_index { columns_hash[_1].is_a?(Master::Column::StiTypeColumn) }
+
+        columns.each do |column_name|
+          unless klass.method_defined?(:"#{column_name}=")
+            if ENV["RAILS_ENV"] == "development"
+              # In local/dev, define a no-op setter so loading does not raise
+              klass.define_method(:"#{column_name}=", &:itself)
+              warn "#{klass}.#{column_name} column is not defined!"
+            else
+              fail "#{klass}.#{column_name} column is not defined!"
+            end
+          end
+        end
+
+        raw[:rows].filter_map { |row|
+          begin
+            record =
+              if sti_column_index
+                child_klass = ActiveSupport::Inflector.constantize(row[sti_column_index])
+                if child_klass == klass || child_klass.sti_base_class == klass
+                  child_klass.new
+                else
+                  warn "[#{klass}] Invalid value in the type column: #{row}"
+                  next
+                end
+              else
+                klass.new
+              end
+
+            column_assign_methods.zip(row) do |assign_method, value|
+              record.send(assign_method, value)
+            end
+
+            record
+          rescue
+            nil
+          end
+        }.freeze
+      end
+    end
+  end
+end

data/lib/simple_master/loader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Loader
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Returns if records are updated in table.
+    def load_records(table)
+      klass = table.klass
+      fail "Load target not available." unless klass.base_class?
+
+      raw = read_raw(table)
+
+      new_digest = table.diff.nil? ? raw.hash : "#{raw.hash}/#{table.diff.hash}"
+      if new_digest == table.digest
+        return false
+      end
+
+      table.digest = new_digest
+      table.all = build_records(klass, raw).freeze
+      globalize(table)
+
+      table.apply_diff
+
+      table.update_sub_tables
+
+      klass.reset_object_cache
+
+      true
+    end
+
+    # Interface for loader loading raw data, for building records and table digest.
+    def read_raw(table)
+      fail NotImplementedError
+    end
+
+    # Interface for building records from raw data.
+    def build_records(klass, raw)
+      fail NotImplementedError
+    end
+
+    def globalize(table)
+      return unless options[:globalize_proc]
+      table.all = options[:globalize_proc].call(table.klass, table.all)
+    end
+  end
+end
+
+require "simple_master/loader/dataset_loader"
+require "simple_master/loader/marshal_loader"
+require "simple_master/loader/query_loader"

data/lib/simple_master/master/association/belongs_to_association.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Association
+      class BelongsToAssociation < self
+        def foreign_key
+          @foreign_key ||= (options[:foreign_key] || ActiveSupport::Inflector.foreign_key(name)).to_sym
+        end
+
+        def primary_key
+          @primary_key ||= options[:primary_key] || target_class.primary_key || :id
+        end
+
+        def init(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if #{target_class} < SimpleMaster::Master
+              def #{name}
+                return nil unless #{foreign_key}
+
+                #{search_code}
+              end
+            else
+              def #{name}
+                return nil unless #{foreign_key}
+
+                belongs_to_store[:#{name}] ||= #{target_class}.simple_master_connection.find_by_#{primary_key}(#{foreign_key})
+              end
+            end
+          RUBY
+        end
+
+        def init_for_test(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if #{target_class} < SimpleMaster::Master
+              def #{name}
+                return belongs_to_store[:#{name}] if belongs_to_store[:#{name}]
+                return nil unless #{foreign_key}
+
+                #{search_code}
+              end
+            else
+              def #{name}
+                return nil unless #{foreign_key}
+
+                belongs_to_store[:#{name}] ||= #{target_class}.simple_master_connection.find_by_#{primary_key}(#{foreign_key})
+              end
+            end
+
+            def #{name}=(value)
+              @_association_#{name}_source = self.#{foreign_key} = value&.#{primary_key}
+              belongs_to_store[:#{name}] = value
+            end
+
+            def _#{name}_target_save?
+              # Skip saving the association if the key changed after assignment
+              return false if @_association_#{name}_source != #{foreign_key}
+
+              target = belongs_to_store[:#{name}]
+              return false if target.nil?
+
+              true
+            end
+          RUBY
+        end
+
+        private
+
+        def search_code
+          if primary_key == :id
+            "#{target_class}.find_by_id(#{foreign_key})"
+          else
+            "#{target_class}.find_by(:#{primary_key}, #{foreign_key})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/association/belongs_to_polymorphic_association.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Association
+      class BelongsToPolymorphicAssociation < self
+        def foreign_key
+          @foreign_key ||= (options[:foreign_key] || ActiveSupport::Inflector.foreign_key(name)).to_sym
+        end
+
+        def foreign_type
+          @foreign_type ||= options[:foreign_type] || :"#{name}_type"
+        end
+
+        def foreign_type_class
+          @foreign_type_class ||= :"#{foreign_type}_class"
+        end
+
+        def is_active_record?
+          # target_class will be dynamically loaded.
+          false
+        end
+
+        def target_class
+          fail
+        end
+
+        def init(master_class)
+          unless master_class.method_defined?(foreign_type_class)
+            fail "[#{master_class}] Please specify `polymorphic_type: true` on polymorphic type column <#{name}>."
+          end
+
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              return nil if #{foreign_type_class}.nil?
+
+              if #{foreign_type_class} < SimpleMaster::Master
+                #{foreign_type_class}.find_by_id(#{foreign_key})
+              else
+                belongs_to_store[:#{name}] ||= #{foreign_type_class}.simple_master_connection.find_by(id: #{foreign_key})
+              end
+            end
+          RUBY
+        end
+
+        def init_for_test(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              return nil if #{foreign_type_class}.nil?
+
+              if #{foreign_type_class} < SimpleMaster::Master
+                belongs_to_store[:#{name}] || #{foreign_type_class}.find_by_id(#{foreign_key})
+              else
+                belongs_to_store[:#{name}] ||= #{foreign_type_class}.simple_master_connection.find_by(id: #{foreign_key})
+              end
+            end
+
+            def #{name}=(value)
+              @_association_#{name}_source = self.#{foreign_key} = value&.id
+              @_association_#{name}_class_source = self.#{foreign_type_class} = value&.class
+              belongs_to_store[:#{name}] = value
+            end
+
+            def _#{name}_target_save?
+              # Skip saving the association if the key changed after assignment
+              return false if @_association_#{name}_source != #{foreign_key}
+              return false if @_association_#{name}_class_source != #{foreign_type_class}
+
+              target = belongs_to_store[:#{name}]
+              return false if target.nil?
+
+              true
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/association/has_many_association.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Association
+      class HasManyAssociation < self
+        def foreign_key
+          @foreign_key ||= (options[:foreign_key] || ActiveSupport::Inflector.foreign_key(defined_at.to_s)).to_sym
+        end
+
+        def inverse_of
+          @inverse_of ||= options[:inverse_of] || ActiveSupport::Inflector.underscore(defined_at.to_s)
+        end
+
+        def primary_key
+          @primary_key ||= options[:primary_key] || defined_at.primary_key || :id
+        end
+
+        def init(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if #{target_class} < SimpleMaster::Master
+              def #{name}
+                #{target_class}.all_by(:#{foreign_key}, #{primary_key})
+              end
+            else
+              def #{name}
+                has_many_store[:#{name}] ||= #{target_class}.simple_master_connection.where(:#{foreign_key} => #{primary_key}).to_a
+              end
+            end
+          RUBY
+        end
+
+        def init_for_test(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if #{target_class} < SimpleMaster::Master
+              def #{name}
+                has_many_store[:#{name}] || #{target_class}.all_by(:#{foreign_key}, #{primary_key})
+              end
+            else
+              def #{name}
+                has_many_store[:#{name}] ||= #{target_class}.simple_master_connection.where(:#{foreign_key} => #{primary_key}).to_a
+              end
+            end
+
+            def #{name}=(values)
+              has_many_store[:#{name}] = values
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end