dynamic-active-model 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b97bc188a4c9b06a6cfa87bf1af11ef77bd1e80dbf795b61992d90a940202f8
-  data.tar.gz: add2284f1e7f247f47bb3146b145bb8fe8880baa95acc37b904c791d4077c24d
+  metadata.gz: b13a9d41753ab707e9a414bb36ffd043c4362d09764717f4b43770ba8c0e0731
+  data.tar.gz: 2ed3a9b28b4e9a0825b19acf97f9b95deb8cd99bf312ed6006112f8bbd2573d1
 SHA512:
-  metadata.gz: 9a185c609164a98c20d755c47d45db2ed059aebe42811d15c987ebb8f3e18d8dd6b7101e714252d046b85ef0f42cad1997d557ead86d0fac534a18314751bac5
-  data.tar.gz: 6dc01aefd21b1dce01a1b4bc9926bd4424a25da6fb0bbcaeb728b6692fff88de984567f2fa988e4dbde917d996b3a2166bfa6d19671fa1831438e745700f25f7
+  metadata.gz: 86c16133679c95f1e79a24745f2d474c5b5645aadcd6609dcddfe0a347e0545ef618a24ee96b9d674f742b75d03fa0cc90c964400c4ca3e8c89019de8988214a
+  data.tar.gz: acb55a31da056e1f4d5b5d816a61cd45464262b7b6bf4df84b9f56e3400e4d0767561c933e8bce43bc3718e4de7088bd108fa5124a6ecb8f66ec4ef03d9b3134

data/bin/dynamic-db-explorer

@@ -70,6 +70,10 @@ OptionParser.new do |opts|
     options[:foreign_key_constraints] = true
   end
 
+  opts.on('--has-many-through', 'Also add has_many :through across join models') do
+    options[:has_many_through] = true
+  end
+
   opts.on('-c', '--config FILE', "config file, default #{DEFAULT_CONFIG_FILE}") do |v|
     options[:config_file] = v
   end
@@ -96,6 +100,7 @@ if options[:config_file]
   options[:skip_tables] = config.delete('skip_tables') || []
   options[:relationships] = config.delete('relationships') || {}
   options[:foreign_key_constraints] ||= config.delete('foreign_key_constraints') || false
+  options[:has_many_through] ||= config.delete('has_many_through') || false
   if (module_name = config.delete('module'))
     raise ArgumentError, "Invalid module name: #{module_name}" unless module_name.match?(/\A[A-Z][A-Za-z0-9_]*\z/)
 
@@ -110,7 +115,8 @@ DYNAMIC_DATABASE = DynamicActiveModel::Explorer.explore(
   options[:connection_options],
   options[:skip_tables],
   options[:relationships],
-  foreign_key_constraints: options[:foreign_key_constraints] || false
+  foreign_key_constraints: options[:foreign_key_constraints] || false,
+  has_many_through: options[:has_many_through] || false
 )
 
 if options[:class_files_dir]

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

@@ -60,6 +60,12 @@ module DynamicActiveModel
       @constraints = ForeignKeyConstraints.new(@database)
     end
 
+    # Also adds has_many :through associations across join models (see HasManyThrough)
+    # @return [void]
+    def use_has_many_through!
+      @has_many_through = true
+    end
+
     # Builds all relationships between models based on foreign keys and constraints
     # This method:
     # 1. Maps foreign keys to their corresponding models
@@ -80,6 +86,8 @@ module DynamicActiveModel
         end.compact
         add_has_and_belongs_to_many(join_table_model, models) if models.size == 2
       end
+
+      HasManyThrough.new(@database.models, table_indexes).build! if @has_many_through
     end
 
     private

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

@@ -14,8 +14,9 @@ module DynamicActiveModel
   #   skip_tables = ['temporary_data', 'audit_logs']
   #   DynamicActiveModel::Explorer.explore(DB, database_config, skip_tables)
   #
-  # @example With Foreign Key Constraints
-  #   DynamicActiveModel::Explorer.explore(DB, database_config, foreign_key_constraints: true)
+  # @example With Foreign Key Constraints and has_many :through
+  #   DynamicActiveModel::Explorer.explore(DB, database_config, foreign_key_constraints: true,
+  #                                                             has_many_through: true)
   #
   # @example With Custom Relationships
   #   relationships = {
@@ -35,13 +36,16 @@ module DynamicActiveModel
     # @param parent_class [Class, nil] Optional superclass for the base class (see Factory)
     # @param foreign_key_constraints [Boolean] Also relate columns through the database's
     #   foreign key constraints (see ForeignKeyConstraints)
+    # @param has_many_through [Boolean] Also add has_many :through across join models
+    #   (see HasManyThrough)
     # @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 = {},
