brick 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 634669de2074746d62642b8c9108070b78e92b14f7924ac969404b240de2267d
-  data.tar.gz: 7614fa456fcaeb6bc68227230088fe3adeed31278241a000f3fb19792b763d26
+  metadata.gz: b65cbc8bbf472c887136395afb13f9dcf6e460f0c279dda0372939da8863178f
+  data.tar.gz: d63ae1e8795bb788e67c05d98f245c086aa773fbfc5585f716e3371652976878
 SHA512:
-  metadata.gz: 3b89ed9c8ffe3c63e098a3f7a8e5a9987db0c00bfe2c917b7c2acefebc30653a4a88d091852b8f8e6128daa310e7c7742d10611acfb0ffe7d06cc6c01da7068e
-  data.tar.gz: 98d58b4461b9e85537da640e3940316553d142a341547086ce614f75d9366145c8818beb6e972ac93a77e7209b034eb64a64eb9a078f6afb91fbbd008e3ade69
+  metadata.gz: e27c5bc4385ae585e1904fc142aa6e0a61b1c780c6e9d68efc4b6ce1b60f985db71922466ad5dff365e3c239a0220411af90ec2f148705bdc5a993e552494c50
+  data.tar.gz: 2937ec1ecb167d7db208c0f46aaab60670b95403ba22b464597c254c782e9075e0245514fd950fbb4267c3e3f206b7b49969cd5052dd3d6d89db41a7883cd7d9

data/lib/brick/config.rb

@@ -65,7 +65,7 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
-    # Associations to treat has a has_one
+    # Associations to treat as a has_one
     def has_ones
       @mutex.synchronize { @has_ones }
     end

data/lib/brick/extensions.rb

@@ -194,8 +194,10 @@ class Object
         end
 
         fks = relation[:fks] || {}
-        fks.each do |_constraint_name, assoc|
-          assoc_name = assoc[:assoc_name]
+        # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
+        hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
+          # The key in each hash entry (fk.first) is the constraint name
+          assoc_name = (assoc = fk.last)[:assoc_name]
           inverse_assoc_name = assoc[:inverse][:assoc_name]
           options = {}
           singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
@@ -203,7 +205,7 @@ class Object
                     need_class_name = singular_table_name.underscore != assoc_name
                     need_fk = "#{assoc_name}_id" != assoc[:fk]
                     inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], assoc[:inverse])
-                    if (has_ones = ::Brick.config.has_ones.fetch(assoc[:inverse][:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
+                    if (has_ones = ::Brick.config.has_ones&.fetch(assoc[:inverse][:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
                       inverse_assoc_name = if has_ones[singular_inv_assoc_name]
                                              need_inverse_of = true
                                              has_ones[singular_inv_assoc_name]
@@ -233,23 +235,51 @@ class Object
           # Figure out if we need to specially call out the class_name and/or foreign key
           # (and if either of those then definitely also a specific inverse_of)
           options[:class_name] = singular_table_name.camelize if need_class_name
-          options[:foreign_key] = assoc[:fk].to_sym if need_fk # Funky foreign key?
+          # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
+          if need_fk # Funky foreign key?
+            options[:foreign_key] = if assoc[:fk].is_a?(Array)
+                                      assoc_fk = assoc[:fk].uniq
+                                      assoc_fk.length < 2 ? assoc_fk.first : assoc_fk
+                                    else
+                                      assoc[:fk].to_sym
+                                    end
+          end
           options[:inverse_of] = inverse_assoc_name.to_sym if need_class_name || need_fk || need_inverse_of
-          assoc_name = assoc_name.to_sym
-          code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
-          self.send(macro, assoc_name, **options)
 
-          # Look for any valid "has_many :through"
+          # Prepare a list of entries for "has_many :through"
           if macro == :has_many
             relations[assoc[:inverse_table]][:hmt_fks].each do |k, hmt_fk|
               next if k == assoc[:fk]
 
-              hmt_fk = ActiveSupport::Inflector.pluralize(hmt_fk)
-              code << "  has_many :#{hmt_fk}, through: #{assoc_name.inspect}\n"
-              self.send(:has_many, hmt_fk.to_sym, **{ through: assoc_name })
+              hmts[ActiveSupport::Inflector.pluralize(hmt_fk.last)] << [assoc, hmt_fk.first]
             end
           end
+
+          # And finally create a has_one, has_many, or belongs_to for this association
+          assoc_name = assoc_name.to_sym
+          code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
+          self.send(macro, assoc_name, **options)
+          hmts
         end
+        hmts.each do |hmt_fk, fks|
+          fks.each do |fk|
+            source = nil
+            this_hmt_fk = if fks.length > 1
+                            singular_assoc_name = ActiveSupport::Inflector.singularize(fk.first[:inverse][:assoc_name])
+                            source = fk.last
+                            through = ActiveSupport::Inflector.pluralize(fk.first[:alternate_name])
+                            "#{singular_assoc_name}_#{hmt_fk}"
+                          else
+                            through = fk.first[:assoc_name]
+                            hmt_fk
+                          end
+            code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
+            options = { through: assoc_name }
+            options[:source] = source.to_sym if source
+            self.send(:has_many, this_hmt_fk.to_sym, **options)
+          end
+        end
+
         code << "end # model #{model_name}\n\n"
       end # class definition
       [built_model, code]
@@ -293,7 +323,7 @@ class Object
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
-      if relation[:hm_counts][hm_assoc[:assoc_name]] > 1
+      if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
         [ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name]), true]
       else
         [ActiveSupport::Inflector.pluralize(hm_assoc[:inverse_table]), nil]

data/lib/brick/frameworks/rails/engine.rb

@@ -69,14 +69,14 @@ module Brick
                 hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>H#{hm.last.macro == :has_one ? 'O' : 'M'}#{'T' if hm.last.options[:through]} #{hm.first}</th>\n" }
                 hms_columns = hms.each_with_object(+'') do |hm, s|
                   hm_fk_name = if hm.last.options[:through]
-                    associative = associatives[hm.last.name]
-                    "'#{associative.name}.#{associative.foreign_key}'"
-                  else
-                    hm.last.foreign_key
-                  end
+                                 associative = associatives[hm.last.name]
+                                 "'#{associative.name}.#{associative.foreign_key}'"
+                               else
+                                 hm.last.foreign_key
+                               end
                   s << if hm.last.macro == :has_many
 "<td>
-  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
+  #\{#{obj_name}.#{hm.first}.count\} #{hm.first}<%= link_to \"\", #{hm.last&.klass&.name&.underscore&.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
 </td>\n"
                          else # has_one
 "<td>
@@ -194,7 +194,7 @@ module Brick
         # Find associative tables that can be set up for has_many :through
         ::Brick.relations.each do |_key, tbl|
           tbl_cols = tbl[:cols].keys
-          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = fk.last[:inverse_table] if fk.last[:is_bt]; s }
+          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
           # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
           # foreign keys then it can act as an associative table and thus be used with has_many :through.
           if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 6
+    TINY = 7
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -196,7 +196,7 @@ module Brick
       end
     end
 
-    # Associations to treat has a has_one
+    # Associations to treat as a has_one
     # @api public
     def has_ones=(hos)
       if hos

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-19 00:00:00.000000000 Z
+date: 2022-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord