dynamic-active-model-rails 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a7da7ef7df96bc40935c0defc56a7d05bb08a961dd8ccaf3e68638b1eacedc6
-  data.tar.gz: a454903cc4352593bf17662013b4bd2d0d3896ed4cc4ac6c4eb71e7cafc726dd
+  metadata.gz: 5a7327d58f230e0a97c0f8f16bffd96668a739ec899cbee6fae940ce3df021d4
+  data.tar.gz: 377c2ad16ae2e2f8044f382852c4771c655ea81e11985f1560c64c6d8a26acca
 SHA512:
-  metadata.gz: e1c4312ec8b9f804fc64db61d6ab9feee12d7d2dd2a29f01af146dcd9e2f599fe02394ff28ee5a43eb006474eba2a78c5f6ce4d394b94c8e4824f26b6b9b32d2
-  data.tar.gz: c5682d0674d704c08ba8da89b2cec584a5cb1231f5fe962b05705fc777f94f9f2629949aade2a785ffc915cfe40707d24fb01fdeefbdffb4fd7ac0c850592944
+  metadata.gz: e2fcb3f0522925d95fedb76004ea695c13b618b525d22dff9726ac56c965811ceb2ef74ee8017d214b598a1e3c3201d5e088806ce54c1eab2ced77ce303715d2
+  data.tar.gz: d3dccaaf31a98ed51d446e27c5c5e7bcd6a728fb4d88c89b5aef4f2c35980a297096f08587cf38e010af035efa5d4e69131cd02b46a294db0a16358aaaa321ce

data/README.md

@@ -29,6 +29,24 @@ bin/rails generate dynamic_active_model:extension grant_db users       # app/mod
 
 `--connection NAME` points the database at a `database.yml` entry. `--replica NAME` adds a reading role through `connects_to` and requires `--connection`. The generators warn if the current environment has no such entry. Without `--connection`, the database shares `ApplicationRecord`'s connection.
 
