brick 1.0.152 → 1.0.153

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b4101e6f3437aaf0cb79eec97a94b9df6655d9db8a4773e761768556d2ec31f
-  data.tar.gz: 543bad78f1a359af9126373928789d868530b7ed09c17dbf18bf52a012a37763
+  metadata.gz: fc98614593bc4e4931a445801f4f7764c15e6032daf2765f8d78a47f61b7b3a7
+  data.tar.gz: 5b3ae1d718df14101c153b335a66578a5b02771714dedd7ebda1022cadebe482
 SHA512:
-  metadata.gz: 84d77e9a74428eea4e90f0a40b6e2a6dc824623a6b8975659698b4c79b73ec2ec5f5f26409c5d3d7f0c89c33e6c0aafb73a0c69b8cb3900654d10c528f3d4699
-  data.tar.gz: 556ad657abeb7a2368940a8b651ef85e6d3c410684e3ab7a088d741ea851e5c31b51bbe8f8baaa017231f56eb7fa177928782b68c6ee7b00c053d1267ac67a1f
+  metadata.gz: 15852e3d59a95d5ac8614d98a44a70796c5494610447505abe61dcd02010c3701dc9ba48da951e4639e4fa14694cfee4c7455c2a0bd63fc613738886ca908b26
+  data.tar.gz: bd5cc34b7c004461af1737dbcb4b746889bd7f4da7d5242c3f341793ed4675c33a50bc61108a6f1e24037585298361f8f4f6ac699a25a72c4ec860f1c272e0ba

data/lib/brick/extensions.rb

@@ -1244,25 +1244,38 @@ end
     result = if ::Brick.enable_controllers? &&
                 is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
+               controller_class_name = +''
                full_class_name = +''
-               full_class_name << "::#{(split_self_name&.first && split_self_name.join('::')) || self.name}" unless self == Object
+               unless self == Object
+                 controller_class_name << ((split_self_name&.first && split_self_name.join('::')) || self.name)
+                 full_class_name << "::#{controller_class_name}"
+                 controller_class_name << '::'
+               end
                # (Go over to underscores for a moment so that if we have something come in like VABCsController then the model name ends up as
                # Vabc instead of VABC)
                singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
                full_class_name << "::#{singular_class_name}"
+               skip_controller = nil
                if plural_class_name == 'BrickOpenapi' ||
                   (
                     (::Brick.config.add_status || ::Brick.config.add_orphans) &&
                     plural_class_name == 'BrickGem'
                   ) ||
-                  model = self.const_get(full_class_name)
-                 # In the very rare case that we've picked up a MODULE which has the same name as what would be the
-                 # resource's MODEL name, just build out an appropriate auto-model on-the-fly. (RailsDevs code has this in PayCustomer.)
-                 # %%% We don't yet display the code for this new model
-                 if model && !model.is_a?(Class)
-                   model, _code = Object.send(:build_model, relations, model.module_parent, model.module_parent.name, singular_class_name)
+                 begin
+                   model = self.const_get(full_class_name)
+
+                   # In the very rare case that we've picked up a MODULE which has the same name as what would be the
+                   # resource's MODEL name, just build out an appropriate auto-model on-the-fly. (RailsDevs code has this in PayCustomer.)
+                   # %%% We don't yet display the code for this new model
+                   if model && !model.is_a?(Class)
+                     model, _code = Object.send(:build_model, relations, model.module_parent, model.module_parent.name, singular_class_name)
+                   end
+                 rescue NameError # If the const_get for the model has failed...
+                   skip_controller = true
+                   # ... then just fall through and allow it to fail when trying to loading the ____Controller class normally.
                  end
-                 # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
+               end
+               unless skip_controller
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
 
@@ -1475,7 +1488,7 @@ class Object
           code << "  has_secure_password\n"
         end
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
-        code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || table_name != matching
+        code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || self.table_name != matching
 
         # Override models backed by a view so they return true for #is_view?
         # (Dynamically-created controllers and view templates for such models will then act in a read-only way)
@@ -2225,7 +2238,7 @@ class Object
                   end
                 end
               end
-              if (upd_hash ||= upd_params).fetch(model.inheritance_column, nil).strip == ''
+              if (upd_hash ||= upd_params).fetch(model.inheritance_column, nil)&.strip == ''
                 upd_hash[model.inheritance_column] = nil
               end
               obj.send(:update, upd_hash || upd_params)
@@ -2485,6 +2498,11 @@ end.class_exec do
             ::Brick.config.table_name_prefixes[as_tnp] = ar_extension
           end
         end
+
+        # Support the followability gem:  https://github.com/nejdetkadir/followability
+        if Object.const_defined?('Followability') && !::Brick.config.table_name_prefixes.key?('followability_')
+          ::Brick.config.table_name_prefixes['followability_'] = 'Followability'
+        end
       end
       # Load the initializer for the Apartment gem a little early so that if .excluded_models and
       # .default_schema are specified then we can work with non-tenanted models more appropriately

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

@@ -1686,7 +1686,7 @@ end
         end %>
         BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
     <% else %>
-      <%= k %>
+      <%= #{model_name}.human_attribute_name(k, { default: k }) %>
     <% end %>
     </th>
     <td>

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

@@ -1,7 +1,29 @@
 module Brick::Rails::FormTags
   # Our super speedy grid
-  def brick_grid(relation, bt_descrip, sequence = nil, inclusions, exclusions,
-                 cols, poly_cols, bts, hms_keys, hms_cols)
+  def brick_grid(relation = nil, bt_descrip = nil, sequence = nil, inclusions = nil, exclusions = nil,
+                 cols = {}, poly_cols = nil, bts = {}, hms_keys = [], hms_cols = {})
+    # When a relation is not provided, first see if one exists which matches the controller name
+    unless (relation ||= instance_variable_get("@#{controller_name}".to_sym))
+      # Failing that, dig through the instance variables with hopes to find something that is an ActiveRecord::Relation
+      case (collections = _brick_resource_from_iv).length
+      when 0
+        puts '#brick_grid:  Not having been provided with a collection to work from, searched through all instance variables to find an ActiveRecord::Relation.  None could be found.'
+        return
+      when 1 # If there's only one type match then simply get the first one, hoping that this is what they intended
+        relation = instance_variable_get(iv = (chosen = collections.first).last.first)
+        puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}.
+              Failing that, have searched through instance variables and found #{iv} of type #{chosen.first.name}.
+              Running with it!"
+      else
+        myriad = collections.each_with_object([]) { |c, s| c.last.each { |iv| s << "#{iv} (#{c.first.name})" } }
+        puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}, and then searched through all instance variables.
+              Found ActiveRecord::Relation objects of multiple types:
+                #{myriad.inspect}
+              Not knowing which of these to render, have erred on the side of caution and simply provided this warning message."
+        return
+      end
+    end
+
     out = "<table id=\"headerTop\"></table>
 <table id=\"#{relation.table_name.split('.').last}\" class=\"shadow\">
   <thead><tr>"
@@ -14,8 +36,8 @@ module Brick::Rails::FormTags
     col_keys = relation.columns.each_with_object([]) do |col, s|
       col_name = col.name
       next if inclusions&.exclude?(col_name) ||
-              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts.key?(col_name)) ||
-              ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
+              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts&.key?(col_name)) ||
+              ::Brick.config.metadata_columns.include?(col_name) || poly_cols&.include?(col_name)
 
       s << col_name
       cols[col_name] = col
@@ -44,7 +66,8 @@ module Brick::Rails::FormTags
                       "x-order=\"#{bt.first.to_s + '"' unless bt[2]}>BT " +
                       bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
                     else # Normal column
-                      "x-order=\"#{col_name + '"' if true}>#{col_name}"
+                      col_name_humanised = klass.human_attribute_name(col_name, { default: col_name })
+                      "x-order=\"#{col_name + '"' if true}>#{col_name_humanised}"
                     end
              elsif col # HM column
                options = {}
@@ -261,16 +284,7 @@ module Brick::Rails::FormTags
     else
       # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
       # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