-                     parent_class: nil, foreign_key_constraints: false)
+                     parent_class: nil, foreign_key_constraints: false, has_many_through: false)
       database = create_models!(base_module, connection_options, skip_tables, table_class_names,
                                 parent_class: parent_class)
-      build_relationships!(database, relationships, foreign_key_constraints: foreign_key_constraints)
+      build_relationships!(database, relationships, foreign_key_constraints: foreign_key_constraints,
+                                                    has_many_through: has_many_through)
       database
     end
 
@@ -73,10 +77,12 @@ module DynamicActiveModel
     # @param database [Database] The database instance containing the models
     # @param relationships [Hash] Custom foreign key relationships to add
     # @param foreign_key_constraints [Boolean] Also relate columns through foreign key constraints
+    # @param has_many_through [Boolean] Also add has_many :through across join models
     # @return [void]
-    def self.build_relationships!(database, relationships, foreign_key_constraints: false)
+    def self.build_relationships!(database, relationships, foreign_key_constraints: false, has_many_through: false)
       relations = Associations.new(database)
       relations.use_foreign_key_constraints! if foreign_key_constraints
+      relations.use_has_many_through! if has_many_through
       relationships.each do |table_name, foreign_keys|
         foreign_keys.each do |foreign_key, relationship_name|
           relations.add_foreign_key(table_name, foreign_key, relationship_name)

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module DynamicActiveModel
+  # Adds has_many :through associations across join models. A join model is a
+  # table with a primary key and a unique index on exactly two columns, each a
+  # belongs_to to a different model; other columns (timestamps, audit columns,
+  # extra data) don't matter. For user_roles with a unique (user_id, role_id):
+  #
+  #   User has_many :roles, through: :user_roles, source: :role
+  #   Role has_many :users, through: :user_roles, source: :user
+  #
+  # A name already taken on the model (association, method or column) is skipped.
+  # Tables without a primary key are has_and_belongs_to_many join tables instead.
+  class HasManyThrough
+    # @param models [Array<Class>] Models with their belongs_to/has_many already built
+    # @param table_indexes [Hash] Indexes by table name (see Associations#table_indexes)
+    def initialize(models, table_indexes)
+      @models = models
+      @table_indexes = table_indexes
+    end
+
+    # @return [void]
+    def build!
+      @models.each { |model| add_through_associations(model) }
+    end
+
+    private
+
+    # @param join_model [Class]
+    def add_through_associations(join_model)
+      pair = join_belongs_to(join_model)
+      return unless pair
+
+      first, second = pair
+      add_through(join_model, first, second)
+      add_through(join_model, second, first)
+    end
+
+    # @param model [Class]
+    # @return [Array<ActiveRecord::Reflection::BelongsToReflection>, nil] The two
+    #   belongs_to a unique two-column index covers, if the model is a join model
+    def join_belongs_to(model)
+      return unless model.primary_key.is_a?(String)
+
+      @table_indexes.fetch(model.table_name, []).each do |index|
+        next unless index.unique && index.columns.is_a?(Array) && index.columns.size == 2
+
+        reflections = index.columns.map { |column| belongs_to_for(model, column) }
+        return reflections if reflections.all? && reflections.map(&:klass).uniq.size == 2
+      end
+      nil
+    end
+
+    # @return [ActiveRecord::Reflection::BelongsToReflection, nil]
+    def belongs_to_for(model, column)
+      model.reflect_on_all_associations(:belongs_to).find { |reflection| reflection.foreign_key.to_s == column }
+    end
+
+    # Gives the owner side of the join a has_many :through to the target side
+    # @param join_model [Class]
+    # @param owner [ActiveRecord::Reflection::BelongsToReflection] e.g. user_roles.user
+    # @param target [ActiveRecord::Reflection::BelongsToReflection] e.g. user_roles.role
+    def add_through(join_model, owner, target)
+      through = join_association(owner.klass, join_model, owner.foreign_key.to_s)
+      name = target.name.to_s.pluralize.to_sym
+      return if through.nil? || taken?(owner.klass, name)
+
+      owner.klass.has_many(name, through: through.name, source: target.name)
+    end
+
+    # @return [ActiveRecord::Reflection::HasManyReflection, nil] The owner's has_many
+    #   to the join model over that foreign key, e.g. User has_many :user_roles
+    def join_association(owner_model, join_model, foreign_key)
+      owner_model.reflect_on_all_associations(:has_many).find do |reflection|
+        reflection.options[:class_name] == join_model.name && reflection.options[:foreign_key].to_s == foreign_key
+      end
+    end
+
+    # @return [Boolean] Whether the name is already an association, method or column
+    def taken?(model, name)
+      !model.reflect_on_association(name).nil? || model.method_defined?(name) ||
+        model.column_names.include?(name.to_s)
+    end
+  end
+end

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

@@ -54,6 +54,7 @@ module DynamicActiveModel
           connection_options: nil,
           parent_class: nil,
           foreign_key_constraints: false,
+          has_many_through: false,
           skip_tables: [],
           relationships: {},
           table_class_names: {},
@@ -94,6 +95,15 @@ module DynamicActiveModel
         dynamic_active_model_config[:foreign_key_constraints]
       end
 
+      # Sets or gets whether has_many :through associations are added across join
+      # models (see HasManyThrough)
+      # @param enabled [Boolean, nil]
+      # @return [Boolean] The current setting
+      def has_many_through(enabled = nil) # rubocop:disable Naming/PredicatePrefix -- DSL setter/getter
+        update_config(:has_many_through, enabled) unless enabled.nil?
+        dynamic_active_model_config[:has_many_through]
+      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
@@ -176,7 +186,8 @@ module DynamicActiveModel
             relationships,
             table_class_names,
             parent_class: parent_class,
-            foreign_key_constraints: foreign_key_constraints
+            foreign_key_constraints: foreign_key_constraints,
+            has_many_through: has_many_through
           )
         )
         database.update_all_models(extensions_path, extensions_suffix) if extensions_path

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+
 module DynamicActiveModel
   # The TemplateClassFile class generates Ruby source files for ActiveRecord models.
   # It creates properly formatted class definitions that include:
@@ -26,11 +28,13 @@ module DynamicActiveModel
       @model = model
     end
 
-    # Creates a Ruby source file for the model
+    # Creates a Ruby source file for the model, at dir/<namespace>/<model>.rb
     # @param dir [String] Directory to create the file in
     # @return [void]
     def create_template!(dir)
       file = "#{dir}/#{@model.name.underscore}.rb"
+      # the namespace directory (e.g. db/ for DB::User) may not exist yet
+      FileUtils.mkdir_p(File.dirname(file))
       File.binwrite(file, to_s)
     end
 
@@ -44,6 +48,7 @@ module DynamicActiveModel
       all_has_many_relationships.each do |assoc|
         append_association!(str, 'has_many', assoc, has_many_association_options(assoc))
       end
+      all_has_many_through_relationships.each { |assoc| append_through_association!(str, assoc) }
       all_belongs_to_relationships.each do |assoc|
         append_association!(str, 'belongs_to', assoc, belongs_to_association_options(assoc))
       end
@@ -66,6 +71,12 @@ module DynamicActiveModel
       @model.reflect_on_all_associations.grep(ActiveRecord::Reflection::HasManyReflection)
     end
 
+    # Gets all has_many :through relationships for the model
+    # @return [Array] List of has_many :through associations
+    def all_has_many_through_relationships
+      @model.reflect_on_all_associations(:has_many).grep(ActiveRecord::Reflection::ThroughReflection)
+    end
+
     # Gets all belongs_to relationships for the model
     # @return [Array<ActiveRecord::Reflection::BelongsToReflection>]
     def all_belongs_to_relationships
@@ -84,6 +95,14 @@ module DynamicActiveModel
       @model.reflect_on_all_associations.grep(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
     end
 
+    # Appends a has_many :through declaration; through and source are symbols
+    # @param str [String] The source string being built
+    # @param assoc [ActiveRecord::Reflection::ThroughReflection] The association to add
+    def append_through_association!(str, assoc)
+      str << "  has_many #{assoc.name.inspect}, through: #{assoc.options[:through].to_sym.inspect}, " \
+             "source: #{assoc.options[:source].to_sym.inspect}\n"
+    end
+
     # 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'

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

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

data/lib/dynamic-active-model.rb

@@ -40,6 +40,9 @@ module DynamicActiveModel
   # Resolves the database's foreign key constraints to models
   autoload :ForeignKeyConstraints, 'dynamic-active-model/foreign_key_constraints'
 
+  # Adds has_many :through associations across join models
+  autoload :HasManyThrough, 'dynamic-active-model/has_many_through'
+
   # Manages automatic discovery and setup of model relationships
   autoload :Associations, 'dynamic-active-model/associations'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-active-model
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Doug Youch
@@ -57,6 +57,7 @@ files:
 - lib/dynamic-active-model/factory.rb
 - lib/dynamic-active-model/foreign_key.rb
 - lib/dynamic-active-model/foreign_key_constraints.rb
+- lib/dynamic-active-model/has_many_through.rb
 - lib/dynamic-active-model/setup.rb
 - lib/dynamic-active-model/template_class_file.rb
 - lib/dynamic-active-model/version.rb