+## Rake Tasks
+
+```bash
+bin/rails dynamic_active_model:models                 # each database with its models and associations
+bin/rails dynamic_active_model:export DIR=tmp/models  # a class file per model (default tmp/dynamic_active_model)
+```
+
+`models` shows what the gem generated, without opening a console:
+
+```
+GrantDB (shares ApplicationRecord's connection), 31 models
+  GrantDB::Role (roles)
+    has_many :user_roles -> GrantDB::UserRole
+    has_many :users -> GrantDB::User, through: :user_roles
+```
+
+Connections given as a URL or config hash are shown as "custom connection", so credentials never appear in the output. `export` writes `DIR/<namespace>/<model>.rb` for every model. Use it to read the generated associations, or as a starting point when a table needs a hand-written model.
+
 ## Configuration
 
 ```ruby
@@ -79,6 +97,7 @@ The `cars_db` → `CarsDB` mapping is registered with the Rails autoloader only,
 | `parent_class:` | `'ApplicationRecord'` | Superclass of the generated abstract base class, given as a name so it can be reloaded. |
 | `connects_to:` | `nil` | Roles for Rails multi-database support, such as `{ writing: :cars, reading: :cars_replica }`, or `connects_to`'s own arguments (`{ database: ..., shards: ... }`). Can't be combined with a `connection`. |
 | `foreign_key_constraints:` | `false` | Also derive associations from the database's foreign key constraints. This catches columns like `posts.author_id → users` and self-references, and costs one query per table at build time. See the core README. |
+| `has_many_through:` | `false` | Add `has_many :through` across join models: tables with a unique index on two foreign keys, such as `user_roles`. See the core README. |
 | `extensions_path:` | `app/models/<folder>` | Directory of extension files, absolute or relative to `Rails.root`. The default folder may be absent; a configured path must exist. |
 | `extensions_suffix:` | `'.ext.rb'` | Suffix of extension files. The autoloader ignores files with this suffix. |
 

data/lib/dynamic-active-model/rails/database_definition.rb

@@ -32,6 +32,9 @@ module DynamicActiveModel
       # @return [Boolean] Whether to also relate columns through foreign key constraints
       attr_reader :foreign_key_constraints
 
+      # @return [Boolean] Whether to also add has_many :through across join models
+      attr_reader :has_many_through
+
       # @return [Hash] Custom relationship names by table and foreign key
       attr_reader :relationships
 
@@ -49,15 +52,17 @@ module DynamicActiveModel
       #   connects_to's own arguments ({ database: ..., shards: ... })
       # @param foreign_key_constraints [Boolean] Also relate columns through the database's
       #   foreign key constraints
+      # @param has_many_through [Boolean] Also add has_many :through across join models
       # @raise [ArgumentError] If both a connection and connects_to are given
       def initialize(name, connection = nil, module_name: nil, parent_class: 'ApplicationRecord',
                      extensions_path: nil, extensions_suffix: '.ext.rb', connects_to: nil,
-                     foreign_key_constraints: false)
+                     foreign_key_constraints: false, has_many_through: false)
         raise ArgumentError, 'pass either a connection or connects_to:, not both' if connection && connects_to
 
         @connection = connection
         @connects_to = connects_to && normalize_connects_to(connects_to)
         @foreign_key_constraints = foreign_key_constraints
+        @has_many_through = has_many_through
         @module_name = module_name || default_module_name(name)
         @parent_class_name = parent_class.to_s
         @extensions_path = extensions_path&.to_s

data/lib/dynamic-active-model/rails/database_loader.rb

@@ -62,7 +62,8 @@ module DynamicActiveModel
         @database = new_database
         @database.create_models!
         Explorer.build_relationships!(@database, definition.relationships,
-                                      foreign_key_constraints: definition.foreign_key_constraints)
+                                      foreign_key_constraints: definition.foreign_key_constraints,
+                                      has_many_through: definition.has_many_through)
         load_extensions
         ActiveSupport.run_load_hooks(definition.load_hook, @database)
       rescue StandardError

data/lib/dynamic-active-model/rails/model_export.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DynamicActiveModel
+  module Rails
+    # Writes a class file per model (TemplateClassFile) for every declared
+    # database, for bin/rails dynamic_active_model:export. Useful to read what
+    # the gem generates, or as a starting point for a hand-written model.
+    class ModelExport
+      # @param loaders [Array<DatabaseLoader>]
+      def initialize(loaders)
+        @loaders = loaders
+      end
+
+      # @param dir [String] Output directory; files land in dir/<namespace>/<model>.rb
+      # @return [Array<String>] Paths written
+      def export!(dir)
+        @loaders.flat_map { |loader| loader.load!.models }.map do |model|
+          DynamicActiveModel::TemplateClassFile.new(model).create_template!(dir)
+          File.join(dir, "#{model.name.underscore}.rb")
+        end
+      end
+    end
+  end
+end

data/lib/dynamic-active-model/rails/model_report.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module DynamicActiveModel
+  module Rails
+    # A plain-text listing of each declared database's models and associations,
+    # for bin/rails dynamic_active_model:models. Builds the databases it lists.
+    #
+    # @example
+    #   GrantDB (shares ApplicationRecord's connection), 2 models
+    #     GrantDB::Role (roles)
+    #       has_many :users -> GrantDB::User, through: :user_roles
+    class ModelReport
+      # @param loaders [Array<DatabaseLoader>]
+      def initialize(loaders)
+        @loaders = loaders
+      end
+
+      # @return [String]
+      def to_s
+        @loaders.map { |loader| database_section(loader) }.join("\n")
+      end
+
+      private
+
+      # @param loader [DatabaseLoader]
+      # @return [String]
+      def database_section(loader)
+        models = loader.load!.models.sort_by(&:name)
+        lines = ["#{loader.definition.module_name} (#{connection_description(loader.definition)}), " \
+                 "#{models.size} #{models.size == 1 ? 'model' : 'models'}"]
+        models.each { |model| lines.concat(model_lines(model)) }
+        "#{lines.join("\n")}\n"
+      end
+
+      # Describes the connection without printing URLs or config hashes, which
+      # can hold passwords
+      # @param definition [DatabaseDefinition]
+      # @return [String]
+      def connection_description(definition)
+        return "connects_to: #{definition.connects_to.inspect}" if definition.connects_to
+        return "connection: #{definition.connection.inspect}" if definition.connection.is_a?(Symbol)
+        return 'custom connection' if definition.connection
+
+        "shares #{definition.parent_class_name}'s connection"
+      end
+
+      # @param model [Class]
+      # @return [Array<String>]
+      def model_lines(model)
+        ["  #{model.name} (#{model.table_name})"] +
+          model.reflect_on_all_associations.sort_by { |reflection| reflection.name.to_s }.map do |reflection|
+            "    #{association_line(reflection)}"
+          end
+      end
+
+      # @param reflection [ActiveRecord::Reflection::AssociationReflection]
+      # @return [String] e.g. "has_many :users -> GrantDB::User, through: :user_roles"
+      def association_line(reflection)
+        line = "#{reflection.macro} #{reflection.name.inspect} -> #{reflection.klass.name}"
+        reflection.options[:through] ? "#{line}, through: #{reflection.options[:through].inspect}" : line
+      end
+    end
+  end
+end

data/lib/dynamic-active-model/rails/railtie.rb

@@ -7,6 +7,10 @@ module DynamicActiveModel
     class Railtie < ::Rails::Railtie
       config.eager_load_namespaces << DynamicActiveModel::Rails
 
+      rake_tasks do
+        load File.expand_path('tasks/dynamic_active_model.rake', __dir__)
+      end
+
       # so config.active_support.deprecation (log, raise in tests, ...) applies
       initializer 'dynamic_active_model.deprecator' do |app|
         app.deprecators[:dynamic_active_model] = DynamicActiveModel.deprecator

data/lib/dynamic-active-model/rails/tasks/dynamic_active_model.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+namespace :dynamic_active_model do
+  desc 'List each declared database with its models and associations'
+  task models: :environment do
+    puts DynamicActiveModel::Rails::ModelReport.new(DynamicActiveModel::Rails.loaders)
+  end
+
+  desc 'Write a class file per model to DIR (default tmp/dynamic_active_model)'
+  task export: :environment do
+    dir = ENV.fetch('DIR') { Rails.root.join('tmp', 'dynamic_active_model').to_s }
+    files = DynamicActiveModel::Rails::ModelExport.new(DynamicActiveModel::Rails.loaders).export!(dir)
+    puts "Wrote #{files.size} class files to #{dir}"
+  end
+end

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

@@ -21,6 +21,8 @@ module DynamicActiveModel
     autoload :DatabaseDefinition, 'dynamic-active-model/rails/database_definition'
     autoload :DatabaseLoader, 'dynamic-active-model/rails/database_loader'
     autoload :LazyNamespace, 'dynamic-active-model/rails/lazy_namespace'
+    autoload :ModelExport, 'dynamic-active-model/rails/model_export'
+    autoload :ModelReport, 'dynamic-active-model/rails/model_report'
     autoload :SchemaChangeHook, 'dynamic-active-model/rails/schema_change_hook'
 
     class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-active-model-rails
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Doug Youch
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -67,8 +67,11 @@ files:
 - lib/dynamic-active-model/rails/database_definition.rb
 - lib/dynamic-active-model/rails/database_loader.rb
 - lib/dynamic-active-model/rails/lazy_namespace.rb
+- lib/dynamic-active-model/rails/model_export.rb
+- lib/dynamic-active-model/rails/model_report.rb
 - lib/dynamic-active-model/rails/railtie.rb
 - lib/dynamic-active-model/rails/schema_change_hook.rb
+- lib/dynamic-active-model/rails/tasks/dynamic_active_model.rake
 - lib/generators/dynamic_active_model/database/database_generator.rb
 - lib/generators/dynamic_active_model/database_arguments.rb
 - lib/generators/dynamic_active_model/extension/extension_generator.rb