-      links = instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
-                iv_name = name.to_s[1..-1]
-                case (val = instance_variable_get(name))
-                when ActiveRecord::Relation
-                  s[val.klass] << iv_name
-                when ActiveRecord::Base
-                  s[val] << iv_name
-                end
-              end
-      if links.length == 1 # If there's only one match then use any text that was supplied
+      if (links = _brick_resource_from_iv(true)).length == 1 # If there's only one match then use any text that was supplied
         link_to_brick(text || links.first.last.join('/'), links.first.first, **kwargs)
       else
         links.each_with_object([]) { |v, s| s << link if link = link_to_brick(v.join('/'), v, **kwargs) }.join(' &nbsp; ').html_safe
@@ -278,4 +292,17 @@ module Brick::Rails::FormTags
     end
   end # link_to_brick
 
+private
+
+  def _brick_resource_from_iv(trim_ampersand = false)
+    instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
+      iv_name = trim_ampersand ? name.to_s[1..-1] : name
+      case (val = instance_variable_get(name))
+      when ActiveRecord::Relation
+        s[val.klass] << iv_name
+      when ActiveRecord::Base
+        s[val] << iv_name
+      end
+    end
+  end
 end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -192,10 +192,17 @@ module Brick
           puts "Based on inclusion in ::Brick.polymorphics, marking association #{full_assoc_name} as being polymorphic."
           a.options[:polymorphic] = true
         end
-        next unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
-                    (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
-                     (!a.belongs_to? || model_cols[a.foreign_key]&.type == pk_type)
-                    )
+        unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
+               (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
+                 (!a.belongs_to? || (same_type = (fk_type = model_cols[a.foreign_key]&.type) == pk_type))
+               )
+          if same_type == false # We really do want to test specifically for false here, and not nil!
+            puts "WARNING:
+  Foreign key column #{a.klass.table_name}.#{a.foreign_key} is #{fk_type}, but the primary key it relates to, #{a.active_record.table_name}.#{a.active_record.primary_key}, is #{pk_type}.
+  These columns should both be of the same type."
+          end
+          next
+        end
 
         if a.belongs_to?
           if a.polymorphic?
@@ -1375,14 +1382,18 @@ ActiveSupport.on_load(:active_record) do
     arsc.class_exec do
       def self.create(connection, callable = nil, &block)
         relation = (callable || block).call ::ActiveRecord::StatementCache::Params.new
-        bind_map = ::ActiveRecord::StatementCache::BindMap.new(
-                     # AR <= 4.2 uses relation.bind_values
-                     relation.respond_to?(:bound_attributes) ? relation.bound_attributes : relation.bind_values
-                   )
         options = [self, relation.arel]
         options.shift if connection.method(:cacheable_query).arity == 1 # Rails <= 5.0
         query_builder = connection.cacheable_query(*options)
-        new query_builder, bind_map
+        query_builder, binds = query_builder if query_builder.is_a?(Array) # Accommodate AR < 5.2.4
+
+        bind_map = ::ActiveRecord::StatementCache::BindMap.new(
+                     # AR <= 4.2 uses relation.bind_values
+                     relation.respond_to?(:bound_attributes) ? relation.bound_attributes : (binds || relation.bind_values)
+                   )
+        new_options = [query_builder, bind_map]
+        new_options << relation.klass if binds # Accommodate AR < 5.2.4
+        new(*new_options)
       end
     end
   end

data/lib/generators/brick/install_generator.rb

@@ -19,13 +19,25 @@ module Brick
 
     def create_initializer_file
       is_brick_file = File.exist?(filename = 'config/initializers/brick.rb')
-      if is_brick_file && ::Brick.config.schema_behavior[:multitenant] || !is_brick_file
+      if (is_brick_file && (tnps = ::Brick.config.table_name_prefixes).present?) ||
+                           (::Brick.config.schema_behavior[:multitenant]
+         ) || !is_brick_file
         # See if we can make suggestions for additional_references and polymorphic associations
         resembles_fks = Hash.new { |h, k| h[k] = [] }
         possible_polymorphics = {}
-        possible_additional_references = (relations = ::Brick.relations).each_with_object(Hash.new { |h, k| h[k] = [] }) do |v, s|
-          model_filename = "app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb"
-          v.last[:cols].each do |col, type|
+        relations = ::Brick.relations
+        if is_brick_file
+          # Need to remove any currently-existing additional_references so that it doesn't cloud the discovery process:
+          ::Brick.config.additional_references.each do |ar|
+            if (fks = relations.fetch(ar[0], nil)&.fetch(:fks, nil))
+              fks.delete(fks.find { |k, v| v[:is_bt] && k.start_with?('(brick) ') && v[:fk] == ar[1] }&.first)
+            end
+          end
+        end
+        possible_additional_references = relations.each_with_object(Hash.new { |h, k| h[k] = [] }) do |relation, s|
+          this_tnp = tnps&.keys.find { |tnp| relation.first.start_with?(tnp) }
+          model_filename = "app/models/#{ActiveSupport::Inflector.singularize(relation.first)}.rb"
+          relation.last[:cols].each do |col, type|
             col_down = col.downcase
 
             if (is_possible_poly = ['character varying', 'text'].include?(type.first))
@@ -40,7 +52,7 @@ module Brick
               end
               is_possible_poly = false if col_down.length < 6 # Was it simply called "type" or something else really short?
               if is_possible_poly && !File.exist?(model_filename) # Make sure a model file isn't present
-                possible_polymorphics["#{v.first}.#{col_down}"] = "'#{v.first}.#{col[0..poly_type_cut_length]}'"
+                possible_polymorphics["#{relation.first}.#{col_down}"] = "'#{relation.first}.#{col[0..poly_type_cut_length]}'"
                 next
               end
             end
@@ -66,16 +78,24 @@ module Brick
               col_down = col_down[2..-1]
             end
             # This possible key not really a primary key and not yet used as a foreign key?
-            if is_possible && !(relation = relations.fetch(v.first, {}))[:pkey].first&.last&.include?(col) &&
-               !relations.fetch(v.first, {})[:fks]&.any? { |_k, v| v[:is_bt] && v[:fk] == col }
-              # Starting to look promising ... make sure a model file isn't present
-              if !File.exist?(model_filename)
-                if (relations.fetch(f_table = col_down, nil) ||
-                  relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
-                  s["#{v.first}.#{col_down}"] << "['#{v.first}', '#{col}', '#{f_table}']"
-                else
-                  resembles_fks["#{v.first}.#{col_down}"] << "#{v.first}.#{col}"
-                end
+            if is_possible && !relation.last[:pkey].first&.last&.include?(col) &&
+               !relation.last[:fks]&.any? { |_k, v| v[:is_bt] && v[:fk] == col } &&
+               # Starting to look promising ... make sure a model file isn't present
+               !File.exist?(model_filename)
+              if (
+                  (relations.fetch(f_table = col_down, nil) ||
+                   relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)
+                  ) && s["#{relation.first}.#{col_down}"] << "['#{relation.first}', '#{col}', '#{f_table}']"
+                 ) ||
+                 (
+                  this_tnp && (full_col_down = this_tnp + col_down) &&
+                  (relations.fetch(f_table = full_col_down, nil) ||
+                   relations.fetch(f_table = ActiveSupport::Inflector.pluralize(full_col_down), nil)
+                  ) && s["#{relation.first}.#{full_col_down}"] << "['#{relation.first}', '#{col}', '#{f_table}']"
+                 )
+                # Found a possible_additional_reference (and set as the last action of the conditional check above)
+              else
+                resembles_fks["#{relation.first}.#{col_down}"] << "#{relation.first}.#{col}"
               end
             end
           end
@@ -183,7 +203,13 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # ::Brick.controllers_inherit_from = 'ApplicationController'
 
   # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
-  # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
+  #{
+    if tnps
+      "Brick.table_name_prefixes = #{tnps.inspect}"
+    else
+      "# Brick.table_name_prefixes = { 'nav_' => 'Navigation' }"
+    end
+  }
 
   # # COLUMN SEQUENCING AND INCLUSION / EXCLUSION
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.152
+  version: 1.0.153
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-11 00:00:00.000000000 Z
+date: 2023-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord