dynamic-active-model 0.9.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7040fc598ff4554e76a3c57dcd5fc32c37fc2592f0567af929c1a5f93319313a
-  data.tar.gz: 8601378b7117b7d612db65698025879a31a6e432952a44f2c77cab2ba027e7ca
+  metadata.gz: 2bd96e8f6ce3262f827cacc23998e10b8b3dca910ab1b1e9913cc04b97ab6eb0
+  data.tar.gz: 7491a9ec594e8e704fafdcfcc974cbcf55b09a1624774fc88879023f6799a021
 SHA512:
-  metadata.gz: a598ae139fbe14648219525a1250061089a960978b346ff40a05f392fbd6313b69ba9a8640cb17753b7dab8086d1b2d4d7c4974f9006084d57561eabeea48f3c
-  data.tar.gz: a98ea335292e8ea96d4c7bd9123749ed425dcc8e6a0da7eaf6bd9d8a188c08859fa4bf04b2d44c81920f75aa64e7f9282ff5698a2c6e0c0716949e0546da9927
+  metadata.gz: 5dcdf65ae1a4da67eb8dece874b716ac08a7bf64c6457de3e244e627620cafaf5ffe0f86055a49c806d47d53afa3365ee1873db1952d9d686da024768adb3457
+  data.tar.gz: f4294f0f89f4a6be4ec5e1d19fc74d721b869d7d60bf8f280e3de085df0649db89dda2bbb51e44f1f1113efb709219f65dd0badc543a80924d3be47432b49a71

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: {},
@@ -62,30 +70,31 @@ module DynamicActiveModel
           options = ActiveRecord::Base
                     .configurations
                     .configs_for(
-                      env_name: Rails.env,
+                      env_name: ::Rails.env,
                       name: name
                     )
                     .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/version.rb

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

metadata

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