brick 1.0.76 → 1.0.77

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 615640b22db113a3959644ee9c2d08ff3a2b37aa10f12dc92d68effef091c228
-  data.tar.gz: b0d3e616b0f44584cf6960f8b8b191fc449b9afc426a6486da11c2deadece7a6
+  metadata.gz: 7e113470d473585f716cfa5b835f503448a0d160b60de20f884bf3ce2cc14c08
+  data.tar.gz: 40064f980dd6893cb4e7e47861e00b184983d1a4bbc11b7cbd16fd6caddfab87
 SHA512:
-  metadata.gz: 02a9f1c74af24e1e23df8b64972d7af8d74bbb870f1510b69d0814f362959e2527f2a7ee9ff7ca65187eb97be4fad1136d64bea7e01a8327a57608924a8f12d8
-  data.tar.gz: '0265977b746d0955c76bef269067d14363cda4373fc5f726f19fb284baf31d0df3bdaae6ffad7301b71cd630a2745db4d30f1da79ec43ef4ae1a92bc986058e9'
+  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 }

data/lib/brick/extensions.rb

@@ -256,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
 
@@ -783,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' ||
@@ -929,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
@@ -1197,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)
 
@@ -1341,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
@@ -1442,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
@@ -1465,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
@@ -1504,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
@@ -1525,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
@@ -1535,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
@@ -1543,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
@@ -1556,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') &&
@@ -1602,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
@@ -1614,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
@@ -1823,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
@@ -1834,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')"
@@ -1845,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
 
@@ -2090,7 +2134,7 @@ 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)

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

@@ -114,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)
@@ -125,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
@@ -177,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
@@ -184,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
@@ -405,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)
@@ -461,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];
@@ -523,15 +531,19 @@ if (grid) {
   function gridMove(evt) {
     var lastHighCell = gridHighCell;
     gridHighCell = document.elementFromPoint(evt.x, evt.y);
-    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\");
+    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\");
+      }
     }
   }
 }
@@ -849,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) || (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 %>
@@ -877,9 +890,9 @@ 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
@@ -927,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
@@ -984,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|
@@ -1008,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:
@@ -1043,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 %>
@@ -1101,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
 
@@ -1118,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 = 76
+    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)
@@ -538,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.

metadata

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