brick 1.0.75 → 1.0.77

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd5fdf68935981a46106c879f5ac1fb44ac790c269c3eb2c5429cd67880f916
-  data.tar.gz: 260ce60eeaf2e4b17ca5b5e76e54960c4d2685c9cb9d8549a35a16ce49b5a36c
+  metadata.gz: 7e113470d473585f716cfa5b835f503448a0d160b60de20f884bf3ce2cc14c08
+  data.tar.gz: 40064f980dd6893cb4e7e47861e00b184983d1a4bbc11b7cbd16fd6caddfab87
 SHA512:
-  metadata.gz: 00f45ff020fcd729c2115f6d9f6ab0ab588247b2d727de7e1bd6acf53fa685ef76eeecce181a7a0c4659d8156971f88466915749cfad44e993993179435acdbd
-  data.tar.gz: 74f0b40c44bae3729624ca0ba6a378f9067e4b0aa98460a03aa193e292432576327991d8c2a107317d8ce51ce223eee780a0d632d5805ca14b91a1b55388259f
+  metadata.gz: 4219dfee478a845a949b1ac9b03d0a135504723a892b571ca068af70c2b58ca52025f5e1f2fedb6a97a5b2dcd97280c5f54132b854e285e6daf7bc95d0c2d357
+  data.tar.gz: 67ae65b0de3801bbb2a1817d16b4023116ee7d41491b6d45927bd8197a8f800151f8ce79de34732a55f3dfcabbe301dc69b276899cfd544604d6a64e61220c99

data/lib/brick/config.rb

@@ -20,6 +20,15 @@ module Brick
       @serializer = Brick::Serializers::YAML
     end
 
+    # Any path prefixing to apply to all auto-generated Brick routes
+    def path_prefix
+      @mutex.synchronize { @path_prefix }
+    end
+
+    def path_prefix=(path)
+      @mutex.synchronize { @path_prefix = path }
+    end
+
     # Indicates whether Brick models are on or off. Default: true.
     def enable_models
       @mutex.synchronize { !!@enable_models }
@@ -90,6 +99,15 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
+    # Custom columns to add to a table, minimally defined with a name and DSL string
+    def custom_columns
+      @mutex.synchronize { @custom_columns }
+    end
+
+    def custom_columns=(cust_cols)
+      @mutex.synchronize { @custom_columns = cust_cols }
+    end
+
     # Skip creating a has_many association for these
     def exclude_hms
       @mutex.synchronize { @exclude_hms }

data/lib/brick/extensions.rb

@@ -100,73 +100,86 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, emit_dsl = false, is_polymorphic = false)
-      build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
-      build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
+      unless build_array.is_a?(::Brick::JoinArray)
+        build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
+        build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+      end
+      prefix = [prefix] unless prefix.is_a?(Array)
       members = []
+      unless dsl || (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
+        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
+        x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
+        return members
+      end
+
+      # Do the actual dirty work of recursing through nested DSL
       bracket_name = nil
-      prefix = [prefix] unless prefix.is_a?(Array)
-      if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
-        dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
-        dsl3 = +'' # To return expanded DSL that is nested from another model
-        klass = nil
-        dsl.each_char do |ch|
-          if bracket_name
-            if ch == ']' # Time to process a bracketed thing?
-              parts = bracket_name.split('.')
-              first_parts = parts[0..-2].map do |part|
-                klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
-                puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
-                part_sym
-              end
-              parts = prefix + first_parts + [parts[-1]]
-              if parts.length > 1
-                unless is_polymorphic
-                  s = build_array
-                  parts[0..-3].each { |v| s = s[v.to_sym] }
-                  s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
-                end
-                translations[parts[0..-2].join('.')] = klass
+      dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
+      dsl3 = +'' # To return expanded DSL that is nested from another model
+      klass = nil
+      dsl.each_char do |ch|
+        if bracket_name
+          if ch == ']' # Time to process a bracketed thing?
+            parts = bracket_name.split('.')
+            first_parts = parts[0..-2].map do |part|
+              klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
+              puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
+              part_sym
+            end
+            parts = prefix + first_parts + [parts[-1]]
+            if parts.length > 1
+              unless is_polymorphic
+                s = build_array
+                parts[0..-3].each { |v| s = s[v.to_sym] }
+                s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
               end
-              if klass.column_names.exclude?(parts.last) &&
-                 (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
-                # Expand this entry which refers to an association name
-                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
-                members += members2
-                dsl2 << dsl2a
-                dsl3 << dsl2a
-              else
-                dsl2 << "[#{bracket_name}]"
-                if emit_dsl
-                  dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
-                end
-                members << parts
+              translations[parts[0..-2].join('.')] = klass
+            end
+            if klass.column_names.exclude?(parts.last) &&
+               (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+              if prefix.empty? # Custom columns start with an empty prefix
+                prefix << parts.shift until parts.empty?
               end
-              bracket_name = nil
+              # Expand this entry which refers to an association name
+              members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
+              members += members2
+              dsl2 << dsl2a
+              dsl3 << dsl2a
             else
-              bracket_name << ch
+              dsl2 << "[#{bracket_name}]"
+              if emit_dsl
+                dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
+              end
+              members << parts
             end
-          elsif ch == '['
-            bracket_name = +''
-            klass = self
+            bracket_name = nil
           else
-            dsl2 << ch
-            dsl3 << ch
+            bracket_name << ch
           end
+        elsif ch == '['
+          bracket_name = +''
+          klass = self
+        else
+          dsl2 << ch
+          dsl3 << ch
         end
-        # Rewrite the DSL in case it's now different from having to expand it
-        # if ::Brick.config.model_descrips[name] != dsl2
-        #   puts ::Brick.config.model_descrips[name]
-        #   puts dsl2.inspect
-        #   puts dsl3.inspect
-        #   binding.pry
-        # end
-        ::Brick.config.model_descrips[name] = dsl2 unless emit_dsl
-      else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
-        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
-        x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
-      emit_dsl ? [members, dsl3] : members
+      # Rewrite the DSL in case it's now different from having to expand it
+      # if ::Brick.config.model_descrips[name] != dsl2
+      #   puts ::Brick.config.model_descrips[name]
+      #   puts dsl2.inspect
+      #   puts dsl3.inspect
+      #   binding.pry
+      # end
+      if emit_dsl
+        # Had been:  [members, dsl2, dsl3]
+        [members, dsl3]
+      else
+        ::Brick.config.model_descrips[name] = dsl2
+        members
+      end
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -177,7 +190,8 @@ module ActiveRecord
     end
 
     def self.brick_descrip(obj, data = nil, pk_alias = nil)
-      if (dsl = ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
+      dsl = obj if obj.is_a?(String)
+      if (dsl ||= ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
         idx = -1
         caches = {}
         output = +''
@@ -242,12 +256,13 @@ module ActiveRecord
       table_name == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
     end
 
-    def self._brick_index
-      tbl_parts = table_name.split('.')
+    def self._brick_index(mode = nil)
+      tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
       tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.first == Apartment.default_schema
-      if (index = tbl_parts.map(&:underscore).join('_')) == index.singularize
-        index << '_index' # Rails applies an _index suffix to that route when the resource name is singular
-      end
+      tbl_parts.unshift(::Brick.config.path_prefix) if ::Brick.config.path_prefix
+      index = tbl_parts.map(&:underscore).join('_')
+      # Rails applies an _index suffix to that route when the resource name is singular
+      index << '_index' if mode != :singular && index == index.singularize
       index
     end
 
@@ -272,18 +287,28 @@ module ActiveRecord
       def _br_associatives
         @_br_associatives ||= {}
       end
+      # Custom columns
+      def _br_cust_cols
+        @_br_cust_cols ||= {}
+      end
     end
 
-    # Search for BT, HM, and HMT DSL stuff
+    # Search for custom column, BT, HM, and HMT DSL stuff
     def self._brick_calculate_bts_hms(translations, join_array)
+      # Add any custom columns
+      ::Brick.config.custom_columns&.fetch(table_name, nil)&.each do |k, cc|
+        # false = not polymorphic, and true = yes -- please emit_dsl
+        pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, cc, true)
+        _br_cust_cols[k] = [pieces, my_dsl]
+      end
       bts, hms, associatives = ::Brick.get_bts_and_hms(self)
       bts.each do |_k, bt|
         next if bt[2] # Polymorphic?
 
         # join_array will receive this relation name when calling #brick_parse_dsl
         _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                     # Last two params here:  "false" is for don't emit DSL, and "true" is for yes, we are polymorphic
-                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, false, true) }
+                                     # Last params here:  "true" is for yes, we are polymorphic
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
                                    else
                                      { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
                                    end
@@ -314,7 +339,7 @@ module ActiveRecord
                    else # Expecting only Symbol
                      if _br_hm_counts.key?(ord_part)
                        ord_part = "\"b_r_#{ord_part}_ct\""
-                     elsif !_br_bt_descrip.key?(ord_part) && !column_names.include?(ord_part.to_s)
+                     elsif !_br_bt_descrip.key?(ord_part) && !_br_cust_cols.key?(ord_part) && !column_names.include?(ord_part.to_s)
                        # Disallow ordering by a bogus column
                        # %%% Note this bogus entry so that Javascript can remove any bogus _brick_order
                        # parameter from the querystring, pushing it into the browser history.
@@ -331,6 +356,11 @@ module ActiveRecord
       [order_by, order_by_txt]
     end
 
+    def self.brick_select(params = {}, selects = [], *args)
+      (relation = all).brick_select(params, selects, *args)
+      relation.select(selects)
+    end
+
   private
 
     def self._brick_get_fks
@@ -421,7 +451,13 @@ module ActiveRecord
       end
     end
 
-    def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+    def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+      is_add_bts = is_add_hms = true
+
+      # 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'
       is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
@@ -446,7 +482,7 @@ module ActiveRecord
       end
 
       # %%% Skip the metadata columns
-      if selects&.empty? # Default to all columns
+      if selects.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
         #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
@@ -481,7 +517,36 @@ module ActiveRecord
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
         used_col_aliases = {} # Used to make sure there is not a name clash
-        bt_columns = klass._br_bt_descrip.each_with_object([]) do |v, s|
+
+        # CUSTOM COLUMNS
+        # ==============
+        klass._br_cust_cols.each do |k, cc|
+          if 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
+            next
+          end
+
+          cc.first.each do |cc_part|
+            dest_klass = cc_part[0..-2].inject(klass) { |kl, cc_part_term| kl.reflect_on_association(cc_part_term).klass }
+            tbl_name = (field_tbl_names[k][cc_part.last] ||= shift_or_first(chains[dest_klass])).split('.').last
+            # Deal with the conflict if there are two parts in the custom column named the same,
+            # "category.name" and "product.name" for instance will end up with aliases of "name"
+            # and "product__name".
+            cc_part_idx = cc_part.length - 1
+            while cc_part_idx > 0 &&
+                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__')}") &&
+                  used_col_aliases.key?(col_alias)
+              cc_part_idx -= 1
+            end
+            selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
+            cc_part << col_alias
+            used_col_aliases[col_alias] = nil
+          end
+        end
+
+        klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
 
@@ -544,7 +609,13 @@ module ActiveRecord
       klass._br_hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
-                         hm.foreign_key if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
+                         if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
+                           if hm.source_reflection.macro == :belongs_to # Traditional HMT using an associative table
+                             hm.foreign_key
+                           else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
+                             hm.source_reflection.active_record.primary_key
+                           end
+                         end
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
@@ -596,7 +667,8 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
       end
       where!(wheres) unless wheres.empty?
       # Must parse the order_by and see if there are any symbols which refer to BT associations
-      # as they must be expanded to find the corresponding b_r_model__column naming for each.
+      # or custom columns as they must be expanded to find the corresponding b_r_model__column
+      # or br_cc_column naming for each.
       if order_by.present?
         final_order_by = *order_by.each_with_object([]) do |v, s|
           if v.is_a?(Symbol)
@@ -605,6 +677,8 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
               bt_cols.values.each do |v1|
                 v1.each { |v2| s << "\"#{v2.last}\"" if v2.length > 1 }
               end
+            elsif (cc_cols = klass._br_cust_cols[v])
+              cc_cols.first.each { |v1| s << "\"#{v1.last}\"" if v1.length > 1 }
             else
               s << v
             end
@@ -710,50 +784,60 @@ end
 Module.class_exec do
   alias _brick_const_missing const_missing
   def const_missing(*args)
-    desired_classname = (self == Object) ? args.first.to_s : "#{name}::#{args.first}"
+    requested = args.first.to_s
+    is_controller = requested.end_with?('Controller')
+    # self.name is nil when a model name is requested in an .erb file
+    if self.name && ::Brick.config.path_prefix
+      camelize_prefix = ::Brick.config.path_prefix.camelize
+      # Asking for the prefix module?
+      if self == Object && requested == camelize_prefix
+        Object.const_set(args.first, (built_module = Module.new))
+        puts "module #{camelize_prefix}; end\n"
+        return built_module
+      end
+      split_self_name.shift if (split_self_name = self.name.split('::')).first.blank?
+      if split_self_name.first == camelize_prefix
+        split_self_name.shift # Remove the identified path prefix from the split name
+        if is_controller
+          brick_root = split_self_name.empty? ? self : camelize_prefix.constantize
+        end
+      end
+    end
+    base_module = if self < ActiveRecord::Migration || !self.name
+                    brick_root || Object
+                  elsif (split_self_name || self.name.split('::')).length > 1
+                    return self._brick_const_missing(*args)
+                  else
+                    self
+                  end
+    desired_classname = (self == Object) ? requested : "#{name}::#{requested}"
     if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) && possible.name == desired_classname) ||
        # Try to require the respective Ruby file
        ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
-                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = args.first.to_s).underscore))
+                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
         ) && (require_dependency(filename) || true) &&
         ((possible = self.const_get(args.first)) && possible.name == desired_classname)
        ) ||
        # If any class has turned up so far (and we're not in the middle of eager loading)
        # then return what we've found.
-       (is_defined && !::Brick.is_eager_loading)
-      return possible
-    end
-    class_name = ::Brick.namify(args.first.to_s)
-    # self.name is nil when a model name is requested in an .erb file
-    base_module = (self < ActiveRecord::Migration || !self.name) ? Object : self
-    # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-    # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-    # that is, checking #qualified_name_for with:  from_mod, const_name
-    # If we want to support namespacing in the future, might have to utilise something like this:
-    # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
-    # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
-    # If the file really exists, go and snag it:
-    if ActiveSupport::Dependencies.search_for_file(class_name.underscore)
-      return base_module._brick_const_missing(*args)
-      # elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-      #   my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
-      #   return my_const
-    else
-      filepath = base_module.name&.split('::')&.[](0..-2) unless base_module == Object
-      filepath = ((filepath || []) + [class_name]).join('/').underscore + '.rb'
-      if ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-        return base_module._brick_const_missing(*args)
+       (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
+      if (!brick_root && (filename || possible.instance_of?(Class))) ||
+         (possible.instance_of?(Module) &&
+          ((possible.respond_to?(:module_parent) ? possible.module_parent : possible.parent) == self)
+         ) ||
+         (possible.instance_of?(Class) && possible == self) # Are we simply searching for ourselves?
+        return possible
       end
     end
-
+    class_name = ::Brick.namify(requested)
     relations = ::Brick.relations
-    # puts "ON OBJECT: #{args.inspect}" if self.module_parent == Object
-    result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
+    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
+               full_class_name = +''
+               full_class_name << "::#{(split_self_name&.first && split_self_name.join('::')) || self.name}" unless self == Object
                # (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)
-               full_class_name = +''
-               full_class_name << "::#{self.name}" unless self == Object
                singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
                full_class_name << "::#{singular_class_name}"
                if plural_class_name == 'BrickSwagger' ||
@@ -856,7 +940,9 @@ class Object
                                       schema_name
                                     else
                                       matching = "#{schema_name}.#{matching}"
-                                      (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.camelize))
+                                      # %%% Coming up with integers when tables are in schemas
+                                      # ::Brick.db_schemas[schema_name] ||= self.const_get(schema_name.camelize.to_sym)
+                                      self.const_get(schema_name.camelize)
                                     end
                     "#{schema_module&.name}::#{inheritable_name || model_name}"
                   end
@@ -1124,8 +1210,7 @@ class Object
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
 
-      namespace_name = "#{namespace.name}::" if namespace
-      code = +"class #{namespace_name}#{class_name} < ApplicationController\n"
+      code = +"class #{class_name} < ApplicationController\n"
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
@@ -1204,22 +1289,6 @@ class Object
             return
           end
 
-          # Normal (non-swagger) request
-
-          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
-          # wants to do an ORDER BY based on any of that
-          translations = {}
-          join_array = ::Brick::JoinArray.new
-          is_add_bts = is_add_hms = true
-          # This builds out bt_descrip and hm_counts on the model
-          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
-
-          # %%% Allow params to define which columns to use for order_by
-          # Overriding the default by providing a querystring param?
-          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
-
-          ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
             exported_csv = CSV.generate(force_quotes: false) do |csv_out|
@@ -1233,7 +1302,16 @@ class Object
             return
           end
 
-          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by, translations, join_array)
+          # Normal (not swagger or CSV) request
+
+          # %%% Allow params to define which columns to use for order_by
+          # Overriding the default by providing a querystring param?
+          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
+
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), nil,
+                                                                  translations = {},
+                                                                  join_array = ::Brick::JoinArray.new)
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
           counts = model._br_hm_counts.each_with_object([]) do |v, s|
@@ -1275,13 +1353,6 @@ class Object
             code << "  end\n"
             self.define_method :show do
               ::Brick.set_db_schema(params)
-              id = if model.columns_hash[pk.first]&.type == :string
-                     is_pk_string = true
-                     params[:id]
-                   else
-                     params[:id]&.split(/[\/,_]/)
-                   end
-              id = id.first if id.is_a?(Array) && id.length == 1
               instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
             end
           end
@@ -1376,7 +1447,14 @@ class Object
     @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
   end\n"
             self.define_method :find_obj do
-              id = is_pk_string ? params[:id] : params[:id]&.split(/[\/,_]/)
+              id = if model.columns_hash[pk.first]&.type == :string
+                     is_pk_string = true
+                     params[:id].gsub('^^sl^^', '/')
+                   else
+                     params[:id]&.split(/[\/,_]/).map do |val_part|
+                       val_part.gsub('^^sl^^', '/')
+                     end
+                   end
               model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
             end
           end
@@ -1399,33 +1477,55 @@ class Object
             # Get column names for params from relations[model.table_name][:cols].keys
           end
         end # unless is_swagger
-        code << "end # #{namespace_name}#{class_name}\n"
+        code << "end # #{class_name}\n"
       end # class definition
       [built_controller, code]
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc, source = nil)
-      if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
-         hm_assoc[:alternate_name] != (source || name.underscore)
-        plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
-        new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
-        # uniq = 1
-        # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
-        #   hm_assoc[:assoc_name] = "#{hm_assoc_name}_#{uniq += 1}"
-        # end
-        # puts new_alt_name
-        # hm_assoc[:assoc_name] = new_alt_name
-        [new_alt_name, true]
-      else
-        assoc_name = ::Brick.namify(hm_assoc[:inverse_table]).pluralize
-        if (needs_class = assoc_name.include?('.')) # If there is a schema name present, use a downcased version for the :has_many
-          assoc_parts = assoc_name.split('.')
-          assoc_parts[0].downcase! if assoc_parts[0] =~ /^[A-Z0-9_]+$/
-          assoc_name = assoc_parts.join('.')
+      assoc_name, needs_class = if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
+                                   hm_assoc[:alternate_name] != (source || name.underscore)
+                                  plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
+                                  new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
+                                  # uniq = 1
+                                  # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
+                                  #   hm_assoc[:assoc_name] = "#{hm_assoc_name}_#{uniq += 1}"
+                                  # end
+                                  # puts new_alt_name
+                                  # hm_assoc[:assoc_name] = new_alt_name
+                                  [new_alt_name, true]
+                                else
+                                  assoc_name = ::Brick.namify(hm_assoc[:inverse_table]).pluralize
+                                  if (needs_class = assoc_name.include?('.')) # If there is a schema name present, use a downcased version for the :has_many
+                                    assoc_parts = assoc_name.split('.')
+                                    assoc_parts[0].downcase! if assoc_parts[0] =~ /^[A-Z0-9_]+$/
+                                    assoc_name = assoc_parts.join('.')
+                                  end
+                                  # hm_assoc[:assoc_name] = assoc_name
+                                  [assoc_name, needs_class]
+                                end
+      # Already have the HM class around?
+      begin
+        if (hm_class = Object._brick_const_missing(hm_class_name = relation[:class_name].to_sym))
+          existing_hm_assocs = hm_class.reflect_on_all_associations.select do |assoc|
+            assoc.macro != :belongs_to && assoc.klass == self && assoc.foreign_key == hm_assoc[:fk]
+          end
+          # Missing a has_many in an existing class?
+          if existing_hm_assocs.empty?
+            options = { inverse_of: hm_assoc[:inverse][:assoc_name].to_sym }
+            # Add class_name and foreign_key where necessary
+            unless hm_assoc[:alternate_name] == (source || name.underscore)
+              options[:class_name] = self.name
+              options[:foreign_key] = hm_assoc[:fk].to_sym
+            end
+            hm_class.send(:has_many, assoc_name.to_sym, options)
+            puts "# ** Adding a missing has_many to #{hm_class.name}:\nclass #{hm_class.name} < #{hm_class.superclass.name}"
+            puts "  has_many :#{assoc_name}, #{options.inspect}\nend\n"
+          end
         end
-        # hm_assoc[:assoc_name] = assoc_name
-        [assoc_name, needs_class]
+      rescue NameError
       end
+      [assoc_name, needs_class]
     end
   end
 end
@@ -1438,6 +1538,7 @@ module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
     conn = _brick_establish_connection(*args)
+    begin
       # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
       # the default DEFERRED mode.
       #   https://discuss.rubyonrails.org/t/failed-write-transaction-upgrades-in-sqlite3/81480/2
@@ -1459,9 +1560,10 @@ module ActiveRecord::ConnectionHandling
           end
         end
       end
-    begin
+      # ::Brick.is_db_present = true
       _brick_reflect_tables
     rescue ActiveRecord::NoDatabaseError
+      # ::Brick.is_db_present = false
     end
     conn
   end
@@ -1469,6 +1571,8 @@ module ActiveRecord::ConnectionHandling
   # This is done separately so that during testing it can be called right after a migration
   # in order to make sure everything is good.
   def _brick_reflect_tables
+    # return if ActiveRecord::Base.connection.current_database == 'postgres'
+
     initializer_loaded = false
     if (relations = ::Brick.relations).empty?
       # If there's schema things configured then we only expect our initializer to be named exactly this
@@ -1477,8 +1581,8 @@ module ActiveRecord::ConnectionHandling
       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
-      apartment = Object.const_defined?('Apartment')
-      if apartment && File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
+      if (apartment = Object.const_defined?('Apartment')) &&
+         File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
@@ -1490,19 +1594,21 @@ module ActiveRecord::ConnectionHandling
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLServer'
         is_postgres = !is_mssql
-        db_schemas = ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;')
+        db_schemas = if is_postgres
+                       ActiveRecord::Base.execute_sql('SELECT nspname AS table_schema, MAX(oid) AS dt FROM pg_namespace GROUP BY 1 ORDER BY 1;')
+                     else
+                       ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema, NULL AS dt FROM INFORMATION_SCHEMA.tables;')
+                     end
         ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
           row = case row
-                when String
-                  row
                 when Array
-                  row.first
+                  row
                 else
-                  row['table_schema']
+                  [row['table_schema'], row['dt']]
                 end
           # Remove any system schemas
-          s[row] = nil unless ['information_schema', 'pg_catalog',
-                               'INFORMATION_SCHEMA', 'sys'].include?(row)
+          s[row.first] = row.last unless ['information_schema', 'pg_catalog', 'pg_toast',
+                                          'INFORMATION_SCHEMA', 'sys'].include?(row.first)
         end
         if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
            (sta = multitenancy[:schema_to_analyse]) != 'public') &&
@@ -1536,6 +1642,10 @@ module ActiveRecord::ConnectionHandling
           if ::Brick.db_schemas.key?(possible_schema)
             ::Brick.default_schema = schema = possible_schema
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
+          elsif Rails.env == 'test' # When testing, just find the most recently-created schema
+            ::Brick.default_schema = schema = ::Brick.db_schemas.to_a.sort { |a, b| b.last <=> a.last }.first.first
+            puts "While running tests, had noticed that in the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reverting to instead use the most recently-created schema, #{schema}."
+            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
           else
             puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\".  This schema does not exist. ***"
           end
@@ -1548,7 +1658,7 @@ module ActiveRecord::ConnectionHandling
       measures = []
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
+      when 'PostgreSQL', 'SQLite', 'SQLServer' # These bring back a hash for each row because the query uses column aliases
         # schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         ActiveRecord::Base.retrieve_schema_and_tables(sql, is_postgres, is_mssql, schema).each do |r|
           # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
@@ -1757,7 +1867,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
         AND t.table_name = c.table_name
         LEFT OUTER JOIN
-        (SELECT kcu1.constraint_schema, kcu1.table_name, kcu1.ordinal_position,
+        (SELECT kcu1.constraint_schema, kcu1.table_name, kcu1.column_name, kcu1.ordinal_position,
         tc.constraint_type, kcu1.constraint_name
         FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
         INNER JOIN INFORMATION_SCHEMA.table_constraints AS tc
@@ -1768,9 +1878,9 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         ) AS kcu ON
         -- kcu.CONSTRAINT_CATALOG = t.table_catalog AND
         kcu.CONSTRAINT_SCHEMA = c.table_schema
-        AND kcu.TABLE_NAME = c.table_name#{"
+        AND kcu.TABLE_NAME = c.table_name
+        AND kcu.column_name = c.column_name#{"
     --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}
-        AND kcu.ordinal_position = c.ordinal_position
     WHERE t.table_schema #{is_postgres || is_mssql ?
         "NOT IN ('information_schema', 'pg_catalog',
                  'INFORMATION_SCHEMA', 'sys')"
@@ -1779,7 +1889,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }
   --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
       AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
-    ORDER BY 1, t.table_type DESC, 2, c.ordinal_position"
+    ORDER BY 1, t.table_type DESC, 2, kcu.ordinal_position"
     ActiveRecord::Base.execute_sql(sql, *ar_tables)
   end
 
@@ -1902,9 +2012,7 @@ module Brick
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
         pri_tbl = is_class ? fk[4][:class].underscore : pri_tbl
         pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl&.singularize != bt_assoc_name
-        cnstr_base = cnstr_name = "(brick) #{for_tbl}_#{pri_tbl}"
-        cnstr_added_num = 1
-        cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
+        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
         missing = []
         missing << fk[1] unless relations.key?(fk[1])
         missing << primary_table unless is_class || relations.key?(primary_table)
@@ -2026,7 +2134,29 @@ module Brick
                    end
                  end
                end
-      ::Brick.relations.keys.map { |v| [(r = v.pluralize), (model = models[r])&.last&.table_name || v, migrations&.fetch(r, nil), model&.first] }
+      ::Brick.relations.keys.map { |v| [(model = models[v])&.last, model&.last&.table_name, migrations&.fetch(v, nil), model&.first] }
+    end
+
+    def ensure_unique(name, *sources)
+      base = name
+      if (added_num = name.slice!(/_(\d+)$/))
+        added_num = added_num[1..-1].to_i
+      else
+        added_num = 1
+      end
+      while (
+        name = "#{base}_#{added_num += 1}"
+        sources.each_with_object(nil) do |v, s|
+          s || case v
+               when Hash
+                 v.key?(name)
+               when Array
+                 v.include?(name)
+               end
+        end
+      )
+      end
+      name
     end
 
     # Locate orphaned records

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

@@ -33,6 +33,9 @@ module Brick
         # Additional references (virtual foreign keys)
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
+        # Custom columns to add to a table, minimally defined with a name and DSL string
+        ::Brick.custom_columns = app.config.brick.fetch(:custom_columns, nil)
+
         # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
         ::Brick.order = app.config.brick.fetch(:order, {})
 
@@ -111,7 +114,7 @@ module Brick
               if @_brick_model
                 pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(@_brick_model&.table_name, nil))
                 obj_name = model_name.split('::').last.underscore
-                path_obj_name = model_name.underscore.tr('/', '_')
+                path_obj_name = @_brick_model._brick_index(:singular)
                 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)
@@ -122,9 +125,11 @@ module Brick
                               "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if (through = hm_assoc.options[:through])
-                                 next unless @_brick_model.instance_methods.include?(through)
+                                 # %%% How to deal with weird self_ref type has_many -> has_one polymorphic stuff?
+                                 #     (or perhaps we don't need to!)
+                                 next unless @_brick_model.instance_methods.include?(through) &&
+                                             (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 associative = @_brick_model._br_associatives[hm.first]
                                  tbl_nm = if hm_assoc.options[:source]
                                             associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
                                           else
@@ -174,6 +179,7 @@ module Brick
               # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
               # environment or whatever, then get either the controllers or routes list instead
               apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
+              prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
                                 binding.pry if tbl.is_a?(Symbol)
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
@@ -181,7 +187,7 @@ module Brick
                                 end
                                 s[tbl] = nil
                               end.keys.sort.each_with_object(+'') do |v, s|
-                                s << "<option value=\"#{v.underscore.gsub('.', '/')}\">#{v}</option>"
+                                s << "<option value=\"#{prefix}#{v.underscore.gsub('.', '/')}\">#{v}</option>"
                               end.html_safe
               table_options << '<option value="brick_status">(Status)</option>'.html_safe if ::Brick.config.add_status
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
@@ -249,8 +255,8 @@ tr th {
   right: 0;
   cursor: pointer;
 }
-#headerTop tr th:hover {
-  background-color: #18B090;
+#headerTop tr th:hover, #headerTop tr th.highlight {
+  background-color: #28B898;
 }
 #exclusions {
   font-size: 0.7em;
@@ -273,6 +279,10 @@ tr th, tr td {
   padding: 0.2em 0.5em;
 }
 
+tr td.highlight {
+  background-color: #B0B0FF;
+}
+
 .show-field {
   background-color: #004998;
 }
@@ -398,6 +408,11 @@ def display_value(col_type, val)
     end
   end
 end
+# Accommodate composite primary keys that include strings with forward-slash characters
+def slashify(val)
+  val = [val] unless val.is_a?(Array)
+  val.map { |val_part| val_part.is_a?(String) ? val_part.gsub('/', '^^sl^^') : val_part }
+end
 callbacks = {} %>"
 
               if ['index', 'show', 'new', 'update'].include?(args.first)
@@ -454,7 +469,7 @@ window.addEventListener(\"pageshow\", function() {
   });
 
   if (tblSelect) { // Always present
-    var i = schemaSelect ? 1 : 0,
+    var i = #{::Brick.config.path_prefix ? '0' : 'schemaSelect ? 1 : 0'},
         changeoutList = changeout(location.href);
     for (; i < changeoutList.length; ++i) {
       tblSelect.value = changeoutList[i];
@@ -500,6 +515,38 @@ function changeout(href, param, value, trimAfter) {
 var grid = document.getElementById(\"#{table_name}\");
 #{table_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
 var headerTop = document.getElementById(\"headerTop\");
+var headerCols;
+if (grid) {
+  // COLUMN HEADER AND TABLE CELL HIGHLIGHTING
+  var gridHighHeader = null,
+      gridHighCell = null;
+  grid.addEventListener(\"mouseenter\", gridMove);
+  grid.addEventListener(\"mousemove\", gridMove);
+  grid.addEventListener(\"mouseleave\", function (evt) {
+    if (gridHighCell) gridHighCell.classList.remove(\"highlight\");
+    gridHighCell = null;
+    if (gridHighHeader) gridHighHeader.classList.remove(\"highlight\");
+    gridHighHeader = null;
+  });
+  function gridMove(evt) {
+    var lastHighCell = gridHighCell;
+    gridHighCell = document.elementFromPoint(evt.x, evt.y);
+    while (gridHighCell && gridHighCell.tagName !== \"TD\" && gridHighCell.tagName !== \"TH\")
+      gridHighCell = gridHighCell.parentElement;
+    if (gridHighCell) {
+      if (lastHighCell !== gridHighCell) {
+        gridHighCell.classList.add(\"highlight\");
+        if (lastHighCell) lastHighCell.classList.remove(\"highlight\");
+      }
+      var lastHighHeader = gridHighHeader;
+      gridHighHeader = headerCols[gridHighCell.cellIndex];
+      if (lastHighHeader !== gridHighHeader) {
+        if (gridHighHeader) gridHighHeader.classList.add(\"highlight\");
+        if (lastHighHeader) lastHighHeader.classList.remove(\"highlight\");
+      }
+    }
+  }
+}
 function setHeaderSizes() {
   // console.log(\"start\");
   // See if the headerTop is already populated
@@ -531,6 +578,7 @@ function setHeaderSizes() {
         }
       }
     }
+    headerCols = tr.childNodes;
     if (isEmpty) headerTop.appendChild(tr);
   }
   grid.style.marginTop = \"-\" + getComputedStyle(headerTop).height;
@@ -779,7 +827,8 @@ erDiagram
        cols[col_name] = col
      end
      unless @_brick_sequence # If no sequence is defined, start with all inclusions
-       @_brick_sequence = col_keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
+       cust_cols = #{model_name}._br_cust_cols
+       @_brick_sequence = col_keys + cust_cols.keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
      end
      @_brick_sequence.reject! { |nm| @_brick_excl.include?(nm) } if @_brick_excl # Reject exclusions
      @_brick_sequence.each_with_object(+'') do |col_name, s|
@@ -796,6 +845,8 @@ erDiagram
        elsif col # HM column
          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\"))}\")
+       elsif (cc = cust_cols.key?(col_name)) # Custom column
+         s << \"<th x-order=\\\"#\{col_name}\\\">#\{col_name}\"
        else # Bad column name!
          s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
        end
@@ -810,24 +861,25 @@ erDiagram
      @#{table_name}.each do |#{obj_name}|
        hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
-    <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
+    <td><%= link_to '⇛', #{path_obj_name}_path(slashify(#{obj_pk})), { class: 'big-arrow' } %></td>" if obj_pk}
     <% @_brick_sequence.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
-      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name)%>><%
+      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name) || (cust_col = cust_cols[col_name])%>><%
          if (bt = bts[col_name])
            if bt[2] # Polymorphic?
-             bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
-             base_class = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class.name.underscore
-             poly_id = #{obj_name}.send(\"#\{bt.first\}_id\")
-             %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\", send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
+             bt_class = #{obj_name}.send(\"#\{bt.first}_type\")
+             base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
+             poly_id = #{obj_name}.send(\"#\{bt.first}_id\")
+             %><%= link_to(\"#\{bt_class} ##\{poly_id}\", send(\"#\{base_class_underscored}_path\".to_sym, poly_id)) if poly_id %><%
            else
+             # binding.pry if @_brick_bt_descrip[bt.first][bt[1].first.first].nil?
              bt_txt = (bt_class = bt[1].first.first).brick_descrip(
                # 0..62 because Postgres column names are limited to 63 characters
                #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (bt_id_col = descrips.last)
              )
              bt_txt ||= \"<span class=\\\"orphan\\\">&lt;&lt; Orphaned ID: #\{val} >></span>\".html_safe if val
              bt_id = bt_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) } %>
-          <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
+          <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class._brick_index(:singular)}_path\".to_sym, bt_id)) : bt_txt %>
         <% end
          elsif (hms_col = hms_cols[col_name])
            if hms_col.length == 1 %>
@@ -838,15 +890,18 @@ erDiagram
                      descrips = @_brick_bt_descrip[col_name.to_sym][klass]
                      ho_txt = klass.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
                      ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
-                     ho_id&.first ? link_to(ho_txt, send(\"#\{klass.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt
+                     ho_id&.first ? link_to(ho_txt, send(\"#\{klass.base_class._brick_index(:singular)}_path\".to_sym, ho_id)) : ho_txt
                    else
-                     \"#\{hms_col[1] || 'View'\} #\{hms_col.first}\"
+                     \"#\{hms_col[1] || 'View'} #\{hms_col.first}\"
                    end %>
          <%= link_to txt, send(\"#\{klass._brick_index}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
         <% end
          elsif (col = cols[col_name])
            col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
     %><%=  display_value(col_type || col&.sql_type, val) %><%
+         elsif cust_col
+           data = cust_col.first.map { |cc_part| #{obj_name}.send(cc_part.last) }
+    %><%=  #{model_name}.brick_descrip(cust_col.last, data) %><%
          else # Bad column name!
       %>?<%
          end
@@ -885,7 +940,7 @@ erDiagram
   @resources.each do |r|
   %>
   <tr>
-  <td><%= link_to(r[0], \"/#\{r[0].underscore.tr('.', '/')}\") %></td>
+  <td><%= link_to(r[0], r[0] && send(\"#\{r[0]&._brick_index}_path\".to_sym)) %></td>
   <td<%= if r[1]
            ' class=\"orphan\"' unless ::Brick.relations.key?(r[1])
          else
@@ -942,12 +997,15 @@ if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(
 end
 %><%= link_to '(See all #{obj_name.pluralize})', #{@_brick_model._brick_index}_path %>
 #{erd_markup}
-<% if obj %>
+<% if obj
+      # path_options = [obj.#{pk}]
+      # path_options << { '_brick_schema':  } if
+      # url = send(:#\{model_name._brick_index(:singular)}_path, obj.#{pk})
+      options = {}
+      options[:url] = send(\"#\{#{model_name}._brick_index(:singular)}_path\".to_sym, obj) if ::Brick.config.path_prefix
+ %>
   <br><br>
-  <%= # path_options = [obj.#{pk}]
-    # path_options << { '_brick_schema':  } if
-    # url = send(:#{model_name.underscore}_path, obj.#{pk})
-    form_for(obj.becomes(#{model_name})) do |f| %>
+  <%= form_for(obj.becomes(#{model_name}), options) do |f| %>
   <table class=\"shadow\">
   <% has_fields = false
     @#{obj_name}.attributes.each do |k, val|
@@ -966,7 +1024,7 @@ end
           bt_pair = nil
           loop do
             bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
-            # Acxommodate any valid STI by going up the chain of inheritance
+            # Accommodate any valid STI by going up the chain of inheritance
             break unless bt_pair.nil? && poly_class_name = ::Brick.existing_stis[poly_class_name]
           end
           puts \"*** Might be missing an STI class called #\{orig_poly_name\} whose base class should have this:
@@ -1001,7 +1059,7 @@ end
       html_options[:prompt] = \"Select #\{bt_name\}\" %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
       <%= if (bt_obj = bt_class&.find_by(bt_pair[1] => val))
-            link_to('⇛', send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' })
+            link_to('⇛', send(\"#\{bt_class.base_class._brick_index(:singular)\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' })
           elsif val
             \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
           end %>
@@ -1059,9 +1117,10 @@ end
     <tr><td colspan=\"2\">(No displayable fields)</td></tr>
   <% end %>
   </table>
-  <% end %>
+<%   end %>
 
-  #{hms_headers.each_with_object(+'') do |hm, s|
+#{unless args.first == 'new'
+  hms_headers.each_with_object(+'') do |hm, s|
     # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
     next if hm.first.options[:through] && !hm.first.through_reflection
 
@@ -1076,14 +1135,15 @@ end
           <tr><td>(none)</td></tr>
         <% else %>
           <% collection.uniq.each do |#{hm_singular_name}| %>
-            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore.tr('/', '_')}_path([#{obj_pk}])) %></td></tr>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
           <% end %>
         <% end %>
       </table>"
     else
       s
     end
-  end}
+  end
+end}
 <% end %>
 #{script}"
 

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -216,6 +216,12 @@ module Brick
       true
     end
 
+    # Any path prefixing to apply to all auto-generated Brick routes
+    # @api public
+    def path_prefix=(path)
+      Brick.config.path_prefix = path
+    end
+
     # Switches Brick auto-models on or off, for all threads
     # @api public
     def enable_models=(value)
@@ -329,6 +335,15 @@ module Brick
       end
     end
 
+    # Custom columns to add to a table, minimally defined with a name and DSL string.
+    # @api public
+    def custom_columns=(cust_cols)
+      if cust_cols
+        cust_cols = cust_cols.call if cust_cols.is_a?(Proc)
+        Brick.config.custom_columns = cust_cols
+      end
+    end
+
     # @api public
     def order=(value)
       Brick.config.order = value
@@ -529,23 +544,40 @@ In config/initializers/brick.rb appropriate entries would look something like:
       view_class_length = 37 # Length of "Classes that can be built from views:"
       existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
       ::Rails.application.routes.append do
+        brick_routes_create = lambda do |schema_name, controller_name, v, options|
+          if schema_name # && !Object.const_defined('Apartment')
+            send(:namespace, schema_name) do
+              send(:resources, v[:resource].to_sym, **options)
+            end
+          else
+            send(:resources, v[:resource].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:
         ::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)) # && !Object.const_defined('Apartment')
-              send(:namespace, schema_name) do
-                send(:resources, v[:resource].to_sym, **options)
-              end
+            controller_prefix = (::Brick.config.path_prefix ? "#{::Brick.config.path_prefix}/" : '')
+            if (schema_name = v.fetch(:schema, nil))
               full_resource = "#{schema_name}/#{v[:resource]}"
-              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
             else
-              send(:resources, v[:resource].to_sym, **options)
               # Normally goes to something like:  /api/v1/employees
-              send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              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
+                brick_routes_create.call(schema_name, controller_name, v, options)
+              end
+            else
+              brick_routes_create.call(schema_name, controller_name, v, options)
             end
 
             if (class_name = v.fetch(:class_name, nil))

data/lib/generators/brick/install_generator.rb

@@ -139,6 +139,10 @@ module Brick
 # # Settings for the Brick gem
 # # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
 
+# # Custom path prefix to apply to all auto-generated Brick routes.  Also causes auto-generated controllers
+# # to be created inside a module with the same name.
+# ::Brick.path_prefix = 'admin'
+
 # # Normally all are enabled in development mode, and for security reasons only models are enabled in production
 # # and test.  This allows you to either (a) turn off models entirely, or (b) enable controllers, views, and routes
 # # in production.
@@ -207,6 +211,12 @@ module Brick
 # # to be the primary key.)
 #{bar}
 
+# # Custom columns to add to a table, minimally defined with a name and DSL string.
+# Brick.custom_columns = { 'users' =>  { messages:    ['[COUNT(messages)] messages', 'messages'] },
+#                          'orders' => { salesperson:  '[salesperson.first] [salesperson.last]',
+#                                        products:    ['[COUNT(order_items.product)] products', 'order_items.product' ] }
+#                        }
+
 # # Skip creating a has_many association for these (only retain the belongs_to built from this additional_reference).
 # # (Uses the same exact three-part format as would define an additional_reference)
 # # Say for instance that we didn't care to display the favourite colours that users have:

metadata

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