brick 1.0.109 → 1.0.111

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1621b6af75759b90c788ce080db85608731c2bfc026c82d7bcea011a89c2162e
-  data.tar.gz: a4242388d2fa29a12229c620d91b5d572e9e2f7688783beb6963817cf3fac340
+  metadata.gz: cb97e4a946526ed99a24e67b1e65d5f6490a40c97dc170dd0680166b087d1ccb
+  data.tar.gz: 48d9c4f2afcd737d9a857f8c771448639c1b0d2d568dc966bbe4b85a97cb4610
 SHA512:
-  metadata.gz: fa089c1bc9663e764b783c639ca9ca24c18a5cbbc788281e11620b33277e87282b6e1a0195d12686b72f53a5ae4a5bcb9e8343e9ef9bb4d97f53fb69ad4619fe
-  data.tar.gz: 784eed99a879191dff95b5dfd061f8025d52d3e30eb16b7a754b425c2f4ad58e03e8631949d807f130dc86e55cb3a5e08d215a3f1729b4465c58dc3cecffb96d
+  metadata.gz: 383d9996affbbd4fa049ab125490879143299a5477e98f921d450ea6b5b466d66a4cd210aac8db9c105a6eaf5f10eae8ac181d84d78fb6fc0b4c4151ac9dcee3
+  data.tar.gz: b9902fc959b0de870ef5c402fe75e76d939d0c7c5abc7b8d3c16451b87f56929eb6e329153c6b5697936f10228752ba3b2f5f2a7de6aa5c9c77c105c34dd2cfa

data/lib/brick/extensions.rb

@@ -261,9 +261,16 @@ module ActiveRecord
       assoc_html_name ? "#{assoc_name}-#{link}".html_safe : link
     end
 
-    def self._brick_index(mode = nil, separator = '_')
+    # Providing a relation object allows auto-modules built from table name prefixes to work
+    def self._brick_index(mode = nil, separator = '_', relation = nil)
       tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
       tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
+      if (aps = relation&.fetch(:auto_prefixed_schema, nil)) && tbl_parts.last.start_with?(aps)
+        last_part = tbl_parts.last[aps.length..-1]
+        aps = aps[0..-2] if aps[-1] == '_'
+        tbl_parts[-1] = aps
+        tbl_parts << last_part
+      end
       tbl_parts.unshift(::Brick.config.path_prefix) if ::Brick.config.path_prefix
       index = tbl_parts.map(&:underscore).join(separator)
       # Rails applies an _index suffix to that route when the resource name is singular
