brick 1.0.81 → 1.0.83

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2627490165a63200a49afb7707882489986217bc170491e88f64eb9faf880b6b
-  data.tar.gz: f12adff07785ffd5c4a877f555cd7899de859f99ae9b18b84eda6f3d20ac5c15
+  metadata.gz: fd1f37f0785af48f35bc1292e9eec44cd8ebc6a81a6ed7163e53aeaeb753ccc7
+  data.tar.gz: e532a10b06419ce64369e7a397a8eb4d268d87dc5a18c936847ab693cbf159bb
 SHA512:
-  metadata.gz: f112e1bf44fc39e80bced64a2d9fb4dd16297e2c549f66d0842fb65d7f3644170fa18c3c784c59c5a93db57233a77bfa5f288dca89be1b3dec6172bb670f147b
-  data.tar.gz: 0c2061b9b662c00aeb85a76db20fb59962302dd8b6ab17225ded332eadf4485392e3f5e44538b8f99d525666b8a036bb2fbd53a2604bbf7f69aca3ad8400fa4d
+  metadata.gz: 7d9dbf20d1bcdc3d3ac2beaf905392ba4990574a8165c1111bdb8f035bd8b53765f1555bd672da134cd342edadb45a2b62151e49cfa6279ebc957f16d34fc449
+  data.tar.gz: 276c8e4b831a866baa1b4e84a288a0137ae19afba54d08d342432f358ff4b7a45f234521c35f6d1a6ab96fd69ceb68aa30ba41bfb4b18caef7a12e25cedec8ed

data/lib/brick/extensions.rb

@@ -59,6 +59,10 @@ end
 
 module ActiveRecord
   class Base
+    def self.is_brick?
+      instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
+    end
+
     def self._assoc_names
       @_assoc_names ||= {}
     end
@@ -521,7 +525,7 @@ module ActiveRecord
         # CUSTOM COLUMNS
         # ==============
         klass._br_cust_cols.each do |k, cc|
-          if respond_to?(k) # Name already taken?
+          if rel_dupe.respond_to?(k) # Name already taken?
             # %%% Use ensure_unique here in this kind of fashion:
             # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
             # binding.pry
@@ -641,11 +645,13 @@ module ActiveRecord
                            [a.table_name, a.foreign_key, a.source_reflection.macro]
                          end
                          next if bail_out
+
                          # count_column is determined from the originating HMT member
                          if (src_ref = hm.source_reflection).nil?
                            puts "*** Warning:  Could not determine destination model for this HMT association in model #{klass.name}:\n  has_many :#{hm.name}, through: :#{hm.options[:through]}"
+                           puts
                            nix << k
-                           bail_out = true
+                           next
                          elsif src_ref.macro == :belongs_to # Traditional HMT using an associative table
                            "br_t#{idx}.#{hm.foreign_key}"
                          else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
@@ -676,15 +682,15 @@ module ActiveRecord
                          pri_tbl.table_name
                        end
         on_clause = []
-        if fk_col.is_a?(Array) # Composite key?
-          fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl_name}.#{pri_tbl.primary_key[idx]}" }
-          selects = fk_col.dup
-        else
-          selects = [fk_col]
-          on_clause << "#{tbl_alias}.#{fk_col} = #{pri_tbl_name}.#{pri_tbl.primary_key}"
-        end
+        hm_selects = if fk_col.is_a?(Array) # Composite key?
+                       fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl_name}.#{pri_tbl.primary_key[idx]}" }
+                       fk_col.dup
+                     else
+                       on_clause << "#{tbl_alias}.#{fk_col} = #{pri_tbl_name}.#{pri_tbl.primary_key}"
+                       [fk_col]
+                     end
         if poly_type
-          selects << poly_type
+          hm_selects << poly_type
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
         unless from_clause
@@ -696,9 +702,9 @@ module ActiveRecord
                             hm.table_name
                           end
         end
-        group_bys = ::Brick.is_oracle || is_mssql ? selects : (1..selects.length).to_a
+        group_bys = ::Brick.is_oracle || is_mssql ? hm_selects : (1..hm_selects.length).to_a
         join_clause = "LEFT OUTER
-JOIN (SELECT #{selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
+JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
           }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
