brick 1.0.27 → 1.0.30

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

@@ -55,7 +55,9 @@ module Brick
               unless (is_template_exists = _brick_template_exists?(*args, **options))
                 # Need to return true if we can fill in the blanks for a missing one
                 # args will be something like:  ["index", ["categories"]]
-                model = args[1].map(&:camelize).join('::').singularize.constantize
+                args[1] = args[1].each_with_object([]) { |a, s| s.concat(a.split('/')) }
+                args[1][args[1].length - 1] = args[1].last.singularize # Make sure the last item, defining the class name, is singular
+                model = args[1].map(&:camelize).join('::').constantize
                 if is_template_exists = model && (
                      ['index', 'show'].include?(args.first) || # Everything has index and show
                      # Only CUD stuff has create / update / destroy
@@ -71,9 +73,10 @@ module Brick
               keys = if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
                        fk_name.zip(pk.map { |pk_part| "#{obj_name}.#{pk_part}" })
                      else
-                       [[fk_name, "#{obj_name}.#{pk}"]]
+                       pk = pk.each_with_object([]) { |pk_part, s| s << "#{obj_name}.#{pk_part}" }
+                       [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
                      end
-              keys << [hm_assoc.inverse_of.foreign_type, "#{hm_assoc.active_record.name}"] if hm_assoc.options.key?(:as)
+              keys << [hm_assoc.inverse_of.foreign_type, hm_assoc.active_record.name] if hm_assoc.options.key?(:as)
               keys.map { |x| "#{x.first}: #{x.last}"}.join(', ')
             end
 
@@ -82,9 +85,10 @@ module Brick
               return  _brick_find_template(*args, **options) unless @_brick_model
 
               model_name = @_brick_model.name
-              pk = @_brick_model.primary_key
-              obj_name = model_name.underscore
-              table_name = model_name.pluralize.underscore
+              pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
+              obj_name = model_name.split('::').last.underscore
+              path_obj_name = model_name.underscore.tr('/', '_')
+              table_name = obj_name.pluralize
               template_link = nil
               bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
               hms_columns = [] # Used for 'index'
@@ -107,21 +111,21 @@ module Brick
                                               "#{obj_name}.#{attrib_name} || 0"
                                             end
 "<%= ct = #{set_ct}
-     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
+     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
                                  else # has_one
 "<%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>\n"
                                  end
                 elsif args.first == 'show'
-                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
                 end
                 s << hm_stuff
               end
 
-              schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
+              schema_options = ::Brick.db_schemas.keys.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
               # %%% 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
-              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
-                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).sort
+                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>" }.html_safe
               css = +"<style>
 #dropper {
   background-color: #eee;
@@ -206,7 +210,13 @@ input[type=submit] {
   val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
 end
 def hide_bcrypt(val)
-  is_bcrypt?(val) ? '(hidden)' : val
+  if is_bcrypt?(val)
+    '(hidden)'
+  elsif val.is_a?(String) && val.encoding.name != 'UTF-8'
+    val[0..1000].force_encoding('UTF-8')
+  else
+    val
+  end
 end %>"
 
               if ['index', 'show', 'update'].include?(args.first)
@@ -254,7 +264,8 @@ if (schemaSelect) {
 
 var tblSelect = document.getElementById(\"tbl\");
 if (tblSelect) {
-  tblSelect.value = changeout(location.href);
+  tblSelect.value = changeout(location.href)[0];
+  if (tblSelect.selectedIndex < 0) tblSelect.value = changeout(location.href)[1];
   tblSelect.addEventListener(\"change\", function () {
     var lhr = changeout(location.href, null, this.value);
     if (brickSchema)
@@ -269,7 +280,8 @@ function changeout(href, param, value) {
     hrefParts = hrefParts[0].split(\"://\");
     var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
     if (value === undefined)
-      return pathParts[1];
+      // 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)];
     else
       return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
   }
@@ -283,7 +295,7 @@ function changeout(href, param, value) {
               inline = case args.first
                        when 'index'
                          obj_pk = if pk&.is_a?(Array) # Composite primary key?
-                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]"
+                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]" unless pk.empty?
                                   elsif pk
                                     "#{obj_name}.#{pk}"
                                   end
@@ -306,7 +318,7 @@ function changeout(href, param, value) {
       btnImport.style.display = droppedTSV.length > 0 ? \"block\" : \"none\";
     });
     btnImport.addEventListener(\"click\", function () {
-      fetch(changeout(<%= #{obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
+      fetch(changeout(<%= #{path_obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
         method: 'PATCH',
         headers: { 'Content-Type': 'text/tab-separated-values' },
         body: droppedTSV
@@ -377,17 +389,32 @@ function changeout(href, param, value) {
 <script async defer src=\"https://apis.google.com/js/api.js\" onload=\"gapiLoaded()\"></script>
 "
                          end
+# %%% Instead of our current "for Janet Leverling (Employee)" kind of link we previously had this code that did a "where x = 123" thing:
+#   (where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %>)
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
-<h1>#{model_name.pluralize}</h1>#{template_link}
-
-<% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
+<h1>#{model_plural = model_name.pluralize}</h1>#{template_link}
+
+<% if @_brick_params&.present? %>
+  <% if @_brick_params.length == 1 # %%% Does not yet work with composite keys
+       k, id = @_brick_params.first
+       id = id.first if id.is_a?(Array) && id.length == 1
+       origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
+      #  binding.pry
+       if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| puts fk.inspect; fk[:fk] == key_parts.last }) &&
+         (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
+         <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination.name.underscore.tr('/', '_')\}_path\".to_sym, id) %></h3><%
+       end
+     end %>
+  (<%= link_to 'See all #{model_plural.split('::').last}', #{path_obj_name.pluralize}_path %>)
+<% end %>
 <table id=\"#{table_name}\">
-  <thead><tr>#{'<th></th>' if pk}
+  <thead><tr>#{'<th></th>' if pk.present?}
   <% @#{table_name}.columns.map(&:name).each do |col| %>
-    <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) || poly_cols.include?(col) %>
+    <% next if (#{(pk || []).inspect}.include?(col) && #{model_name}.column_for_attribute(col).type == :integer && !bts.key?(col)) ||
+               ::Brick.config.metadata_columns.include?(col) || poly_cols.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
          BT <%
@@ -400,15 +427,16 @@ function changeout(href, param, value) {
     </th>
   <% end %>
   <%# Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name %>
-  #{hms_headers.map { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.pluralize}_path) %></th>\n" }.join}
+  #{hms_headers.map { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>\n" }.join}
   </tr></thead>
 
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
+    <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% #{obj_name}.attributes.each do |k, val| %>
-      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) || poly_cols.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && (k.length == 63 || k.end_with?('_ct'))) %>
+      <% next if (#{(obj_pk || []).inspect}.include?(k) && #{model_name}.column_for_attribute(k).type == :integer && !bts.key?(k)) ||
+                 ::Brick.config.metadata_columns.include?(k) || poly_cols.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && (k.length == 63 || k.end_with?('_ct'))) %>
       <td>
       <% if (bt = bts[k]) %>
         <%# binding.pry # Postgres column names are limited to 63 characters %>
@@ -423,7 +451,7 @@ function changeout(href, param, value) {
                #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |z| #{obj_name}.send(z.last[0..62]) }, (bt_id_col = descrips.last)
              )
              bt_id = #{obj_name}.send(*bt_id_col) if bt_id_col&.present? %>
-          <%= bt_id ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
+          <%= bt_id ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
           <%#= Previously was:  bt_obj = bt[1].first.first.find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt[1].first.first.name.underscore\}_path\".to_sym, bt_obj.send(bt[1].first.first.primary_key.to_sym))) if bt_obj %>
         <% end %>
       <% else %>
@@ -433,19 +461,19 @@ function changeout(href, param, value) {
     <% end %>
     #{hms_columns.each_with_object(+'') { |hm_col, s| s << "<td>#{hm_col}</td>" }}
   </tr>
-  </tbody>
   <% end %>
+  </tbody>
 </table>
 
-#{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
+#{"<hr><%= link_to \"New #{obj_name}\", new_#{path_obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
                        when 'show', 'update'
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
 <h1>#{model_name}: <%= (obj = @#{obj_name})&.brick_descrip || controller_name %></h1>
-<%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
+<%= link_to '(See all #{obj_name.pluralize})', #{path_obj_name.pluralize}_path %>
 <% if obj %>
   <%= # path_options = [obj.#{pk}]
     # path_options << { '_brick_schema':  } if
@@ -455,8 +483,8 @@ function changeout(href, param, value) {
   <% has_fields = false
     @#{obj_name}.attributes.each do |k, val| %>
     <tr>
-    <%# %%% Accommodate composite keys %>
-    <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+    <% next if (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
+               ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
     <% has_fields = true
       if (bt = bts[k])
@@ -464,26 +492,31 @@ function changeout(href, param, value) {
         bt_name = bt[1].map { |x| x.first.name }.join('/')
         # %%% Only do this if the user has permissions to edit this bt field
         if bt[2] # Polymorphic?
-          poly_class_name = @#{obj_name}.send(\"#\{bt.first\}_type\")
+          poly_class_name = orig_poly_name = @#{obj_name}.send(\"#\{bt.first\}_type\")
           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
             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:
+***   has_many :#{table_name}, as: :#\{bt.first\}
+*** Can probably auto-configure everything using these lines in an initialiser:
+***   Brick.sti_namespace_prefixes = { '::#\{orig_poly_name\}' => 'SomeParentModel' }
+***   Brick.polymorphics = { '#{table_name}.#\{bt.first\}' => ['SomeParentModel'] }\" if bt_pair.nil?
           # descrips = @_brick_bt_descrip[bt.first][bt_class]
           poly_id = @#{obj_name}.send(\"#\{bt.first\}_id\")
           # bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
         else # No polymorphism, so just get the first one
           bt_pair = bt[1].first
         end
-        bt_class = bt_pair.first
+        bt_class = bt_pair&.first
         if bt.length < 4
           bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
           # %%% Accommodate composite keys for obj.pk at the end here
-          bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
+          bt_class&.order(obj_pk = bt_class.primary_key)&.each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
         end %>
-        BT <%= bt_class.bt_link(bt.first) %>
+        BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
     <% else %>
       <%= k %>
     <% end %>
@@ -493,7 +526,7 @@ function changeout(href, param, value) {
       html_options = { prompt: \"Select #\{bt_name\}\" }
       html_options[:class] = 'dimmed' unless val %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
-      <%= bt_obj = bt_class.find_by(bt_pair[1] => val); link_to('⇛', send(\"#\{bt_class.base_class.name.underscore\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+      <%= 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' }) if bt_obj %>
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
@@ -535,7 +568,7 @@ function changeout(href, param, value) {
           <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}_path([#{obj_pk}])) %></td></tr>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore.tr('/', '_')}_path([#{obj_pk}])) %></td></tr>
           <% end %>
         <% end %>
       </table>"

data/lib/brick/join_array.rb

@@ -213,7 +213,7 @@ module Brick
           puts "X3"
           super(key, ::Brick::JoinArray.new.replace([current, value]))
         when ::Brick::JoinArray # Concatenate new stuff onto any existing JoinArray
-          current.set_matching(value, nil)
+          current.set_matching(value, nil) if value
         when ::Brick::JoinHash # Graduate an existing hash into being in an array if things are dissimilar
           super(key, ::Brick::JoinArray.new.replace([current, value]))
           value

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -90,10 +90,10 @@ module Brick
   end
 
   class << self
-    attr_accessor :db_schemas
+    attr_accessor :default_schema, :db_schemas
 
     def set_db_schema(params)
-      schema = params['_brick_schema'] || 'public'
+      schema = params['_brick_schema']
       ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema) if schema && ::Brick.db_schemas&.include?(schema)
     end
 
@@ -287,8 +287,16 @@ module Brick
     # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes
     # for polymorphics in which it wasn't originally specified.
     # @api public
-    def schema_to_analyse=(schema)
-      Brick.config.schema_to_analyse = schema
+    def schema_behavior=(behavior)
+      Brick.config.schema_behavior = (behavior.is_a?(Symbol) ? { behavior => nil } : behavior)
+    end
+    # For any Brits out there
+    def schema_behaviour=(behavior)
+      Brick.schema_behavior = behavior
+    end
+
+    def sti_type_column=(type_col)
+      Brick.config.sti_type_column = (type_col.is_a?(String) ? { type_col => nil } : type_col)
     end
 
     def default_route_fallback=(resource_name)
@@ -303,18 +311,23 @@ module Brick
 
       relations = ::Brick.relations
       if (ars = ::Brick.config.additional_references) || ::Brick.config.polymorphics
-        ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2], relations) } if ars
+        if ars
+          ars.each do |ar|
+            fk = ar.length < 5 ? [nil, +ar[0], ar[1], nil, +ar[2]] : [ar[0], +ar[1], ar[2], ar[3], +ar[4], ar[5]]
+            ::Brick._add_bt_and_hm(fk, relations)
+          end
+        end
         if (polys = ::Brick.config.polymorphics)
-          if (schema = ::Brick.config.schema_to_analyse) && ::Brick.db_schemas&.include?(schema)
+          if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
           end
           missing_stis = {}
           polys.each do |k, v|
             table_name, poly = k.split('.')
-            v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").map { |result| result['typ'] }
+            v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").each_with_object([]) { |result, s| s << result['typ'] if result['typ'] }
             v.each do |type|
               if relations.key?(primary_table = type.underscore.pluralize)
-                ::Brick._add_bt_and_hm([table_name, poly, primary_table, "(brick) #{table_name}_#{poly}"], relations, true)
+                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations, true)
               else
                 missing_stis[primary_table] = type unless ::Brick.existing_stis.key?(type)
               end
@@ -325,9 +338,9 @@ module Brick
 You might be missing an STI namespace prefix entry for these tables:  #{missing_stis.keys.join(', ')}.
 In config/initializers/brick.rb appropriate entries would look something like:
   Brick.sti_namespace_prefixes = {"
-            puts missing_stis.map { |_k, missing_sti| "\n    '::#{missing_sti}' => 'YourParentModel'" }.join(',')
+            puts missing_stis.map { |_k, missing_sti| "\n    '::#{missing_sti}' => 'SomeParentModel'" }.join(',')
             puts "  }
-(Just trade out YourParentModel with some more appropriate one.)"
+(Just trade out SomeParentModel with some more appropriate one.)"
           end
         end
         @_additional_references_loaded = true
@@ -390,11 +403,20 @@ In config/initializers/brick.rb appropriate entries would look something like:
         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 existing_controllers.key?(controller_name = k.underscore.pluralize)
+        ::Brick.relations.each do |rel_name, v|
+          rel_name = rel_name.split('.').map(&:underscore)
+          schema_names = rel_name[0..-2]
+          k = rel_name.last
+          unless existing_controllers.key?(controller_name = k.pluralize)
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
-            send(:resources, controller_name.to_sym, **options)
+            if schema_names.present? # && !Object.const_defined('Apartment')
+              send(:namespace, schema_names.first) do
+                send(:resources, controller_name.to_sym, **options)
+              end
+            else
+              send(:resources, controller_name.to_sym, **options)
+            end
           end
         end
       end
@@ -451,7 +473,7 @@ ActiveSupport.on_load(:active_record) do
             relation = clone # spawn
             relation.select_values = column_names
             result = if klass.connection.class.name.end_with?('::PostgreSQLAdapter')
-                       rslt = klass.connection.execute(relation.arel.to_sql)
+                       rslt = klass.execute_sql(relation.arel.to_sql)
                        rslt.type_map =
                          @type_map ||= proc do
                            # This aliasing avoids the warning:

data/lib/generators/brick/install_generator.rb

@@ -113,24 +113,24 @@ module Brick
 # #   #{resembles_fks.join(', ')}"
       end
 
-      poly = case (possible_polymorphics = possible_polymorphics.values.flatten).length
+      poly = case (possible_polymorphics = possible_polymorphics.values.flatten.map { |poss_poly| "#{poss_poly} => nil"}).length
       when 0
 " like this:
-# Brick.polymorphics = [
-#                        'comments.commentable',
-#                        'images.imageable'
-#                      ]"
+# Brick.polymorphics = {
+#                        'comments.commentable' => nil,
+#                        'images.imageable' => nil
+#                      }"
       when 1
 ".
 # # Here is a possible polymorphic association that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
-# Brick.polymorphics = [#{possible_additional_references.first}]"
+# Brick.polymorphics = { #{possible_additional_references.first} }"
 
       else
 ".
 # # Here are possible polymorphic associations that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
-# Brick.polymorphics = [
+# Brick.polymorphics = {
 #   #{possible_polymorphics.join(",\n#   ")}
-# ]"
+# }"
       end
 
       create_file(filename, "# frozen_string_literal: true
@@ -215,9 +215,15 @@ module Brick
 # Brick.sti_namespace_prefixes = { '::Animals::' => 'Animal',
 #                                  '::Snake' => 'Reptile' }
 
+# # Custom inheritance_column to be used for STI.  This is by default \"type\", and applies to all models.  With this
+# # option you can change this either for specific models, or apply a new overall name generally:
+# Brick.sti_type_column = 'sti_type'
+# Brick.sti_type_column = { 'rails_type' => ['sales.specialoffer'] }
+
 # # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes in the case that
 # # it wasn't originally specified.
-# Brick.schema_to_analyse = 'engineering'
+# Brick.schema_behavior = :namespaced
+# Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering' } }
 
 # # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 

metadata

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