dynamic-active-model 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 471bcb2966f59d8f8f4f7df9f32432cf6ff215685a770e2a99956844e0f2d8d5
-  data.tar.gz: 69941d0598425aaf866cfdc29a6e8252d38df291d61523e6edae6243d7f049c0
+  metadata.gz: b13a9d41753ab707e9a414bb36ffd043c4362d09764717f4b43770ba8c0e0731
+  data.tar.gz: 2ed3a9b28b4e9a0825b19acf97f9b95deb8cd99bf312ed6006112f8bbd2573d1
 SHA512:
-  metadata.gz: a7b6cd8138519d8879df5fab6349771b2cc586d340752d566431a985aac152f102c10654dd60098695f303f3fd35eec5b85f109d269ac24a489b51de0a6f2e05
-  data.tar.gz: 3402b23d14abd1b92525642021a5586a202d83aa09683cfe14ae576d9ead974fdccd72374bb7d4f47b77ffc56ca4ba8c8fbb48f3c8cdc371ba283b2f15f24a9f
+  metadata.gz: 86c16133679c95f1e79a24745f2d474c5b5645aadcd6609dcddfe0a347e0545ef618a24ee96b9d674f742b75d03fa0cc90c964400c4ca3e8c89019de8988214a
+  data.tar.gz: acb55a31da056e1f4d5b5d816a61cd45464262b7b6bf4df84b9f56e3400e4d0767561c933e8bce43bc3718e4de7088bd108fa5124a6ecb8f66ec4ef03d9b3134

data/bin/dynamic-db-explorer

@@ -66,6 +66,14 @@ OptionParser.new do |opts|
     options[:id_suffix] = v
   end
 
+  opts.on('--foreign-key-constraints', 'Also relate columns through foreign key constraints') do
+    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
@@ -91,6 +99,8 @@ if options[:config_file]
   config = YAML.safe_load_file(options[:config_file], permitted_classes: [Symbol])[options[:config_section]]
   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/)
 
@@ -104,7 +114,9 @@ DYNAMIC_DATABASE = DynamicActiveModel::Explorer.explore(
   options[:base_module],
   options[:connection_options],
   options[:skip_tables],
-  options[:relationships]
+  options[:relationships],
+  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

@@ -53,6 +53,19 @@ module DynamicActiveModel
         .add(foreign_key, relationship_name)
     end
 
+    # Relates columns through the database's foreign key constraints as well as by
+    # naming convention. A column with a constraint follows the constraint.
+    # @return [void]
+    def use_foreign_key_constraints!
+      @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
@@ -64,15 +77,7 @@ module DynamicActiveModel
       foreign_key_to_models = create_foreign_key_to_model_map
 
       @database.models.each do |model|
-        model.column_names.each do |column_name|
-          next unless foreign_key_to_models[column_name.downcase]
-
-          foreign_key_to_models[column_name.downcase].each do |foreign_model, relationship_name|
-            next if foreign_model == model
-
-            add_relationships(relationship_name, model, foreign_model, column_name)
-          end
-        end
+        model.column_names.each { |column_name| add_column_relationships(model, column_name, foreign_key_to_models) }
       end
 
       @join_tables.each do |join_table_model|
@@ -81,10 +86,36 @@ 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
 
+    # Relates a column through its foreign key constraint when it has one (and
+    # constraints are in use), otherwise by naming convention
+    # @param model [Class] The model with the column
+    # @param column_name [String]
+    # @param foreign_key_to_models [Hash] See #create_foreign_key_to_model_map
+    def add_column_relationships(model, column_name, foreign_key_to_models)
+      constraint = @constraints&.find(model, column_name)
+      return add_constraint_relationships(constraint) if constraint
+
+      foreign_key_to_models.fetch(column_name.downcase, []).each do |foreign_model, relationship_name|
+        next if foreign_model == model
+
+        add_relationships(relationship_name, model, foreign_model, column_name)
+      end
+    end
+
+    # Adds the relationships a foreign key constraint describes; unlike the naming
+    # convention, these may reference the same model (employees.manager_id)
+    # @param constraint [ForeignKeyConstraints::Constraint]
+    def add_constraint_relationships(constraint)
+      add_relationships(constraint.relationship_name, constraint.model, constraint.referenced_model,
+                        constraint.column, constraint.primary_key)
+    end
+
     # Adds has_and_belongs_to_many relationships between two models
     # @param join_table_model [Class] The join table model
     # @param models [Array<Class>] The two models to be related
@@ -101,12 +132,14 @@ module DynamicActiveModel
     # @param model [Class] The model with the foreign key
     # @param belongs_to_model [Class] The model being referenced
     # @param foreign_key [String] The foreign key column name
-    def add_relationships(relationship_name, model, belongs_to_model, foreign_key)
-      add_belongs_to(relationship_name, model, belongs_to_model, foreign_key)
+    # @param primary_key [String] The referenced column, normally the primary key
+    def add_relationships(relationship_name, model, belongs_to_model, foreign_key,
+                          primary_key = belongs_to_model.primary_key)
+      add_belongs_to(relationship_name, model, belongs_to_model, foreign_key, primary_key)
       if unique_index?(model, foreign_key)
-        add_has_one(relationship_name, belongs_to_model, model, foreign_key)
+        add_has_one(relationship_name, belongs_to_model, model, foreign_key, primary_key)
       else
-        add_has_many(relationship_name, belongs_to_model, model, foreign_key)
+        add_has_many(relationship_name, belongs_to_model, model, foreign_key, primary_key)
       end
     end
 
@@ -115,12 +148,13 @@ module DynamicActiveModel
     # @param model [Class] The model with the foreign key
     # @param belongs_to_model [Class] The model being referenced
     # @param foreign_key [String] The foreign key column name
-    def add_belongs_to(relationship_name, model, belongs_to_model, foreign_key)
+    # @param primary_key [String] The referenced column
+    def add_belongs_to(relationship_name, model, belongs_to_model, foreign_key, primary_key)
       model.belongs_to(
         relationship_name.singularize.to_sym,
         class_name: belongs_to_model.name,
         foreign_key: foreign_key,
-        primary_key: belongs_to_model.primary_key
+        primary_key: primary_key
       )
     end
 
@@ -129,12 +163,13 @@ module DynamicActiveModel
     # @param model [Class] The referenced (parent) model that gets the association
     # @param has_many_model [Class] The model with the foreign key
     # @param foreign_key [String] The foreign key column name
-    def add_has_many(relationship_name, model, has_many_model, foreign_key)
+    # @param primary_key [String] The referenced column on the parent model
+    def add_has_many(relationship_name, model, has_many_model, foreign_key, primary_key)
       model.has_many(
         generate_has_many_association_name(relationship_name, model, has_many_model),
         class_name: has_many_model.name,
         foreign_key: foreign_key,
-        primary_key: model.primary_key
+        primary_key: primary_key
       )
     end
 
@@ -143,12 +178,13 @@ module DynamicActiveModel
     # @param model [Class] The referenced (parent) model that gets the association
     # @param has_one_model [Class] The model with the foreign key
     # @param foreign_key [String] The foreign key column name
-    def add_has_one(relationship_name, model, has_one_model, foreign_key)
+    # @param primary_key [String] The referenced column on the parent model
+    def add_has_one(relationship_name, model, has_one_model, foreign_key, primary_key)
       model.has_one(
         generate_has_one_association_name(relationship_name, model, has_one_model),
         class_name: has_one_model.name,
         foreign_key: foreign_key,
-        primary_key: model.primary_key
+        primary_key: primary_key
       )
     end
 

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

@@ -14,6 +14,10 @@ module DynamicActiveModel
   #   skip_tables = ['temporary_data', 'audit_logs']
   #   DynamicActiveModel::Explorer.explore(DB, database_config, skip_tables)
   #
+  # @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 = {
   #     'users' => {
@@ -30,13 +34,18 @@ module DynamicActiveModel
     # @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)
+    # @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)
+                     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)
+      build_relationships!(database, relationships, foreign_key_constraints: foreign_key_constraints,
+                                                    has_many_through: has_many_through)
       database
     end
 
@@ -67,9 +76,13 @@ module DynamicActiveModel
     # Sets up relationships between created models
     # @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)
+    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/foreign_key_constraints.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DynamicActiveModel
+  # Reads the database's foreign key constraints and resolves them to models, so
+  # Associations can relate columns that don't follow the <table>_id naming
+  # convention (posts.author_id => users) and self-references (employees.manager_id).
+  #
+  # Skipped: composite constraints, columns without the id suffix (a belongs_to
+  # named after the column itself would hide it), and constraints whose table or
+  # referenced table has no model.
+  #
+  # @example
+  #   constraints = DynamicActiveModel::ForeignKeyConstraints.new(database)
+  #   constraints.find(DB::Post, 'author_id') # => #<struct referenced_model=DB::User, ...>
+  class ForeignKeyConstraints
+    # A constraint resolved to models
+    Constraint = Struct.new(:model, :column, :referenced_model, :primary_key, :relationship_name)
+
+    # @param database [Database] The database whose models' constraints to read
+    def initialize(database)
+      @database = database
+      @constraints = database.models.flat_map { |model| constraints_for(model) }
+                             .to_h { |constraint| [[constraint.model, constraint.column], constraint] }
+    end
+
+    # @param model [Class] The model with the column
+    # @param column [String] The column name
+    # @return [Constraint, nil] The column's constraint, if it has one
+    def find(model, column)
+      @constraints[[model, column]]
+    end
+
+    # @return [Integer] Number of usable constraints
+    def size
+      @constraints.size
+    end
+
+    private
+
+    # @param model [Class]
+    # @return [Array<Constraint>] The model's usable constraints
+    def constraints_for(model)
+      model.connection.foreign_keys(model.table_name).filter_map do |foreign_key|
+        column = foreign_key.column
+        next unless column.is_a?(String) && column.end_with?(ForeignKey.id_suffix)
+
+        referenced_model = @database.get_model(foreign_key.to_table)
+        next unless referenced_model
+
+        Constraint.new(model, column, referenced_model, foreign_key.primary_key,
+                       relationship_name(column, referenced_model))
+      end
+    end
+
+    # Names the relationship like the naming convention does: author_id => "author",
+    # but user_id referencing users => "users", so its has_many stays :posts
+    # @param column [String]
+    # @param referenced_model [Class]
+    # @return [String]
+    def relationship_name(column, referenced_model)
+      name = column.delete_suffix(ForeignKey.id_suffix)
+      table_name = referenced_model.table_name.underscore
+      name == table_name.singularize ? table_name : name
+    end
+  end
+end

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

@@ -53,6 +53,8 @@ module DynamicActiveModel
         {
           connection_options: nil,
           parent_class: nil,
+          foreign_key_constraints: false,
+          has_many_through: false,
           skip_tables: [],
           relationships: {},
           table_class_names: {},
@@ -84,6 +86,24 @@ module DynamicActiveModel
         dynamic_active_model_config[:parent_class]
       end
 
+      # Sets or gets whether columns are also related through the database's foreign
+      # key constraints (see ForeignKeyConstraints)
+      # @param enabled [Boolean, nil]
+      # @return [Boolean] The current setting
+      def foreign_key_constraints(enabled = nil)
+        update_config(:foreign_key_constraints, enabled) unless enabled.nil?
+        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
@@ -165,7 +185,9 @@ module DynamicActiveModel
             skip_tables,
             relationships,
             table_class_names,
-            parent_class: parent_class
+            parent_class: parent_class,
+            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.0.0'
+  VERSION = '1.2.0'
 end

data/lib/dynamic-active-model.rb

@@ -37,6 +37,12 @@ module DynamicActiveModel
   # Handles foreign key relationships and constraints
   autoload :ForeignKey, 'dynamic-active-model/foreign_key'
 
+  # 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.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Doug Youch
@@ -56,6 +56,8 @@ files:
 - lib/dynamic-active-model/explorer.rb
 - 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