@@ -1005,7 +1012,8 @@ Module.class_exec do
 
              # MODULE
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
-                   base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
+                   # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
+                   (base_module == Object || (camelize_prefix && base_module == Object.const_get(camelize_prefix))) &&
                    (schema_name = [(singular_table_name = class_name.underscore),
                                    (table_name = singular_table_name.pluralize),
                                    ::Brick.is_oracle ? class_name.upcase : class_name,
@@ -1437,7 +1445,7 @@ class Object
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ['Mysql2', 'Trilogy'].include?(ActiveRecord::Base.connection.adapter_name)
 
-      code = +"class #{class_name} < #{controller_base&.name || 'ApplicationController'}\n"
+      code = +"class #{namespace}::#{class_name} < #{controller_base&.name || 'ApplicationController'}\n"
       built_controller = Class.new(controller_base || ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
@@ -2011,6 +2019,21 @@ end.class_exec do
       # .default_schema are specified then we can work with non-tenanted models more appropriately
       if (apartment = Object.const_defined?('Apartment')) &&
          File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
+        require 'apartment/adapters/abstract_adapter'
+        Apartment::Adapters::AbstractAdapter.class_exec do
+          if instance_methods.include?(:process_excluded_models)
+            def process_excluded_models
+              # All other models will share a connection (at Apartment.connection_class) and we can modify at will
+              Apartment.excluded_models.each do |excluded_model|
+                begin
+                  process_excluded_model(excluded_model)
+                rescue NameError => e
+                  (@bad_models ||= []) << excluded_model
+                end
+              end
+            end
+          end
+        end
         unless @_apartment_loaded
           load apartment_initializer
           @_apartment_loaded = true
@@ -2049,13 +2072,27 @@ end.class_exec do
             schema = possible_schema
             orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
             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[:dt] <=> a.last[:dt] }.first.first
-            puts "While running tests, had noticed in the brick.rb initializer that the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reading table structure from the most recently-created schema, #{schema}."
+          # When testing, just find the most recently-created schema
+          elsif begin
+                  Rails.env == 'test' ||
+                    ActiveRecord::Base.execute_sql("SELECT value FROM ar_internal_metadata WHERE key='environment';").first&.fetch('value', nil) == 'test'
+                rescue
+                end
+            ::Brick.default_schema = ::Brick.apartment_default_tenant
+            ::Brick.test_schema = schema = ::Brick.db_schemas.to_a.sort { |a, b| b.last[:dt] <=> a.last[:dt] }.first.first
+            if possible_schema.blank?
+              puts "While running tests, using the most recently-created schema, #{schema}."
+            else
+              puts "While running tests, had noticed in the brick.rb initializer that the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reading table structure from the most recently-created schema, #{schema}."
+            end
             orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
+            ::Brick.config.schema_behavior = { multitenant: {} } # schema_to_analyse: [schema]
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
           else
             puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
+            if ::Brick.db_schemas.key?(::Brick.apartment_default_tenant)
+              ::Brick.default_schema = schema = ::Brick.apartment_default_tenant
+            end
           end
         end
       when 'Mysql2', 'Trilogy'
@@ -2272,11 +2309,20 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == ::Brick.apartment_default_tenant
       v[:schema] = schema_names.join('.') unless schema_names.empty?
       # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
-      v[:resource] = rel_name.last
       if (singular = rel_name.last.singularize).blank?
         singular = rel_name.last
       end
-      v[:class_name] = (schema_names + [singular]).map(&:camelize).join('::')
+      name_parts = if (tnp = ::Brick.config.table_name_prefixes
+                                    .find { |k1, _v1| singular.start_with?(k1) && singular.length > k1.length }
+                      ).present?
+                     v[:auto_prefixed_schema] = tnp.first
+                     v[:resource] = rel_name.last[(tnp_length = tnp.first.length)..-1]
+                     [tnp.last, singular[tnp_length..-1]]
+                   else
+                     v[:resource] = rel_name.last
+                     [singular]
+                   end
+      v[:class_name] = (schema_names + name_parts).map(&:camelize).join('::')
     end
     ::Brick.load_additional_references if ::Brick.initializer_loaded
 

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

@@ -10,10 +10,13 @@ module Brick
   if (param === undefined || param === null || param === -1) {
     hrefParts = hrefParts[0].split(\"://\");
     var pathParts = hrefParts[hrefParts.length - 1].split(\"/\").filter(function (pp) {return pp !== \"\";});
-    if (value === undefined)
+    if (value === undefined) {
       // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
-      return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)[0]];
-    else {
+      if (pathParts.length > 3)
+        return [pathParts.slice(1, 4).join('/'), pathParts.slice(1, 3).join('/')];
+      else
+        return [pathParts.slice(1, 3).join('/'), pathParts[1]];
+    } else {
       var queryString = param ? \"?\" + params.join(\"&\") : \"\";
       return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value + queryString;
     }
@@ -33,11 +36,12 @@ module Brick
 // This PageTransitionEvent fires when the page first loads, as well as after any other history
 // transition such as when using the browser's Back and Forward buttons.
 window.addEventListener(\"pageshow\", linkSchemas);
-var brickSchema;
+var brickSchema,
+    brickTestSchema;
 function linkSchemas() {
   var schemaSelect = document.getElementById(\"schema\");
   var tblSelect = document.getElementById(\"tbl\");
-  if (tblSelect) { // Always present
+  if (tblSelect) { // Always present for Brick pages
     // Used to be:  var i = # {::Brick.config.path_prefix ? '0' : 'schemaSelect ? 1 : 0'},
     var changeoutList = changeout(location.href);
     for (var i = 0; i < changeoutList.length; ++i) {
@@ -50,32 +54,32 @@ function linkSchemas() {
       if (brickSchema) lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
       location.href = lhr;
     });
-  }
 
-  if (schemaSelect) { // First drop-down is only present if multitenant
-    if (brickSchema = changeout(location.href, \"_brick_schema\")) {
-      [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
-    }
-    if (schemaSelect.options.length > 1) {
-      schemaSelect.value = brickSchema || \"public\";
-      schemaSelect.addEventListener(\"change\", function () {
-        // If there's an ID then remove it (trim after selected table)
-        location.href = changeout(location.href, \"_brick_schema\", this.value, tblSelect.value);
-      });
+    if (schemaSelect) { // First drop-down is only present if multitenant
+      if (brickSchema = changeout(location.href, \"_brick_schema\")) {
+        [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
+      }
+      if (schemaSelect.options.length > 1) {
+        schemaSelect.value = brickSchema || brickTestSchema || \"public\";
+        schemaSelect.addEventListener(\"change\", function () {
+          // If there's an ID then remove it (trim after selected table)
+          location.href = changeout(location.href, \"_brick_schema\", this.value, tblSelect.value);
+        });
+      }
     }
-  }
-  tblSelect.focus();
-
-  [... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
-    if (brickSchema)
-      form.action = changeout(form.action, \"_brick_schema\", brickSchema);
-    form.addEventListener('submit', function (ev) {
-      [... ev.target.getElementsByTagName(\"SELECT\")].forEach(function (select) {
-        if (select.value === \"^^^brick_NULL^^^\") select.value = null;
+    tblSelect.focus();
+
+    [... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
+      if (brickSchema)
+        form.action = changeout(form.action, \"_brick_schema\", brickSchema);
+      form.addEventListener('submit', function (ev) {
+        [... ev.target.getElementsByTagName(\"SELECT\")].forEach(function (select) {
+          if (select.value === \"^^^brick_NULL^^^\") select.value = null;
+        });
+        return true;
       });
-      return true;
     });
-  });
+  }
 };
 "
 
@@ -187,7 +191,8 @@ function linkSchemas() {
                                  s[r.name[0..-9]] = nil if r.name.end_with?('Resource')
                                end
                     ::Brick.relations.each do |k, v|
-                      unless existing.key?(class_name = v[:class_name]) || Brick.config.exclude_tables.include?(k) || class_name.blank?
+                      unless existing.key?(class_name = v[:class_name]) || Brick.config.exclude_tables.include?(k) ||
+                             class_name.blank? || class_name.include?('::')
                         Object.const_get("#{class_name}Resource")
                       end
                     end
@@ -355,15 +360,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                      (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
                      (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
                      (is_crosstab = args[0..1] == ['crosstab', ['brick_gem']])
-                if ActionView.version < ::Gem::Version.new('5.0') # %%% Not sure if this should be perhaps 4.2 instead
-                  begin
-                    if (possible_template = _brick_find_template(*args, **options))
-                      return possible_template
-                    end
-                  rescue
+                begin
+                  if (possible_template = _brick_find_template(*args, **options))
+                    return possible_template
                   end
-                elsif (possible_template = _brick_find_template(*args, **options))
-                  return possible_template
+                rescue
                 end
                 # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
                 model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name
@@ -452,11 +453,22 @@ window.addEventListener(\"popstate\", linkSchemas);
               # %%% 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
               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|
-                                if (tbl_parts = tbl.split('.')).first == apartment_default_schema
-                                  tbl = tbl_parts.last
+              table_options = ::Brick.relations.each_with_object({}) do |rel, s|
+                                next if ::Brick.config.exclude_tables.include?(rel.first)
+
+                                tbl_parts = rel.first.split('.')
+                                if (aps = rel.last.fetch(:auto_prefixed_schema, nil))
+                                  tbl_parts << tbl_parts.last[aps.length..-1]
+                                  aps = aps[0..-2] if aps[-1] == '_'
+                                  tbl_parts[-2] = aps
                                 end
-                                s[tbl] = nil
+                                if tbl_parts.first == apartment_default_schema
+                                  tbl_parts.shift
+                                end
+                                # %%% When table_name_prefixes are use then during rendering empty non-TNP
+                                # entries get added at some point when an attempt is made to find the table.
+                                # Will have to hunt that down at some point.
+                                s[tbl_parts.join('.')] = nil unless rel.last[:cols].empty?
                               end.keys.sort.each_with_object(+'') do |v, s|
                                 s << "<option value=\"#{prefix}#{v.underscore.gsub('.', '/')}\">#{v}</option>"
                               end.html_safe
@@ -836,8 +848,9 @@ document.querySelectorAll(\"input[type=submit][data-confirm]\").forEach(function
   });
 });
 
-#{JS_CHANGEOUT}
-
+#{JS_CHANGEOUT}#{
+  "\nbrickTestSchema = \"#{::Brick.test_schema}\";" if ::Brick.test_schema
+}
 // Snag first TR for sticky header
 var grid = document.getElementById(\"#{table_name}\");
 #{table_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
@@ -881,7 +894,8 @@ if (grid) {
   // });
 }
 function setHeaderSizes() {
-  document.getElementById(\"titleBox\").style.width = grid.clientWidth;
+  if (grid.clientWidth > window.outerWidth)
+    document.getElementById(\"titleBox\").style.width = grid.clientWidth;
   // console.log(\"start\");
   // See if the headerTop is already populated
   // %%% Grab the TRs from headerTop, clear it out, do this stuff, add them back
@@ -1136,12 +1150,13 @@ erDiagram
   <td><h1><%= td_count = 2
               model.name %></h1></td>
   <td id=\"imgErd\" title=\"Show ERD\"></td>
-  <% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace)
+  <% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) && model.name.exclude?('::')
        td_count += 1 %>
     <td><%= link_to_brick(
         avo_svg,
-        { index_proc: Proc.new do |avo_model|
-                        ::Avo.railtie_routes_url_helpers.send(\"resources_#\{model.model_name.route_key}_path\".to_sym)
+        { index_proc: Proc.new do |avo_model, relation|
+                        path_helper = \"resources_#\{relation.fetch(:auto_prefixed_schema, nil)}#\{model.model_name.route_key}_path\".to_sym
+                        ::Avo.railtie_routes_url_helpers.send(path_helper) if ::Avo.railtie_routes_url_helpers.respond_to?(path_helper)
                       end,
           title: \"#\{model.name} in Avo\" }
       ) %></td>
@@ -1328,8 +1343,9 @@ erDiagram
 <% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) %>
   <td><%= link_to_brick(
       avo_svg,
-      { show_proc: Proc.new do |obj|
-                     ::Avo.railtie_routes_url_helpers.send(\"resources_#\{obj.class.base_class.model_name.singular_route_key}_path\".to_sym, obj)
+      { show_proc: Proc.new do |obj, relation|
+                     path_helper = \"resources_#\{relation.fetch(:auto_prefixed_schema, nil)}#\{obj.class.base_class.model_name.singular_route_key}_path\".to_sym
+                     ::Avo.railtie_routes_url_helpers.send(path_helper, obj) if ::Avo.railtie_routes_url_helpers.respond_to?(path_helper)
                    end,
         title: \"#\{page_title} in Avo\" }
     ) %></td>
@@ -1408,8 +1424,8 @@ end
             \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
           end %>
     <% else
-      col_type = col.sql_type == 'geography' ? col.sql_type : col.type
-      case (col_type ||= col.sql_type)
+      col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
+      case (col_type ||= col&.sql_type)
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly?
              is_revert = false %>
@@ -1489,9 +1505,9 @@ end
                        # association that points to an STI model then filtering for the __able_type column is done
                        # with a .where(). And the polymorphic class name it points to is the base class name of
                        # the STI model instead of its subclass.
-                       if (poly_type = #{poly_type.inspect}) &&
-                           @#{obj_name}.respond_to?(:#{@_brick_model.inheritance_column}) &&
-                           (base_type = collection.where_values_hash[poly_type])
+                       poly_type = #{poly_type.inspect}
+                       if poly_type && @#{obj_name}.respond_to?(:#{@_brick_model.inheritance_column}) &&
+                          (base_type = collection.where_values_hash[poly_type])
                          collection = collection.rewhere(poly_type => [base_type, @#{obj_name}.#{@_brick_model.inheritance_column}])
                        end"
       end

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

@@ -162,8 +162,9 @@ module Brick::Rails::FormTags
                    @_brick_model
     # If not provided, do a best-effort to automatically determine the resource class or object
     filter_parts = []
+    rel_name = nil
     klass_or_obj ||= begin
-                       klass, sti_type = ::Brick.ctrl_to_klass(controller_path)
+                       klass, sti_type, rel_name = ::Brick.ctrl_to_klass(controller_path)
                        if klass
                          type_col = klass.inheritance_column # Usually 'type'
                          filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
@@ -200,13 +201,14 @@ module Brick::Rails::FormTags
       end
       filter = "?#{filter_parts.join('&')}" if filter_parts.present?
       app_routes = Rails.application.routes # In case we're operating in another engine, reference the application since Brick routes are placed there.
+      relation = ::Brick.relations.fetch(rel_name || args.first.table_name, nil)
       if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
          (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
-        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj) : "#{app_routes.path_for(controller: klass_or_obj.base_class._brick_index(nil, '/'), action: :index)}#{filter}"
+        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj, relation) : "#{app_routes.path_for(controller: klass_or_obj.base_class._brick_index(nil, '/', relation), action: :index)}#{filter}"
         lt_args = [text || "Index for #{klass_or_obj.name.pluralize}", path]
       else
         # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
-        path = (proc = kwargs[:show_proc]) ? proc.call(klass_or_obj) : "#{app_routes.path_for(controller: klass_or_obj.class.base_class._brick_index(nil, '/'), action: :show, id: klass_or_obj)}#{filter}"
+        path = (proc = kwargs[:show_proc]) ? proc.call(klass_or_obj, relation) : "#{app_routes.path_for(controller: klass_or_obj.class.base_class._brick_index(nil, '/', relation), action: :show, id: klass_or_obj)}#{filter}"
         lt_args = [text || "Show this #{klass_or_obj.class.name}", path]
       end
       kwargs.delete(:visited)

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -135,7 +135,8 @@ module Brick
       @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
     end
 
-    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models, :initializer_loaded
+    attr_accessor :default_schema, :db_schemas, :test_schema,
+                  :routes_done, :is_oracle, :is_eager_loading, :auto_models, :initializer_loaded
 
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
@@ -148,6 +149,10 @@ module Brick
                   ::Brick.db_schemas&.key?(schema)
                  Apartment::Tenant.switch!(schema)
                  schema
+               elsif ::Brick.test_schema
+                 is_show_schema_list = true
+                 Apartment::Tenant.switch!(::Brick.test_schema)
+                 ::Brick.test_schema
                else
                  current_schema # Just return the current schema
                end
@@ -601,7 +606,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
     def display_classes(prefix, rels, max_length)
       rels.sort.each do |rel|
         (::Brick.auto_models ||= []) << rel.first
-        puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{prefix}#{rel.last}"
+        puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{prefix}#{"#{rel[1]}/" if rel[1]}#{rel.last}"
       end
       puts "\n"
     end
@@ -620,16 +625,21 @@ In config/initializers/brick.rb appropriate entries would look something like:
       end
 
       c_path_parts = ctrl_path.split('/')
+      found = nil
       while c_path_parts.present?
         possible_c_path = c_path_parts.join('.')
         possible_c_path_singular = c_path_parts[0..-2] + [c_path_parts.last.singularize]
         possible_sti = possible_c_path_singular.join('/').camelize
         break if (
-                   res_name = res_names[possible_c_path] ||
+                   res_name = res_names[found = possible_c_path] ||
                               ((klass = Brick.config.sti_namespace_prefixes.key?("::#{possible_sti}") && possible_sti.constantize) &&
                                (sti_type = possible_sti)) ||
                               # %%% Used to have the more flexible:  (DidYouMean::SpellChecker.new(dictionary: res_names.keys).correct(possible_c_path)).first
-                              res_names[possible_c_path] || res_names[possible_c_path_singular.join('.')]
+                              res_names[found = possible_c_path] || res_names[found = possible_c_path_singular.join('.')] ||
+                              ((::Brick.config.table_name_prefixes.key?(tn_prefix = c_path_parts.first) ||
+                                ::Brick.config.table_name_prefixes.key?(tn_prefix = "#{c_path_parts.first}_")) &&
+                               res_names[found = tn_prefix + c_path_parts.last]
+                              )
                  ) &&
                  (
                    klass ||
@@ -638,7 +648,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
                  )
         c_path_parts.shift
       end
-      [klass, sti_type]
+      [klass, sti_type, found]
     end
   end
 
@@ -657,10 +667,14 @@ In config/initializers/brick.rb appropriate entries would look something like:
           table_class_length = 38 # Length of "Classes that can be built from tables:"
           view_class_length = 37 # Length of "Classes that can be built from views:"
 
-          brick_routes_create = lambda do |schema_name, res_name, options|
-            if schema_name # && !Object.const_defined('Apartment')
-              send(:namespace, schema_name) do
-                send(:resources, res_name.to_sym, **options)
+          brick_namespace_create = lambda do |path_names, res_name, options|
+            if path_names&.present?
+              if (path_name = path_names.pop).is_a?(Array)
+                module_name = path_name[1]
+                path_name = path_name.first
+              end
+              send(:scope, { module: module_name || path_name, path: path_name, as: path_name }) do
+                brick_namespace_create.call(path_names, res_name, options)
               end
             else
               send(:resources, res_name.to_sym, **options)
@@ -676,13 +690,24 @@ In config/initializers/brick.rb appropriate entries would look something like:
                            end
           versioned_views = {} # Track which views have already been done for each api_root
           ::Brick.relations.each do |k, v|
-            next if !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
-
-            object_name = k.split('.').last # Take off any first schema part
             if (schema_name = v.fetch(:schema, nil))
               schema_prefix = "#{schema_name}."
             end
 
+            next if !(resource_name = v.fetch(:resource, nil)) ||
+                    existing_controllers.key?(controller_name = (
+                                                resource_name = "#{schema_prefix&.tr('.', '/')}#{resource_name}"
+                                             ).pluralize)
+
+            object_name = k.split('.').last # Take off any first schema part
+
+            full_schema_prefix = if (aps = v.fetch(:auto_prefixed_schema, nil))
+                                   aps = aps[0..-2] if aps[-1] == '_'
+                                   (schema_prefix&.dup || +'') << "#{aps}."
+                                 else
+                                   schema_prefix
+                                 end
+
             # Track routes being built
             if (class_name = v.fetch(:class_name, nil))
               if v.key?(:isView)
@@ -691,26 +716,20 @@ In config/initializers/brick.rb appropriate entries would look something like:
               else
                 table_class_length = class_name.length if class_name.length > table_class_length
                 tables
-              end << [class_name, "#{schema_prefix&.tr('.', '/')}#{v[:resource]}"]
+              end << [class_name, aps, resource_name]
             end
 
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
 
             # First do the normal routes
-            if path_prefix
-              # Was:  send(:scope, path: path_prefix) do
-              send(:namespace, path_prefix) do
-                brick_routes_create.call(schema_name, v[:resource], options)
-                sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
-                  brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
-                end
-              end
-            else
-              brick_routes_create.call(schema_name, v[:resource], options)
-              sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
-                brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
-              end
+            prefixes = []
+            prefixes << [aps, v[:class_name]&.split('::')[-2]&.underscore] if aps
+            prefixes << schema_name if schema_name
+            prefixes << path_prefix if path_prefix
+            brick_namespace_create.call(prefixes, v[:resource], options)
+            sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
+              brick_namespace_create.call(prefixes, sc.underscore.tr('/', '_').pluralize, options)
             end
 
             # Now the API routes if necessary
@@ -815,9 +834,8 @@ In config/initializers/brick.rb appropriate entries would look something like:
                 # view_ver_num = if (first_part = k.split('_').first) =~ /^v[\d_]+/
                 #                  first_part[1..-1].gsub('_', '.').to_i
                 #                end
-
                 controller_name = if (last = view_relation.fetch(:resource, nil)&.pluralize)
-                                    "#{schema_prefix}#{last}"
+                                    "#{full_schema_prefix}#{last}"
                                   else
                                     found
                                   end.tr('.', '/')
@@ -1484,12 +1502,12 @@ module ActiveRecord
         # entry in your .select().
         # More information:  https://discuss.rubyonrails.org/t/includes-and-select-for-joined-data/81640
         def apply_column_aliases(relation)
-          if (sel_vals = relation.select_values.map(&:to_s)).first == '_brick_eager_load'
+          if !(@join_root_alias = relation.select_values.empty?) &&
+             relation.select_values.first.to_s == '_brick_eager_load'
+            relation.select_values.shift
             used_cols = {}
             # Find and expand out all column names being used in select(...)
-            new_select_values = sel_vals.each_with_object([]) do |col, s|
-              next if col == '_brick_eager_load'
-
+            new_select_values = relation.select_values.map(&:to_s).each_with_object([]) do |col, s|
               if col.include?(' ') # Some expression? (No chance for a simple column reference)
                 s << col # Just pass it through
               else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.109
+  version: 1.0.111
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-27 00:00:00.000000000 Z
+date: 2023-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord