brick 1.0.99 → 1.0.101

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 431e2aee4c3c199095d8475eeedcc46bd95e86a47c51623e3cea7fbbde59edcd
-  data.tar.gz: 32144a9a9ab6ec60ef297f27ae73e35cc891e5f9462b9beae4e7a0534ab77135
+  metadata.gz: eba38d653370b0cc3e98f2adc82d8c475854440745bd35caab9a9a4253fc152c
+  data.tar.gz: 18ca517b90266cf5db711040a7f40c8e848600135ef0a39ad91da9cd2a0b1c89
 SHA512:
-  metadata.gz: f471bc993d97e92deae3c03e6cac9db0e350e72bd070afe5bcde1d0ca18d650b546db0d018a101009e429e9870a7e2c5e566f980c9e5b1319bc18873271c5550
-  data.tar.gz: 95f128f0f2a29cf0d1af1b5001eae27885b7e11ce23194e4a4da0141a0bfc059edd1917036f4addf1ee2aa4b69f763962e821ca31f9473048a6934dbecd8518e
+  metadata.gz: 859f48999fb0e8d1010a701e29c9f0275f716b20f54b4348576f4dbff7f68da1eb83709a51a1a7acd7debaf4dc1f82e863048ef16cda6b5f59862246e0c50787
+  data.tar.gz: d93c3db79715f62705c0b8f2f5bd2640a2756e1fbcb6aa6a7cf017a18bc31fa5e98496ea41539611c149f84870f24596c105d146484519b7f040d2f36b25ce45

data/lib/brick/extensions.rb

@@ -404,21 +404,9 @@ module ActiveRecord
     def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
       is_add_bts = is_add_hms = true
 
-      if selects.empty?
-        # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
-        # model early in case the user wants to do an ORDER BY based on any of that.
-        model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
-      else
-        is_api = true
-        # If there are any provided selects, treat them as API columns and build them as cust_cols since they
-        # can be built using DSL.
-        # false = not polymorphic, and true = yes -- please emit_dsl
-        selects.each do |api_col|
-          pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, "[#{api_col}]", true)
-          _br_cust_cols[api_col.tr('.', '_')] = [pieces, my_dsl]
-        end
-        selects.clear # Now these have become custom columns
-      end
+      # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
+      # model early in case the user wants to do an ORDER BY based on any of that.
+      model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
 
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
@@ -426,7 +414,7 @@ module ActiveRecord
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
-        next if ['_brick_schema', '_brick_order', '_brick_api', 'controller', 'action'].include?(k)
+        next if ['_brick_schema', '_brick_order', 'controller', 'action'].include?(k)
 
         if (where_col = (ks = k.split('.')).last)[-1] == '!'
           where_col = where_col[0..-2]
@@ -454,14 +442,17 @@ module ActiveRecord
         #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
         #     Relevant info here:  https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/402
         columns.each do |col|
-          next if is_api && id_parts.exclude?(col.name) # Only keep the ID columns if this is an API request
-
           col_alias = " AS #{col.name}_" if (col_name = col.name) == 'class'
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
                      elsif is_postgres || is_mssql
-                       # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
-                       cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col_name)&.first&.start_with?('xml')
+                       if is_distinct # Postgres can not use DISTINCT with any columns that are XML or JSON
+                         cast_as_text = if Brick.relations[klass.table_name]&.[](:cols)&.[](col_name)&.first == 'json'
+                                          '::jsonb' # Convert JSON to JSONB
+                                        elsif Brick.relations[klass.table_name]&.[](:cols)&.[](col_name)&.first&.start_with?('xml')
+                                          '::text' # Convert XML to text
+                                        end
+                       end
                        "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
                      elsif col.type # Could be Sqlite or Oracle
                        if col_alias || !(/^[a-z0-9_]+$/ =~ col_name)
@@ -505,6 +496,7 @@ module ActiveRecord
             # binding.pry
             next
           end
+
           key_klass = nil
           key_tbl_name = nil
           dest_pk = nil
@@ -644,19 +636,26 @@ module ActiveRecord
                          through_sources.map do |a|
                            from_clause << "\n LEFT OUTER JOIN #{a.table_name} br_t#{idx += 1} "
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
-                                            (nm = hmt_assoc.source_reflection.inverse_of&.name)
-                                            # binding.pry unless nm
+                                            nm = hmt_assoc.source_reflection.inverse_of&.name
                                             link_back << nm
                                             "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
                                           elsif src_ref.options[:as]
                                             "ON br_t#{idx}.#{src_ref.type} = '#{src_ref.active_record.name}'" + # "polymorphable_type"
                                             " AND br_t#{idx}.#{src_ref.foreign_key} = br_t#{idx - 1}.id"
                                           elsif src_ref.options[:source_type]
-                                            print "Skipping #{hm.name} --HMT-> #{hm.source_reflection.name} as it uses source_type which is not yet supported"
-                                            nix << k
-                                            bail_out = true
-                                            break
-                                          else # Standard has_many
+                                            if a == hm.source_reflection
+                                              print "Skipping #{hm.name} --HMT-> #{hm.source_reflection.name} as it uses source_type in a way which is not yet supported"
+                                              nix << k
+                                              bail_out = true
+                                              break
+                                              # "ON br_t#{idx}.#{a.foreign_type} = '#{src_ref.options[:source_type]}' AND " \
+                                              #   "br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
+                                            else # Works for HMT through a polymorphic HO
+                                              link_back << hmt_assoc.source_reflection.inverse_of&.name # Some polymorphic "_able" thing
+                                              "ON br_t#{idx - 1}.#{a.foreign_type} = '#{src_ref.options[:source_type]}' AND " \
+                                                "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.id"
+                                            end
+                                          else # Standard has_many or has_one
                                             # binding.pry unless (
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             # )
@@ -719,12 +718,13 @@ module ActiveRecord
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
         unless from_clause
+          tbl_nm = hm.macro == :has_and_belongs_to_many ? hm.join_table : hm.table_name
           hm_table_name = if is_mysql
-                            "`#{hm.table_name}`"
+                            "`#{tbl_nm}`"
                           elsif is_postgres || is_mssql
-                            "\"#{(hm.table_name).gsub('.', '"."')}\""
+                            "\"#{(tbl_nm).gsub('.', '"."')}\""
                           else
-                            hm.table_name
+                            tbl_nm
                           end
         end
         group_bys = ::Brick.is_oracle || is_mssql ? hm_selects : (1..hm_selects.length).to_a
@@ -984,7 +984,7 @@ Module.class_exec do
                                    ::Brick.is_oracle ? class_name.upcase : class_name,
                                    (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas&.include?(s) }&.camelize ||
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name) ||
-                                  (::Brick.config.table_name_prefixes&.values.include?(class_name) && class_name))
+                                  (::Brick.config.table_name_prefixes.values.include?(class_name) && class_name))
                return self.const_get(schema_name) if self.const_defined?(schema_name)
 
                # Build out a module for the schema if it's namespaced
@@ -1403,8 +1403,8 @@ class Object
         # (More information on https://docs.avohq.io/2.0/controllers.html)
         controller_base = Avo::ResourcesController
       end
-      table_name = ActiveSupport::Inflector.underscore(plural_class_name)
-      singular_table_name = ActiveSupport::Inflector.singularize(table_name)
+      table_name = model&.table_name || ActiveSupport::Inflector.underscore(plural_class_name)
+      singular_table_name = ActiveSupport::Inflector.singularize(ActiveSupport::Inflector.underscore(plural_class_name))
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
@@ -1589,14 +1589,6 @@ class Object
             order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
 
             ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
-
-            if (cc = params['_brick_api']&.split(','))
-              is_api = true
-              selects = cc
-              counts = [] # No need for any extra HM count columns
-              model._br_cust_cols.clear
-            end
-
             @_brick_params = ar_relation.brick_select(params, (selects ||= []), order_by,
                                                                translations = {},
                                                                join_array = ::Brick::JoinArray.new)
@@ -1611,14 +1603,14 @@ class Object
                      "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
                    end
             end
-
             ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
-            instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
-            if namespace && (idx = lookup_context.prefixes.index(table_name))
+            instance_variable_set("@#{table_name.split('.').last}".to_sym, ar_select)
+            table_name_no_schema = singular_table_name.pluralize
+            if namespace && (idx = lookup_context.prefixes.index(table_name_no_schema))
               lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
             end
             @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
-                             if (excl_parts = excl.split('.')).first == table_name
+                             if (excl_parts = excl.split('.')).first == table_name_no_schema
                                s << excl_parts.last
                              end
                            end
@@ -1749,7 +1741,12 @@ class Object
                        val_part.gsub('^^sl^^', '/')
                      end
                    end
-              model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+              # Support friendly_id gem
+              if Object.const_defined?('FriendlyId') && model.instance_variable_get(:@friendly_id_config)
+                model.friendly.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+              else
+                model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+              end
             end
           end
 

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

@@ -54,7 +54,7 @@ module Brick
                                       end
 
         # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
-        ::Brick.table_name_prefixes = app.config.brick.fetch(:table_name_prefixes, [])
+        ::Brick.table_name_prefixes = app.config.brick.fetch(:table_name_prefixes, {})
 
         # Columns to treat as being metadata for purposes of identifying associative tables for has_many :through
         ::Brick.metadata_columns = app.config.brick.fetch(:metadata_columns, ['created_at', 'updated_at', 'deleted_at'])
@@ -197,7 +197,7 @@ function linkSchemas() {
             class BrickTitle
               def initialize(name, view_component)
                 @vc = view_component
-                @_name = name
+                @_name = name || ''
               end
               def to_s
                 @_name.html_safe + @vc.instance_variable_get(:@__vc_helpers)&.link_to_brick(nil,
@@ -313,10 +313,10 @@ function linkSchemas() {
               end
 
               if @_brick_model
-                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(@_brick_model&.table_name, nil))
+                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch((table_name = @_brick_model.table_name.split('.').last), nil))
                 obj_name = model_name.split('::').last.underscore
                 path_obj_name = @_brick_model._brick_index(:singular)
-                table_name = obj_name.pluralize
+                table_name ||= obj_name.pluralize
                 template_link = nil
                 bts, hms = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
                 hms_columns = [] # Used for 'index'
@@ -346,13 +346,16 @@ function linkSchemas() {
                                end
                   case args.first
                   when 'index'
-                    unless skip_klass_hms.key?(assoc_name.to_sym) || hm_assoc.options[:source]
+                    if !skip_klass_hms.key?(assoc_name.to_sym) && (
+                         @_brick_model._br_hm_counts.key?(assoc_name) ||
+                         @_brick_model._br_bt_descrip.key?(assoc_name) # Will end up here if it's a has_one
+                       )
                       hm_entry = +"'#{hm_assoc.name}' => [#{assoc_name.inspect}, "
-                      hm_entry << if hm_assoc.macro == :has_many
+                      hm_entry << if hm_assoc.macro == :has_one
+                                    'nil'
+                                  else # :has_many or :has_and_belongs_to_many
                                     # Postgres column names are limited to 63 characters
                                     "'" + "b_r_#{assoc_name}_ct"[0..62] + "'"
-                                  else # has_one
-                                    'nil'
                                   end
                       hm_entry << ", #{path_keys(hm_assoc, hm_fk_name, pk).inspect}]"
                       hms_columns << hm_entry
@@ -424,14 +427,6 @@ h1, h3 {
   cursor: pointer;
 }
 
-#apiToggle {
-  border: 2px solid purple;
-}
-
-#apiToggle, .apiColName {
-  cursor: pointer;
-}
-
 #dropper {
   background-color: #eee;
 }
@@ -572,10 +567,58 @@ def hide_bcrypt(val, max_len = 200)
     '(hidden)'
   else
     if val.is_a?(String)
-      val = \"#\{val[0...max_len]}...\" if val.length > max_len
+      if (val = val.dup.strip).length > max_len
+        if val[0] == '<' # Seems to be HTML?
+          cur_len = 0
+          cur_idx = 0
+          # Find which HTML tags we might be inside so we can apply ending tags to balance
+          element_name = nil
+          in_closing = nil
+          elements = []
+          val.each_char do |ch|
+            case ch
+            when '<'
+              element_name = +''
+            when '/' # First character of tag is '/'?
+              in_closing = true if element_name == ''
+            when '>'
+              if element_name
+                if in_closing
+                  if (idx = elements.index { |tag| tag.downcase == element_name.downcase })
+                    elements.delete_at(idx)
+                  end
+                elsif (tag_name = element_name.split.first).present?
+                  elements.unshift(tag_name)
+                end
+                element_name = nil
+                in_closing = nil
+              end
+            else
+              element_name << ch if element_name
+            end
+            cur_idx += 1
+            # Unless it's inside wickets then this is real text content, and see if we're at the limit
+            break if element_name.nil? && ((cur_len += 1) > max_len)
+          end
+          val = val[0..cur_idx]
+          # Somehow still in the middle of an opening tag right at the end? (Should never happen)
+          if !in_closing && (tag_name = element_name&.split&.first)&.present?
+            elements.unshift(tag_name)
+            val << '>'
+          end
+          elements.each do |closing_tag|
+            val << \"</#\{closing_tag}>\"
+          end
+        else # Not HTML, just cut it at the length
+          val = val[0...max_len]
+        end
+        val = \"#\{val}...\"
+      end
       val = val.dup.force_encoding('UTF-8') unless val.encoding.name == 'UTF-8'
+      val
+    else
+      val.to_s
     end
-    val
   end
 end
 def display_value(col_type, val)
@@ -1002,8 +1045,12 @@ erDiagram
 +"<html>
 <head>
 #{css}
-<title>#{model_name} <%
-  if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)).present?
+<title><% model = #{model_name}
+          if sub_model = @_brick_params&.fetch(type_col = model.inheritance_column, nil)&.first
+            model = Object.const_get(sub_model.to_sym)
+          end
+       %><%= model.name %><%
+  if (description = (relation = Brick.relations[model.table_name])&.fetch(:description, nil)).present?
     %> - <%= description
 %><% end
 %></title>
@@ -1012,19 +1059,16 @@ erDiagram
 <p style=\"color: green\"><%= notice %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
-
-<%= pick_api(#{model_name}).html_safe %>
-
 <table id=\"resourceName\"><tr>
-  <td><h1>#{model_name}</h1></td>
+  <td><h1><%= model.name %></h1></td>
   <td id=\"imgErd\" title=\"Show ERD\"></td>
   <% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) %>
     <td><%= link_to_brick(
         avo_svg,
-        { index_proc: Proc.new do |model|
-                        ::Avo.railtie_routes_url_helpers.send(\"resources_#\{model.base_class.model_name.route_key}_path\".to_sym)
+        { index_proc: Proc.new do |avo_model|
+                        ::Avo.railtie_routes_url_helpers.send(\"resources_#\{model.model_name.route_key}_path\".to_sym)
                       end,
-          title: '#{model_name} in Avo' }
+          title: \"#\{model.name} in Avo\" }
       ) %></td>
   <% end %>
 </tr></table>#{template_link}<%
@@ -1036,13 +1080,13 @@ erDiagram
   <% if @_brick_params.length == 1 # %%% Does not yet work with composite keys
        k, id = @_brick_params.first
        id = id.first if id.is_a?(Array) && id.length == 1
-       origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
+       origin = (key_parts = k.split('.')).length == 1 ? model : model.reflect_on_association(key_parts.first).klass
        if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| fk[:fk] == key_parts.last }) &&
           (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
          <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination._brick_index(:singular)\}_path\".to_sym, id) %></h3><%
        end
      end %>
-  (<%= link_to 'See all #{model_name.split('::').last.pluralize}', #{@_brick_model._brick_index}_path %>)
+  (<%= link_to \"See all #\{model.base_class.name.split('::').last.pluralize}\", #{@_brick_model._brick_index}_path %>)
 <% end
    # COLUMN EXCLUSIONS
    if @_brick_excl&.present? %>
@@ -1069,10 +1113,10 @@ erDiagram
               end.join(', ')}}
 
     # If the resource is missing, has the user simply created an inappropriately pluralised name for a table?
-    @#{table_name} ||= if dym_list = instance_variables.reject do |entry|
-                            entry.to_s.start_with?('@_') ||
-                            ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
-                          end
+    @#{table_name} ||= if (dym_list = instance_variables.reject do |entry|
+                             entry.to_s.start_with?('@_') ||
+                             ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
+                           end).present?
                          msg = \"Can't find resource \\\"#{table_name}\\\".\"
                           # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
                          if (dym = DidYouMean::SpellChecker.new(dictionary: dym_list).correct('@#{table_name}')).present?
@@ -1088,13 +1132,8 @@ erDiagram
                        end
 
     # Write out the mega-grid
-    if params['_brick_api'] # API response?
-      brick_grid(@#{table_name}, @_brick_bt_descrip, @_brick_sequence, [], @_brick_excl,
-                 cols, poly_cols, {}, [], {})
-    else
-      brick_grid(@#{table_name}, @_brick_bt_descrip, @_brick_sequence, @_brick_incl, @_brick_excl,
-                 cols, poly_cols, bts, #{hms_keys.inspect}, {#{hms_columns.join(', ')}})
-    end %>
+    brick_grid(@#{table_name}, @_brick_bt_descrip, @_brick_sequence, @_brick_incl, @_brick_excl,
+               cols, poly_cols, bts, #{hms_keys.inspect}, {#{hms_columns.join(', ')}}) %>
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{path_obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}

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

@@ -11,7 +11,7 @@ module Brick::Rails::FormTags
       out << "<th x-order=\"#{pk.join(',')}\"></th>"
     end
 
-    col_keys ||= relation.columns.each_with_object([]) do |col, s|
+    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)) ||
@@ -39,8 +39,10 @@ module Brick::Rails::FormTags
                     "#{' x-order="' + col_name + '"' if true}>#{col_name}"
                   end
            elsif col # HM column
+             options = {}
+             options[col[1].inheritance_column] = col[1].name unless col[1] == col[1].base_class
              s << "<th#{' x-order="' + col_name + '"' if true}>#{col[2]} "
-             s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path"))}")
+             s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path", options))}")
            elsif cust_cols.key?(col_name) # Custom column
              s << "<th x-order=\"#{col_name}\">#{col_name}"
            elsif col_name.is_a?(Symbol) && (hot = bts[col_name]) # has_one :through
@@ -96,17 +98,17 @@ module Brick::Rails::FormTags
         if hms_col.length == 1
           out << hms_col.first
         else
-          klass = (col = cols[col_name])[1]
+          hm_klass = (col = cols[col_name])[1]
           if col[2] == 'HO'
-            descrips = bt_descrip[col_name.to_sym][klass]
+            descrips = bt_descrip[col_name.to_sym][hm_klass]
             if (ho_id = (ho_id_col = descrips.last).map { |id_col| obj.send(id_col.to_sym) })&.first
-              ho_txt = klass.brick_descrip(obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, ho_id_col)
-              out << link_to(ho_txt, send("#{klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
+              ho_txt = hm_klass.brick_descrip(obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, ho_id_col)
+              out << link_to(ho_txt, send("#{hm_klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
             end
           else
             if (ct = obj.send(hms_col[1].to_sym)&.to_i)&.positive?
               out << "#{link_to("#{ct || 'View'} #{hms_col.first}",
-                                   send("#{klass._brick_index}_path".to_sym,
+                                   send("#{hm_klass._brick_index}_path".to_sym,
                                         hms_col[2].each_with_object({}) { |v, s| s[v.first] = v.last.is_a?(String) ? v.last : obj.send(v.last) })
                                )}\n"
             end
@@ -137,51 +139,6 @@ module Brick::Rails::FormTags
     out.html_safe
   end # brick_grid
 
-  # Recursively render UL and LI to choose columns to include
-  def pick_api(model, is_last = nil, visited = [])
-    out = +''
-    if visited.empty?
-      out << '<span id="apiToggle">API buffet</span><div id="apiBuffet" style="display: none;">'
-      out << '<textarea id="apiCode" cols="100"></textarea>'
-      out << '<input type="button" id="apiRender" value="Render">'
-    end
-    out << "\n#{indent = '  ' * visited.length}<ul>"
-    model.column_names.each { |col_name| out << "\n#{indent}  <li class=\"apiColName\" x-nm=\"#{visited.map { |v| "#{v.last}." }.join}#{col_name}\">#{col_name}</li>" }
-    unless is_last || visited.length == 2
-      model.reflect_on_all_associations.each_with_object({}) do |v, s|
-        next if v.macro == :has_many || v.polymorphic?
-
-        out << "\n#{indent}  <li><b>#{v.name}</b>#{pick_api(v.klass, visited.map(&:first).include?(v.klass),
-                                                   visited.dup << [v.klass, v.name]
-                                                  )}"
-        out << "\n#{indent}  </li>"
-        s[v.name] = nil
-      end
-    end
-    out << "\n#{indent}</ul>"
-    if visited.empty?
-      out << '</div><script>[... document.getElementsByClassName("apiColName")].forEach(function (li) {li.addEventListener("click", apiColClick);});'
-      out << "
-var colList = [];
-var apiBuffet = document.getElementById(\"apiBuffet\");
-var apiCode = document.getElementById(\"apiCode\");
-function apiColClick(evt) {
-  apiCode.innerHTML += this.getAttribute(\"x-nm\") + \",\\n\";
-}
-document.getElementById(\"apiToggle\").addEventListener(\"click\", function () {
-  apiBuffet.style.display = (apiBuffet.style.display === \"block\" ? \"none\" : \"block\");
-});
-// Cheap and cheerful way to render a list of columns just for the demo
-document.getElementById(\"apiRender\").addEventListener(\"click\", function () {
-  var changecolList = apiCode.innerHTML.substring(0, apiCode.innerHTML.length - 2);
-  location.href = changeout(location.href, \"_brick_api\", changecolList);
-});
-</script>
-"
-    end
-    out
-  end
-
   def link_to_brick(*args, **kwargs)
     return unless ::Brick.config.mode == :on
 
@@ -231,13 +188,14 @@ document.getElementById(\"apiRender\").addEventListener(\"click\", function () {
         end
       end
       filter = "?#{filter_parts.join('&')}" if filter_parts.present?
+      app_routes = Rails.application.routes # In case we're operating in another engine, reference the application since Brick routes are placed there.
       if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
          (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
-        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj) : "#{send("#{klass_or_obj.base_class._brick_index}_path")}#{filter}"
+        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj) : "#{app_routes.path_for(controller: klass_or_obj.base_class._brick_index, action: :index)}#{filter}"
         lt_args = [text || "Index for #{klass_or_obj.name.pluralize}", path]
       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
-        path = (proc = kwargs[:show_proc]) ? proc.call(klass_or_obj) : "#{send("#{klass_or_obj.class.base_class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"
+        path = (proc = kwargs[:show_proc]) ? proc.call(klass_or_obj) : "#{app_routes.path_for(controller: klass_or_obj.class.base_class._brick_index, action: :show, id: klass_or_obj)}#{filter}"
         lt_args = [text || "Show this #{klass_or_obj.class.name}", path]
       end
       link_to(*lt_args, **kwargs)

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -640,50 +640,62 @@ In config/initializers/brick.rb appropriate entries would look something like:
           table_class_length = 38 # Length of "Classes that can be built from tables:"
           view_class_length = 37 # Length of "Classes that can be built from views:"
 
-          brick_routes_create = lambda do |schema_name, controller_name, v, options|
+          brick_routes_create = lambda do |schema_name, res_name, options|
             if schema_name # && !Object.const_defined('Apartment')
               send(:namespace, schema_name) do
-                send(:resources, v[:resource].to_sym, **options)
+                send(:resources, res_name.to_sym, **options)
               end
             else
-              send(:resources, v[:resource].to_sym, **options)
+              send(:resources, res_name.to_sym, **options)
             end
           end
 
           # %%% 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 = (path_prefix ? "#{path_prefix}/" : '')
+          sti_subclasses = ::Brick.config.sti_namespace_prefixes.each_with_object(Hash.new { |h, k| h[k] = [] }) do |v, s|
+                             # Turn something like {"::Spouse"=>"Person", "::Friend"=>"Person"} into {"Person"=>["Spouse", "Friend"]}
+                             s[v.last] << v.first[2..-1] unless v.first.end_with?('::')
+                           end
           ::Brick.relations.each do |k, v|
-            unless !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
-              options = {}
-              options[:only] = [:index, :show] if v.key?(:isView)
-              # First do the API routes
-              full_resource = nil
-              if (schema_name = v.fetch(:schema, nil))
-                full_resource = "#{schema_name}/#{v[:resource]}"
-                send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+            next if !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
+
+            options = {}
+            options[:only] = [:index, :show] if v.key?(:isView)
+            # First do the API routes
+            full_resource = nil
+            if (schema_name = v.fetch(:schema, nil))
+              full_resource = "#{schema_name}/#{v[:resource]}"
+              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+            else
+              # Normally goes to something like:  /api/v1/employees
+              send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_prefix}#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+            end
+
+            # Track routes being built
+            if (class_name = v.fetch(:class_name, nil))
+              if v.key?(:isView)
+                view_class_length = class_name.length if class_name.length > view_class_length
+                views
               else
-                # Normally goes to something like:  /api/v1/employees
-                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 path_prefix
-                # Was:  send(:scope, path: path_prefix) do
-                send(:namespace, path_prefix) do
-                  brick_routes_create.call(schema_name, controller_name, v, options)
+                table_class_length = class_name.length if class_name.length > table_class_length
+                tables
+              end << [class_name, full_resource || v[:resource]]
+            end
+
+            # Now the normal routes
+            if path_prefix
+              # Was:  send(:scope, path: path_prefix) do
+              send(:namespace, path_prefix) do
+                brick_routes_create.call(schema_name, v[:resource], options)
+                sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
+                  brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
                 end
-              else
-                brick_routes_create.call(schema_name, controller_name, v, options)
               end
-
-              if (class_name = v.fetch(:class_name, nil))
-                if v.key?(:isView)
-                  view_class_length = class_name.length if class_name.length > view_class_length
-                  views
-                else
-                  table_class_length = class_name.length if class_name.length > table_class_length
-                  tables
-                end << [class_name, full_resource || v[:resource]]
+            else
+              brick_routes_create.call(schema_name, v[:resource], options)
+              sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
+                brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
               end
             end
           end
@@ -1322,24 +1334,26 @@ module ActiveRecord
       private
 
         # %%% Pretty much have to flat-out replace this guy (I think anyway)
-        # Good with Rails 5.24 and 7 on this
-        def build(associations, base_klass, root = nil, path = '')
-          root ||= associations
-          associations.map do |name, right|
-            reflection = find_reflection base_klass, name
-            reflection.check_validity!
-            reflection.check_eager_loadable!
-
-            if reflection.polymorphic?
-              raise EagerLoadPolymorphicError.new(reflection)
-            end
+        # Good with Rails 5.24 through 7 on this
+        # Ransack gem includes Polyamorous which replaces #build in a different way (which we handle below)
+        unless Gem::Specification.all_names.any? { |g| g.start_with?('ransack-') }
+          def build(associations, base_klass, root = nil, path = '')
+            root ||= associations
+            associations.map do |name, right|
+              reflection = find_reflection base_klass, name
+              reflection.check_validity!
+              reflection.check_eager_loadable!
+
+              if reflection.polymorphic?
+                raise EagerLoadPolymorphicError.new(reflection)
+              end
 
-            # %%% The path
-            link_path = path.blank? ? name.to_s : path + ".#{name}"
-            ja = JoinAssociation.new(reflection, build(right, reflection.klass, root, link_path))
-            ja.instance_variable_set(:@link_path, link_path) # Make note on the JoinAssociation of its AR path
-            ja.instance_variable_set(:@assocs, root)
-            ja
+              link_path = path.blank? ? name.to_s : path + ".#{name}"
+              ja = JoinAssociation.new(reflection, build(right, reflection.klass, root, link_path))
+              ja.instance_variable_set(:@link_path, link_path) # Make note on the JoinAssociation of its AR path
+              ja.instance_variable_set(:@assocs, root)
+              ja
+            end
           end
         end
 
@@ -1348,10 +1362,9 @@ module ActiveRecord
           alias _brick_table_aliases_for table_aliases_for
           def table_aliases_for(parent, node)
             result = _brick_table_aliases_for(parent, node)
-
             # Capture the table alias name that was chosen
-            link_path = node.instance_variable_get(:@link_path)
             if (relation = node.instance_variable_get(:@assocs)&.instance_variable_get(:@relation))
+              link_path = node.instance_variable_get(:@link_path)
               relation.brick_links[link_path] = result.first.table_alias || result.first.table_name
             end
             result
@@ -1360,11 +1373,14 @@ module ActiveRecord
           alias _brick_make_constraints make_constraints
           def make_constraints(parent, child, join_type)
             result = _brick_make_constraints(parent, child, join_type)
-
             # Capture the table alias name that was chosen
-            link_path = child.instance_variable_get(:@link_path)
             if (relation = child.instance_variable_get(:@assocs)&.instance_variable_get(:@relation))
-              relation.brick_links[link_path] = result.first.left.table_alias || result.first.left.table_name
+              link_path = child.instance_variable_get(:@link_path)
+              relation.brick_links[link_path] = if child.table.is_a?(Arel::Nodes::TableAlias)
+                                                  child.table.right
+                                                else
+                                                  result.first&.left&.table_alias || child.table_name
+                                                end
             end
             result
           end
@@ -1374,4 +1390,47 @@ module ActiveRecord
   end
 end
 
+# Now the Ransack Polyamorous version of #build
+if Gem::Specification.all_names.any? { |g| g.start_with?('ransack-') }
+  require "polyamorous/activerecord_#{::ActiveRecord::VERSION::STRING[0, 3]}_ruby_2/join_dependency"
+  module Polyamorous::JoinDependencyExtensions
+    def build(associations, base_klass, root = nil, path = '')
+      root ||= associations
+      puts associations.map(&:first)
+
+      associations.map do |name, right|
+        link_path = path.blank? ? name.to_s : path + ".#{name}"
+        ja = if name.is_a? ::Polyamorous::Join
+               reflection = find_reflection base_klass, name.name
+               reflection.check_validity!
+               reflection.check_eager_loadable!
+
+               klass = if reflection.polymorphic?
+                         name.klass || base_klass
+                       else
+                         reflection.klass
+                       end
+               ::ActiveRecord::Associations::JoinDependency::JoinAssociation.new(
+                 reflection, build(right, klass, root, link_path), name.klass, name.type
+               )
+             else
+               reflection = find_reflection base_klass, name
+               reflection.check_validity!
+               reflection.check_eager_loadable!
+
+               if reflection.polymorphic?
+                 raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
+               end
+               ::ActiveRecord::Associations::JoinDependency::JoinAssociation.new(
+                 reflection, build(right, reflection.klass, root, link_path)
+               )
+             end
+        ja.instance_variable_set(:@link_path, link_path) # Make note on the JoinAssociation of its AR path
+        ja.instance_variable_set(:@assocs, root)
+        ja
+      end
+    end
+  end
+end
+
 require 'brick/extensions'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.99
+  version: 1.0.101
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-06 00:00:00.000000000 Z
+date: 2022-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord