dynamic-active-model 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9f8e2e549471211eb31b49e3e20b8a72e1c47eb2e9c857bcb4a85c11e470558
-  data.tar.gz: 70b7edd5ecf3dbe9c164593f1866eb2bd12a9cb89b5c609898052b8ad3f5eee2
+  metadata.gz: 58dbefec4f0c5d98abe3cab906e9e94aa288bca95f40215569b5dabd62ba27ec
+  data.tar.gz: 98e8408169aad9ea42161a878300205e030bf70d4e43eea6bb888a03d5096cbd
 SHA512:
-  metadata.gz: 90b12783def828937bef5898a020c6e8639fbf72c83a8649f5227077fce087d1fc619bd25f472b70b83dcf6a551bc97386f57c86b76f4fdc401fbe8c92336c11
-  data.tar.gz: c3316c0eb2a01b52e3b2628c913ce1d1d53c6ba7f67a34cbfb879caa820509d5ab676e3a2f78c771ca40a3405f960e65bea4ca9674540fca3192808d32053926
+  metadata.gz: f4ddf3e3c10815ccf36c6e75c247b2f18e2e5b3dce896fd0ce8323f94910e063cc143e7013394a5eb61c373d72304b6799bde9b699ede968a1188e06969f4f5d
+  data.tar.gz: d062f596b4280e184d82a79e28f1eb5a8a0e310e408a179ef5d95df7153dbc0b9a1d522e5cf8d0639eb3b83e8ed2f4f752d353a209fc2f5cdf0fda5fc55ac264

data/lib/dynamic-active-model/associations.rb

@@ -76,7 +76,7 @@ module DynamicActiveModel
 
       @join_tables.each do |join_table_model|
         models = join_table_model.column_names.map do |column_name|
-          foreign_key_to_models[column_name.downcase]&.first&.first
+          foreign_key_to_models.dig(column_name.downcase, 0, 0)
         end.compact
         add_has_and_belongs_to_many(join_table_model, models) if models.size == 2
       end

data/lib/dynamic-active-model/database.rb

@@ -16,6 +16,10 @@ module DynamicActiveModel
   #   db.include_table 'users'
   #   db.create_models!
   #
+  # @example Rebuilding After a Schema Change
+  #   db.reset!
+  #   db.create_models!
+  #
   # @example Model Updates
   #   db.update_model(:users) do
   #     def full_name
@@ -45,8 +49,9 @@ module DynamicActiveModel
     # @param base_module [Module] The namespace for created models
     # @param connection_options [Hash] Database connection options
     # @param base_class_name [String, nil] Optional base class name for models
-    def initialize(base_module, connection_options, base_class_name = nil)
-      @factory = Factory.new(base_module, connection_options, base_class_name)
+    # @param parent_class [Class, nil] Optional superclass for the base class (see Factory)
+    def initialize(base_module, connection_options, base_class_name = nil, parent_class: nil)
+      @factory = Factory.new(base_module, connection_options, base_class_name, parent_class: parent_class)
       @table_class_names = {}
       @skip_tables = []
       @skip_table_matchers = []
@@ -106,6 +111,15 @@ module DynamicActiveModel
       @models
     end
 
+    # Removes every created model constant and the factory's base class so the
+    # next call to #create_models! rebuilds them, e.g. after a schema change
+    # @return [void]
+    def reset!
+      @models.each { |model| @factory.remove(model) }
+      @models.clear
+      @factory.reset!
+    end
+
     # @return [Array] List of all skipped tables and patterns
     def skipped_tables
       @skip_tables + @skip_table_matchers
@@ -182,11 +196,22 @@ module DynamicActiveModel
       !skip_table?(table_name) && include_table?(table_name) && get_model(table_name).nil?
     end
 
-    # Checks if a table should be skipped
+    # Checks if a table is one of ActiveRecord's bookkeeping tables
+    # (schema_migrations, ar_internal_metadata)
+    # @param table_name [String] Name of the table
+    # @return [Boolean] Whether the table is internal to ActiveRecord
+    def internal_table?(table_name)
+      base_class = @factory.base_class
+      [base_class.schema_migrations_table_name, base_class.internal_metadata_table_name].include?(table_name)
+    end
+
+    # Checks if a table should be skipped. ActiveRecord's internal tables are
+    # skipped unless included by exact name.
     # @param table_name [String] Name of the table
     # @return [Boolean] Whether the table should be skipped
     def skip_table?(table_name)
-      @skip_tables.include?(table_name.to_s) ||
+      (internal_table?(table_name) && !@include_tables.include?(table_name)) ||
+        @skip_tables.include?(table_name.to_s) ||
         @skip_table_matchers.any? { |r| r.match(table_name) }
     end
 

data/lib/dynamic-active-model/explorer.rb

@@ -29,10 +29,13 @@ module DynamicActiveModel
     # @param skip_tables [Array<String, Regexp>] Tables to exclude from model creation
     # @param relationships [Hash] Custom foreign key relationships to add
     # @param table_class_names [Hash] Custom class names by table name
+    # @param parent_class [Class, nil] Optional superclass for the base class (see Factory)
     # @return [Database] The configured database instance
     # @raise [ClassNameConflict] If two tables map to the same class name
-    def self.explore(base_module, connection_options, skip_tables = [], relationships = {}, table_class_names = {})
-      database = create_models!(base_module, connection_options, skip_tables, table_class_names)
+    def self.explore(base_module, connection_options, skip_tables = [], relationships = {}, table_class_names = {},
+                     parent_class: nil)
+      database = create_models!(base_module, connection_options, skip_tables, table_class_names,
+                                parent_class: parent_class)
       build_relationships!(database, relationships)
       database
     end
@@ -42,9 +45,10 @@ module DynamicActiveModel
     # @param connection_options [Hash] Database connection options
     # @param skip_tables [Array<String, Regexp>] Tables to exclude from model creation
     # @param table_class_names [Hash] Custom class names by table name
+    # @param parent_class [Class, nil] Optional superclass for the base class (see Factory)
     # @return [Database] The configured database instance
-    def self.create_models!(base_module, connection_options, skip_tables, table_class_names = {})
-      database = Database.new(base_module, connection_options)
+    def self.create_models!(base_module, connection_options, skip_tables, table_class_names = {}, parent_class: nil)
+      database = Database.new(base_module, connection_options, parent_class: parent_class)
       skip_tables.each { |table| database.skip_table(skip_table_matcher(table)) }
       table_class_names.each { |table_name, class_name| database.table_class_name(table_name, class_name) }
       database.create_models!

data/lib/dynamic-active-model/factory.rb

@@ -15,6 +15,10 @@ module DynamicActiveModel
   # @example With Custom Class Name
   #   factory = DynamicActiveModel::Factory.new(DB, database_config)
   #   model = factory.create('users', 'CustomUser')
+  #
+  # @example Sharing an Existing Connection Pool
+  #   factory = DynamicActiveModel::Factory.new(DB, nil, parent_class: ApplicationRecord)
+  #   model = factory.create('users')
   class Factory
     # @return [Class] The base class for all generated models
     attr_writer :base_class
@@ -23,10 +27,13 @@ module DynamicActiveModel
     # @param base_module [Module] The namespace for created models
     # @param connection_options [Hash] Database connection options
     # @param base_class_name [Symbol, nil] Optional name for the base class
-    def initialize(base_module, connection_options, base_class_name = nil)
+    # @param parent_class [Class, nil] Optional superclass for the base class. When given
+    #   without connection options, the base class inherits the parent's connection.
+    def initialize(base_module, connection_options, base_class_name = nil, parent_class: nil)
       @base_module = base_module
       @connection_options = connection_options
       @base_class_name = base_class_name || :DynamicAbstractBase
+      @parent_class = parent_class
     end
 
     # Creates a new model class for a table if it doesn't exist
@@ -56,8 +63,8 @@ module DynamicActiveModel
 
     # Gets or creates the base class for all models
     # This method:
-    # 1. Creates an abstract ActiveRecord::Base subclass if needed
-    # 2. Establishes the database connection
+    # 1. Creates an abstract subclass of the parent class if needed
+    # 2. Establishes the database connection, unless inheriting the parent's
     # 3. Returns the configured base class
     # @return [Class] The base class for all models
     def base_class
@@ -65,19 +72,30 @@ module DynamicActiveModel
         begin
           require 'active_record'
 
-          unless @base_module.const_defined?(@base_class_name)
-            new_base_class = Class.new(ActiveRecord::Base) do
-              self.abstract_class = true
-            end
-            @base_module.const_set(@base_class_name, new_base_class)
-          end
+          define_base_class unless @base_module.const_defined?(@base_class_name)
 
           @base_module.const_get(@base_class_name).tap do |kls|
-            kls.establish_connection @connection_options
+            kls.establish_connection(@connection_options) if establish_connection?
           end
         end
     end
 
+    # Removes a model's constant from the base module
+    # @param model [Class] A model class created by this factory
+    # @return [void]
+    def remove(model)
+      @base_module.send(:remove_const, model.name.demodulize)
+    end
+
+    # Removes the base class constant if this factory defined it and forgets the
+    # cached base class, so the next call to #base_class builds a fresh one
+    # @return [void]
+    def reset!
+      @base_module.send(:remove_const, @base_class_name) if @defined_base_class
+      @defined_base_class = false
+      @base_class = nil
+    end
+
     # Generates a valid Ruby class name from a table name
     # @param table_name [String] Name of the database table
     # @return [String] A valid Ruby class name
@@ -90,6 +108,22 @@ module DynamicActiveModel
 
     private
 
+    # Defines the abstract base class in the base module
+    # @return [void]
+    def define_base_class
+      new_base_class = Class.new(@parent_class || ActiveRecord::Base) do
+        self.abstract_class = true
+      end
+      @base_module.const_set(@base_class_name, new_base_class)
+      @defined_base_class = true
+    end
+
+    # Checks if the base class needs its own connection
+    # @return [Boolean] False when inheriting the parent class's connection
+    def establish_connection?
+      @parent_class.nil? || !@connection_options.nil?
+    end
+
     # Returns the existing model for a class name if it belongs to the table
     # @param table_name [String] Name of the database table
     # @param class_name [String] Name of the existing class

data/lib/dynamic-active-model/setup.rb

@@ -18,6 +18,13 @@ module DynamicActiveModel
   #     create_models!
   #   end
   #
+  # @example Sharing ApplicationRecord's Connection
+  #   module DB
+  #     include DynamicActiveModel::Setup
+  #     parent_class ApplicationRecord
+  #     create_models!
+  #   end
+  #
   # @example With Custom Relationships
   #   module DB
   #     include DynamicActiveModel::Setup
@@ -45,6 +52,7 @@ module DynamicActiveModel
       def dynamic_active_model_config
         {
           connection_options: nil,
+          parent_class: nil,
           skip_tables: [],
           relationships: {},
           table_class_names: {},
@@ -68,24 +76,25 @@ module DynamicActiveModel
                     .configuration_hash
         end
 
-        if options
-          config = dynamic_active_model_config
-          config[:connection_options] = options
-          redefine_class_method(:dynamic_active_model_config, config)
-        end
+        update_config(:connection_options, options) if options
 
         dynamic_active_model_config[:connection_options]
       end
 
+      # Sets or gets the superclass for the generated base class. Without connection
+      # options, models inherit the parent class's connection.
+      # @param klass [Class, nil] Superclass, e.g. ApplicationRecord
+      # @return [Class, nil] The current parent class
+      def parent_class(klass = nil)
+        update_config(:parent_class, klass) if klass
+        dynamic_active_model_config[:parent_class]
+      end
+
       # Sets or gets the list of tables to skip
       # @param tables [Array<String>, nil] Tables to skip
       # @return [Array<String>] The current list of skipped tables
       def skip_tables(tables = nil)
-        if tables
-          config = dynamic_active_model_config
-          config[:skip_tables] = tables
-          redefine_class_method(:dynamic_active_model_config, config)
-        end
+        update_config(:skip_tables, tables) if tables
         dynamic_active_model_config[:skip_tables]
       end
 
@@ -101,11 +110,7 @@ module DynamicActiveModel
       # @param all_relationships [Hash, nil] All custom relationships
       # @return [Hash] The current relationships
       def relationships(all_relationships = nil)
-        if all_relationships
-          config = dynamic_active_model_config
-          config[:relationships] = all_relationships
-          redefine_class_method(:dynamic_active_model_config, config)
-        end
+        update_config(:relationships, all_relationships) if all_relationships
         dynamic_active_model_config[:relationships]
       end
 
@@ -140,11 +145,7 @@ module DynamicActiveModel
       # @param path [String, nil] Path to extension files
       # @return [String, nil] The current extensions path
       def extensions_path(path = nil)
-        if path
-          config = dynamic_active_model_config
-          config[:extensions_path] = path
-          redefine_class_method(:dynamic_active_model_config, config)
-        end
+        update_config(:extensions_path, path) if path
         dynamic_active_model_config[:extensions_path]
       end
 
@@ -152,11 +153,7 @@ module DynamicActiveModel
       # @param suffix [String, nil] File extension suffix
       # @return [String] The current extensions suffix
       def extensions_suffix(suffix = nil)
-        if suffix
-          config = dynamic_active_model_config
-          config[:extensions_suffix] = suffix
-          redefine_class_method(:dynamic_active_model_config, config)
-        end
+        update_config(:extensions_suffix, suffix) if suffix
         dynamic_active_model_config[:extensions_suffix]
       end
 
@@ -173,12 +170,24 @@ module DynamicActiveModel
             connection_options,
             skip_tables,
             relationships,
-            table_class_names
+            table_class_names,
+            parent_class: parent_class
           )
         )
         database.update_all_models(extensions_path, extensions_suffix) if extensions_path
         database
       end
+
+      private
+
+      # Stores a single configuration value
+      # @param key [Symbol] Configuration key
+      # @param value [Object] Configuration value
+      def update_config(key, value)
+        config = dynamic_active_model_config
+        config[key] = value
+        redefine_class_method(:dynamic_active_model_config, config)
+      end
     end
   end
 end

data/lib/dynamic-active-model/template_class_file.rb

@@ -42,16 +42,17 @@ module DynamicActiveModel
         str << "  self.table_name = #{@model.table_name.to_sym.inspect}\n"
       end
       all_has_many_relationships.each do |assoc|
-        append_association!(str, assoc)
+        append_association!(str, 'has_many', assoc, has_many_association_options(assoc))
       end
       all_belongs_to_relationships.each do |assoc|
-        append_association!(str, assoc)
+        append_association!(str, 'belongs_to', assoc, belongs_to_association_options(assoc))
       end
       all_has_one_relationships.each do |assoc|
-        append_association!(str, assoc)
+        append_association!(str, 'has_one', assoc, has_one_association_options(assoc))
       end
       all_has_and_belongs_to_many_relationships.each do |assoc|
-        append_association!(str, assoc)
+        append_association!(str, 'has_and_belongs_to_many', assoc,
+                            has_and_belongs_to_many_association_options(assoc))
       end
       str << "end\n"
       str
@@ -85,35 +86,13 @@ module DynamicActiveModel
 
     # Appends an association definition to the source string
     # @param str [String] The source string being built
+    # @param assoc_type [String] The association macro, e.g. 'has_many'
     # @param assoc [ActiveRecord::Reflection::AssociationReflection] The association to add
-    def append_association!(str, assoc)
-      assoc_type = case assoc
-                   when ActiveRecord::Reflection::HasManyReflection
-                     'has_many'
-                   when ActiveRecord::Reflection::BelongsToReflection
-                     'belongs_to'
-                   when ActiveRecord::Reflection::HasOneReflection
-                     'has_one'
-                   when ActiveRecord::Reflection::HasAndBelongsToManyReflection
-                     'has_and_belongs_to_many'
-                   end
-
-      association_options = case assoc_type
-                            when 'has_many'
-                              has_many_association_options(assoc)
-                            when 'belongs_to'
-                              belongs_to_association_options(assoc)
-                            when 'has_one'
-                              has_one_association_options(assoc)
-                            when 'has_and_belongs_to_many'
-                              has_and_belongs_to_many_association_options(assoc)
-                            end
-
+    # @param association_options [Hash] Non-default options to write; nil values are skipped
+    def append_association!(str, assoc_type, assoc, association_options)
       str << "  #{assoc_type} #{assoc.name.inspect}"
-      unless association_options.empty?
-        association_options.each do |name, value|
-          str << ", #{name}: '#{value}'"
-        end
+      association_options.compact.each do |name, value|
+        str << ", #{name}: '#{value}'"
       end
       str << "\n"
     end
@@ -166,7 +145,7 @@ module DynamicActiveModel
     def has_and_belongs_to_many_association_options(assoc)
       options = {}
       options[:join_table] = assoc.options[:join_table] if assoc.options[:join_table]
-      unless assoc.options[:class_name].underscore.singularize == assoc.name.to_s
+      unless assoc.options[:class_name].underscore.pluralize == assoc.name.to_s
         options[:class_name] =
           assoc.options[:class_name]
       end
@@ -178,19 +157,5 @@ module DynamicActiveModel
     def default_foreign_key_name
       "#{@model.table_name.underscore.singularize}_id"
     end
-
-    # Generates the default foreign key for the associated model
-    # @param assoc [ActiveRecord::Reflection::HasAndBelongsToManyReflection] The association
-    # @return [String] The generated foreign key name
-    def generate_association_foreign_key(assoc)
-      "#{assoc.options[:class_name].underscore.singularize}_id"
-    end
-
-    # Gets a constant by its fully qualified name
-    # @param class_name [String] The fully qualified class name
-    # @return [Class] The resolved class
-    def const_get(class_name)
-      class_name.split('::').inject(Object) { |mod, name| mod.const_get(name) }
-    end
   end
 end

data/lib/dynamic-active-model/version.rb

@@ -2,5 +2,5 @@
 
 module DynamicActiveModel
   # Gem version, bumped by release-please
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-active-model
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Doug Youch