@@ -735,8 +741,10 @@ JOIN (SELECT #{selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')},
             else
               s << v
             end
-          else # String stuff just comes straight through
+          else # String stuff (which defines a custom ORDER BY) just comes straight through
             s << v
+            # Avoid "PG::InvalidColumnReference: ERROR: for SELECT DISTINCT, ORDER BY expressions must appear in select list" in Postgres
+            selects << v if is_distinct
           end
         end
         order!(*final_order_by)
@@ -805,6 +813,100 @@ JOIN (SELECT #{selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')},
   end
 end
 
+if Object.const_defined?('ActionView')
+  module ActionView::Helpers::FormTagHelper
+    def link_to_brick(*args, **kwargs)
+      text = (args.first.is_a?(String) && args.first) || args[1]
+      klass_or_obj = ((args.first.is_a?(ActiveRecord::Relation) ||
+                       args.first.is_a?(ActiveRecord::Base) ||
+                       args.first.is_a?(Class)) &&
+                      args.first) ||
+                     @_brick_model
+      # If not provided, do a best-effort to automatically determine the resource class or object
+      sti_type = nil
+      filter_parts = []
+      klass_or_obj ||= begin
+                         res_names = ::Brick.relations.each_with_object({}) do |v, s|
+                           v_parts = v.first.split('.')
+                           v_parts.shift if v_parts.first == 'public'
+                           s[v_parts.join('.')] = v.first
+                         end
+                         c_path_parts = controller_path.split('/')
+                         klass = nil
+                         while c_path_parts.present?
+                           possible_c_path = c_path_parts.join('.')
+                           possible_c_path_singular = c_path_parts[0..-2] + [c_path_parts.last.singularize]
+                           possible_sti = possible_c_path_singular.join('/').camelize
+                           break if (
+                                      res_name = res_names[possible_c_path] ||
+                                                 ((klass = Brick.config.sti_namespace_prefixes.key?("::#{possible_sti}") && possible_sti.constantize) &&
+                                                  (sti_type = possible_sti)) ||
+                                                 # %%% Used to have the more flexible:  (DidYouMean::SpellChecker.new(dictionary: res_names.keys).correct(possible_c_path)).first
+                                                 res_names[possible_c_path] || res_names[possible_c_path_singular.join('.')]
+                                    ) &&
+                                    (
+                                      klass ||
+                                      ((rel = ::Brick.relations.fetch(res_name, nil)) &&
+                                      (klass ||= rel[:class_name]&.constantize))
+                                    )
+                           c_path_parts.shift
+                         end
+                         if klass
+                           type_col = klass.inheritance_column # Usually 'type'
+                           filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
+                           path_params = request.path_parameters.dup
+                           path_params.delete(:controller)
+                           path_params.delete(:action)
+                           pk = (klass.primary_key || ActiveRecord::Base.primary_key).to_sym
+                           # Used to also have this but it's a bit too permissive to identify a primary key:  (path_params.length == 1 && path_params.values.first) ||
+                           if ((id = (path_params[pk] || path_params[:id] || path_params["#{klass.name.underscore}_id".to_sym])) && (obj = klass.find_by(pk => id))) ||
+                              (['show', 'edit'].include?(action_name) && (obj = klass.first))
+                             obj
+                           else
+                             # %%% If there is a HMT that refers to some ___id then try to identify an appropriate filter
+                             # %%% If there is a polymorphic association that might relate to stuff in the path_params,
+                             # try to identify an appropriate ___able_id and ___able_type filter
+                             ((klass.column_names - [pk.to_s]) & path_params.keys.map(&:to_s)).each do |path_param|
+                               filter_parts << "#{path_param}=#{path_params[path_param.to_sym]}"
+                             end
+                             klass
+                           end
+                         end
+                       rescue
+                       end
+      if klass_or_obj
+        if klass_or_obj.is_a?(ActiveRecord::Relation)
+          klass_or_obj.where_values_hash.each do |whr|
+            filter_parts << "#{whr.first}=#{whr.last}" unless whr.last.is_a?(Array)
+          end
+          klass_or_obj = klass_or_obj.klass
+        end
+        filter = "?#{filter_parts.join('&')}" if filter_parts.present?
+        if klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base
+          lt_args = [text || "Index for #{klass_or_obj.name.pluralize}",
+                    "#{send("#{klass_or_obj._brick_index}_path")}#{filter}"]
+        else
+          # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
+          lt_args = [text || "Show this #{klass_or_obj.class.name}",
+                    "#{send("#{klass_or_obj.class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"]
+        end
+        link_to(*lt_args, **kwargs)
+      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([]) do |name, s|
+                  iv_name = name.to_s[1..-1]
+                  case (val = instance_variable_get(name))
+                  when ActiveRecord::Relation, ActiveRecord::Base
+                    s << link_to_brick(val, iv_name) if val
+                  end
+                end
+        links.join(' &nbsp; ').html_safe
+      end
+    end
+  end
+end
+
 if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works with previous non-zeitwerk auto-loading
   module ActiveSupport::Dependencies
     class << self
@@ -1138,6 +1240,7 @@ class Object
       end # class definition
       # Having this separate -- will this now work out better?
         built_model.class_exec do
+          @_brick_built = true
           hmts&.each do |hmt_fk, hms|
             hmt_fk = hmt_fk.tr('.', '_')
             hms.each do |hm|

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

@@ -130,15 +130,15 @@ module Brick
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 tbl_nm = if hm_assoc.options[:source]
-                                            associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
+                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :belongs_to
+                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
                                           else
-                                            associative.name
+                                            source.inverse_of&.name # For HM -> HM style HMT
                                           end
                                  # If there is no inverse available for the source belongs_to association, make one based on the class name
                                  unless tbl_nm
                                    tbl_nm = associative.class_name.underscore
-                                   tbl_nm.slice!(0) if tbl_nm[0] == ('/')
+                                   tbl_nm.slice!(0) if tbl_nm[0] == '/'
                                    tbl_nm = tbl_nm.tr('/', '_').pluralize
                                  end
                                  "'#{tbl_nm}.#{associative.foreign_key}'"
@@ -166,7 +166,13 @@ module Brick
                     hms_columns << hm_entry
                   when 'show', 'new', 'update'
                     hm_stuff << if hm_fk_name
-                                  "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                  if hm_assoc.klass.column_names.include?(hm_fk_name)
+                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                  else
+                                    puts "Warning:  has_many :#{hm_assoc.name} in model #{hm_assoc.active_record.name} currently looks for a foreign key called \"#{hm_assoc.foreign_key}\".  "\
+                                         "Instead it should use the clause  \"foreign_key: :#{hm_assoc.inverse_of&.foreign_key}\"."
+                                    assoc_name
+                                  end
                                 else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
                                   assoc_name
                                 end
@@ -1331,10 +1337,18 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
             prepend ::Brick::RouteSet
           end
           # Do the root route before the Rails Welcome one would otherwise take precedence
-          unless (route = ::Brick.config.default_route_fallback).blank? ||
-                 ::Rails.application.routes.named_routes.send(:routes)[:root]
-            ::Rails.application.routes.append do
-              send(:root, "#{route}#{'#index' unless route.index('#')}")
+          if (route = ::Brick.config.default_route_fallback).present?
+            action = "#{route}#{'#index' unless route.index('#')}"
+            if ::Brick.config.path_prefix
+              ::Rails.application.routes.append do
+                send(:namespace, ::Brick.config.path_prefix) do
+                  send(:root, action)
+                end
+              end
+            elsif ::Rails.application.routes.named_routes.send(:routes)[:root].nil?
+              ::Rails.application.routes.append do
+                send(:root, action)
+              end
             end
           end
         end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -113,15 +113,15 @@ 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
+    def sti_models
+      @sti_models ||= {}
+    end
 
-  def self.existing_stis
-    @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
-  end
+    def existing_stis
+      @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
+    end
 
-  class << self
     attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models
 
     def set_db_schema(params = nil)
@@ -203,11 +203,9 @@ module Brick
       skip_hms = {}
       hms.each do |hmt|
         if (through = hmt.last.options[:through])
-          skip_hms[through] = nil # if hms[through]
-          # binding.pry if !hms[through]
+          # ::Brick.relations[hmt.last.through_reflection.table_name]
+          skip_hms[through] = nil if hms[through] && model.is_brick?
           # End up with a hash of HMT names pointing to join-table associations
-          # Last part was:  hmt.last.name
-          # Changed up because looking for:  hms[:issue_issue_duplicates]
           model._br_associatives[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
         elsif hmt.last.inverse_of.nil?
           puts "SKIPPING #{hmt.last.name.inspect}"
@@ -549,7 +547,11 @@ In config/initializers/brick.rb appropriate entries would look something like:
   module RouteSet
     def finalize!
       unless ::Rails.application.routes.named_routes.route_defined?(:brick_status_path)
-        existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
+        path_prefix = ::Brick.config.path_prefix
+        existing_controllers = routes.each_with_object({}) do |r, s|
+          c = r.defaults[:controller]
+          s[c] = nil if c
+        end
         ::Rails.application.routes.append do
           tables = []
           views = []
@@ -568,7 +570,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
 
           # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
           # If auto-controllers and auto-models are both enabled then this makes sense:
-          controller_prefix = (::Brick.config.path_prefix ? "#{::Brick.config.path_prefix}/" : '')
+          controller_prefix = (path_prefix ? "#{path_prefix}/" : '')
           ::Brick.relations.each do |k, v|
             unless !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
               options = {}
@@ -583,9 +585,9 @@ In config/initializers/brick.rb appropriate entries would look something like:
                 send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_prefix}#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
               end
               # Now the normal routes
-              if ::Brick.config.path_prefix
-                # Was:  send(:scope, path: ::Brick.config.path_prefix) do
-                send(:namespace, ::Brick.config.path_prefix) do
+              if path_prefix
+                # Was:  send(:scope, path: path_prefix) do
+                send(:namespace, path_prefix) do
                   brick_routes_create.call(schema_name, controller_name, v, options)
                 end
               else

data/lib/generators/brick/install_generator.rb

@@ -298,7 +298,9 @@ if Object.const_defined?('Brick')
   # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
   # # name and action you wish in order to override this and have that be the default route when none other has been
   # # specified in routes.rb or elsewhere.  (Or just use an empty string in order to disable this behaviour.)
-  # Brick.default_route_fallback = 'customers' # This defaults to \"customers#index\"
+  # This defaults to \"customers#index\", and if there was also a prefix set called \"admin\" then it would instead
+  # go to \"admin/customers#index\".
+  # Brick.default_route_fallback = 'customers'
   # Brick.default_route_fallback = 'orders#outstanding' # Example of a non-RESTful route
   # Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.81
+  version: 1.0.83
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-18 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord