brick 1.0.109 → 1.0.110

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1621b6af75759b90c788ce080db85608731c2bfc026c82d7bcea011a89c2162e
-  data.tar.gz: a4242388d2fa29a12229c620d91b5d572e9e2f7688783beb6963817cf3fac340
+  metadata.gz: 3d11240139b576ead983fbe9811f4476b8819878068c46db852b515fbc0849c6
+  data.tar.gz: 2db932779fcd8517f7e5be524ce387061d4e8cab193715be76893dc1e675d1c9
 SHA512:
-  metadata.gz: fa089c1bc9663e764b783c639ca9ca24c18a5cbbc788281e11620b33277e87282b6e1a0195d12686b72f53a5ae4a5bcb9e8343e9ef9bb4d97f53fb69ad4619fe
-  data.tar.gz: 784eed99a879191dff95b5dfd061f8025d52d3e30eb16b7a754b425c2f4ad58e03e8631949d807f130dc86e55cb3a5e08d215a3f1729b4465c58dc3cecffb96d
+  metadata.gz: dd22a1ab8d2b13f2d289fe02262ae8aecb3be921094bbb5dd0392fe5cd46ecadda259e72a18c3ecb7daea0fd5f5a50d697383a4bb949b068976e3b6007769d04
+  data.tar.gz: 39d26f6c99511d3651003c660fed495223ebd4fb34865b1eaa3b8554e294ed0fb3672b17e7dc43ca43fecbd1b7dda2ec6b9a4371025880e12c83694f45557173

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)
 
@@ -2272,11 +2280,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;
     }
@@ -187,7 +190,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
@@ -452,11 +456,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
+                                if tbl_parts.first == apartment_default_schema
+                                  tbl_parts.shift
                                 end
-                                s[tbl] = nil
+                                # %%% 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
@@ -881,7 +896,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 +1152,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 +1345,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 +1426,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 +1507,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)
@@ -202,11 +203,11 @@ module Brick::Rails::FormTags
       app_routes = Rails.application.routes # In case we're operating in another engine, reference the application since Brick routes are placed there.
       if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
          (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
-        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj) : "#{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 = 110
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -601,7 +601,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 +620,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 +643,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 +662,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 +685,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 +711,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 +829,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('.', '/')

metadata

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