brick 1.0.5 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cd49783dae6701760920fe007cbde7382fd3dbaf5e8f7472d475c0fe8aaf660
-  data.tar.gz: d2330f28e87dde00b1377f6cbca31cbbfe2dd3b2c495f1fbd0aebc0f8a951504
+  metadata.gz: 7e06e6aaa9b7fef7730d56404912ab186a29f6e698f6dbb0d9c551cf2008c0b1
+  data.tar.gz: 7e546071063729d5b85b2f146bb401c7cbfc462f6dea0a701ed8c839cb883de5
 SHA512:
-  metadata.gz: 2a3c7ba47d32f3a6ab6c9be838006826f5266efb1349d90ce7d53b5e8f89ea078bdcb699a7db8084176e2de444a27931ce8e0216af666c25704c0568b59ac827
-  data.tar.gz: 41fccf3387315cd54fd596955c3f07760941cd4aa51959dc99f87d0b6fb38de742ad11fe7dabb084a3e72167c340b8aafce838c7704626359ccb41878e202ae2
+  metadata.gz: 83499e7959f98bb323f44593f6472ba1996815ed5f286a119f5adfbd2b690be3f9cd3556166cff3efda250fd609b6d06f4054aea599b0e9587191b4cb1d7a3cb
+  data.tar.gz: 6ded71697d4cce4d931afb54869639d6c2d0b32462806c0c0c7826ceb46fd5f7d7c2476f29e5c9302c83482e0293916dd82e553fa847482de52c39e06dc2d210

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

@@ -80,6 +80,18 @@ module ActiveRecord
       end
     end
   end
+
+  module Inheritance
+    module ClassMethods
+      private
+
+      alias _brick_find_sti_class find_sti_class
+      def find_sti_class(type_name)
+        ::Brick.sti_models[type_name] = { base: self } unless type_name.blank?
+        _brick_find_sti_class(type_name)
+      end
+    end
+  end
 end
 
 # Object.class_exec do
@@ -113,6 +125,11 @@ class Object
         singular_table_name = ActiveSupport::Inflector.underscore(model_name)
         table_name = ActiveSupport::Inflector.pluralize(singular_table_name)
 
+        # Adjust for STI if we know of a base model for the requested model name
+        if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+          table_name = base_model.table_name
+        end
+
         # Maybe, just maybe there's a database table that will satisfy this need
         if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
           build_model(model_name, singular_table_name, table_name, relations, matching)
@@ -138,8 +155,9 @@ class Object
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
         raise NameError.new("Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\".")
       end
-      code = +"class #{model_name} < ActiveRecord::Base\n"
-      built_model = Class.new(ActiveRecord::Base) do |new_model_class|
+      base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ActiveRecord::Base
+      code = +"class #{model_name} < #{base_model.name}\n"
+      built_model = Class.new(base_model) do |new_model_class|
         Object.const_set(model_name.to_sym, new_model_class)
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" unless table_name == matching
@@ -176,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])
@@ -185,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]
@@ -215,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]
@@ -275,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

@@ -66,17 +66,23 @@ module Brick
                 associatives = hms.select { |k, v| v.options[:through] }.each_with_object({}) do |hmt, s|
                   s[hmt.first] = hms.delete(hmt.last.options[:through]) # End up with a hash of HMT names pointing to join-table associations
                 end
-                hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>HM#{'T' if hm.last.options[:through]} #{hm.first}</th>\n" }
+                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
-                  s << "<td>
+                                 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? %>
 </td>\n"
+                         else # has_one
+"<td>
+  <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
+</td>\n"
+                       end
                 end
 
                 inline = case args.first
@@ -89,7 +95,7 @@ module Brick
 <table id=\"#{table_name}\">
   <tr>
   <% is_first = true; is_need_id_col = nil
-     bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last.last.name}, #{v.last.last.primary_key.inspect}]"}.join(', ')} }
+     bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
      @#{table_name}.columns.map(&:name).each do |col| %>
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
@@ -125,9 +131,9 @@ module Brick
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%= obj = bt[1].find_by(bt.last => val); link_to obj.brick_descrip, obj %>
+        <%= obj = bt[1].find_by(bt.last => val); link_to(obj.brick_descrip, obj) if obj %>
       <% elsif is_first %>
-        <%= is_first = false; link_to val, #{obj_name} %>
+        <%= is_first = false; link_to val, #{obj_name}_path(#{obj_name}.#{pk}) %>
       <% else %>
         <%= val %>
       <% end %>
@@ -188,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 = 5
+    TINY = 8
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -81,6 +81,10 @@ if Gem::Specification.all_names.any? { |g| g.start_with?('rails-') }
   require 'brick/frameworks/rails'
 end
 module Brick
+  def self.sti_models
+    @sti_models ||= {}
+  end
+
   class << self
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
     def relations
@@ -107,7 +111,7 @@ module Brick
           end
 
           s.first[a.foreign_key] = [a.name, a.klass]
-        when :has_many
+        when :has_many, :has_one
           s.last[a.name] = a
         end
         s
@@ -192,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.5
+  version: 1.0.8
 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