brick 1.0.79 → 1.0.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eedc546e7e9693459cf228ee376650cdf53c0325e55d50ef24bbf46d421f8738
-  data.tar.gz: c4feda4b5db8334363d05f3418dc172f0dbf408c21192222008a5b9a174ae448
+  metadata.gz: 2627490165a63200a49afb7707882489986217bc170491e88f64eb9faf880b6b
+  data.tar.gz: f12adff07785ffd5c4a877f555cd7899de859f99ae9b18b84eda6f3d20ac5c15
 SHA512:
-  metadata.gz: 0c9713099c057b9c9041121576a4f38d5949213926a47d597f88f4a9021ce14cd3df2a30c14b8b929b92ba4549ec4492bdfd8de13cb0a4f710e911c00eab67b6
-  data.tar.gz: 27ca4aa6d40e165aaca5b09cf5b2ce97737b26adc8424b1d25d81b9813100679e9e06a61279c4fd8b96d750a89a4c4cb8eafbfe2d425a4d4c6868644820f297d
+  metadata.gz: f112e1bf44fc39e80bced64a2d9fb4dd16297e2c549f66d0842fb65d7f3644170fa18c3c784c59c5a93db57233a77bfa5f288dca89be1b3dec6172bb670f147b
+  data.tar.gz: 0c2061b9b662c00aeb85a76db20fb59962302dd8b6ab17225ded332eadf4485392e3f5e44538b8f99d525666b8a036bb2fbd53a2604bbf7f69aca3ad8400fa4d

data/lib/brick/extensions.rb

@@ -909,7 +909,7 @@ Module.class_exec do
                # Vabc instead of VABC)
                singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
                full_class_name << "::#{singular_class_name}"
-               if plural_class_name == 'BrickSwagger' ||
+               if plural_class_name == 'BrickOpenapi' ||
                   (
                     (::Brick.config.add_status || ::Brick.config.add_orphans) &&
                     plural_class_name == 'BrickGem'
@@ -1035,7 +1035,7 @@ class Object
         #   puts "Warning: Class name for a model that references table \"#{matching
         #        }\" should be \"#{ActiveSupport::Inflector.singularize(inheritable_name || model_name)}\"."
         # end
-        return
+        return unless singular_table_name.singularize.blank?
       end
 
       full_model_name = full_name.split('::').tap { |fn| fn[-1] = model_name }.join('::')
@@ -1070,31 +1070,40 @@ class Object
             true
           end
           code << "  def self.is_view?; true; end\n"
-        end
 
-        db_pks = relation[:cols]&.map(&:first)
-        has_pk = _brick_primary_key(relation).length.positive? && (db_pks & _brick_primary_key).sort == _brick_primary_key.sort
-        our_pks = relation[:pkey].values.first
-        # No primary key, but is there anything UNIQUE?
-        # (Sort so that if there are multiple UNIQUE constraints we'll pick one that uses the least number of columns.)
-        our_pks = relation[:ukeys].values.sort { |a, b| a.length <=> b.length }.first unless our_pks&.present?
-        if has_pk
-          code << "  # Primary key: #{_brick_primary_key.join(', ')}\n" unless _brick_primary_key == ['id']
-        elsif our_pks&.present?
-          if our_pks.length > 1 && respond_to?(:'primary_keys=') # Using the composite_primary_keys gem?
-            new_model_class.primary_keys = our_pks
-            code << "  self.primary_keys = #{our_pks.map(&:to_sym).inspect}\n"
-          else
-            new_model_class.primary_key = (pk_sym = our_pks.first.to_sym)
-            code << "  self.primary_key = #{pk_sym.inspect}\n"
+          new_model_class.primary_key = nil
+          code << "  self.primary_key = nil\n"
+
+          new_model_class.define_method :'readonly?' do
+            true
           end
-          _brick_primary_key(relation) # Set the newly-found PK in the instance variable
-        elsif (possible_pk = ActiveRecord::Base.get_primary_key(base_class.name)) && relation[:cols][possible_pk]
-          new_model_class.primary_key = (possible_pk = possible_pk.to_sym)
-          code << "  self.primary_key = #{possible_pk.inspect}\n"
+          code << "  def readonly?; true; end\n"
         else
-          code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
+          db_pks = relation[:cols]&.map(&:first)
+          has_pk = (bpk = _brick_primary_key(relation)).present? && (db_pks & bpk).sort == bpk.sort
+          our_pks = relation[:pkey].values.first
+          # No primary key, but is there anything UNIQUE?
+          # (Sort so that if there are multiple UNIQUE constraints we'll pick one that uses the least number of columns.)
+          our_pks = relation[:ukeys].values.sort { |a, b| a.length <=> b.length }.first unless our_pks&.present?
+          if has_pk
+            code << "  # Primary key: #{_brick_primary_key.join(', ')}\n" unless _brick_primary_key == ['id']
+          elsif our_pks&.present?
+            if our_pks.length > 1 && respond_to?(:'primary_keys=') # Using the composite_primary_keys gem?
+              new_model_class.primary_keys = our_pks
+              code << "  self.primary_keys = #{our_pks.map(&:to_sym).inspect}\n"
+            else
+              new_model_class.primary_key = (pk_sym = our_pks.first.to_sym)
+              code << "  self.primary_key = #{pk_sym.inspect}\n"
+            end
+            _brick_primary_key(relation) # Set the newly-found PK in the instance variable
+          elsif (possible_pk = ActiveRecord::Base.get_primary_key(base_class.name)) && relation[:cols][possible_pk]
+            new_model_class.primary_key = (possible_pk = possible_pk.to_sym)
+            code << "  self.primary_key = #{possible_pk.inspect}\n"
+          else
+            code << "  # Could not identify any column(s) to use as a primary key\n"
+          end
         end
+
         if (sti_col = relation.fetch(:sti_col, nil))
           new_model_class.send(:'inheritance_column=', sti_col)
           code << "  self.inheritance_column = #{sti_col.inspect}\n"
@@ -1303,13 +1312,13 @@ class Object
             instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params)))
           end
           return [new_controller_class, code + "end # BrickGem controller\n"]
-        when 'BrickSwagger'
-          is_swagger = true
+        when 'BrickOpenapi'
+          is_openapi = true
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
-          if (is_swagger || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
+          if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
              !params&.key?('_brick_schema') &&
              (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
             if params
@@ -1320,7 +1329,7 @@ class Object
           end
           ::Brick.set_db_schema(params || api_params)
 
-          if is_swagger
+          if is_openapi
             json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
                      'servers': [
                        { 'url': '{scheme}://{defaultHost}', 'variables': {
@@ -1417,7 +1426,7 @@ class Object
           @_brick_erd = params['_brick_erd']&.to_i
         end
 
-        unless is_swagger
+        unless is_openapi
           ::Brick.set_db_schema
           _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk)) if pk
           code << "  def index\n"
@@ -1555,7 +1564,7 @@ class Object
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
           end
-        end # unless is_swagger
+        end # unless is_openapi
         code << "end # #{class_name}\n"
       end # class definition
       [built_controller, code]
@@ -1745,7 +1754,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', 'SQLServer' # These bring back a hash for each row because the query uses column aliases
+      when 'PostgreSQL', 'SQLite' # 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
@@ -1776,7 +1785,7 @@ module ActiveRecord::ConnectionHandling
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
           relation[:col_descrips][col_name] = r['column_description'] if r['column_description']
         end
-      else # MySQL2 and OracleEnhanced act a little differently, bringing back an array for each row
+      else # MySQL2, OracleEnhanced, and MSSQL act a little differently, bringing back an array for each row
         schema_and_tables = case ActiveRecord::Base.connection.adapter_name
                             when 'OracleEnhanced'
                               sql =
@@ -1932,7 +1941,10 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       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
-      v[:class_name] = (schema_names + [rel_name.last.singularize]).map(&:camelize).join('::')
+      if (singular = rel_name.last.singularize).blank?
+        singular = rel_name.last
+      end
+      v[:class_name] = (schema_names + [singular]).map(&:camelize).join('::')
     end
     ::Brick.load_additional_references if initializer_loaded
 
@@ -2156,11 +2168,6 @@ module Brick
 
       return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[1] == exclusion[0] && fk[2] == exclusion[1] && primary_table == exclusion[2] } || hms.nil?
 
-      # if fk[1].end_with?('Suppliers') && fk[4] == 'People'
-      #   puts fk.inspect
-      #   binding.pry
-      # end
-
       if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
         if assoc_hm[:fk].is_a?(String)
           assoc_hm[:fk] = [assoc_hm[:fk], fk[2]] unless fk[2] == assoc_hm[:fk]

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

@@ -189,8 +189,8 @@ module Brick
                               end.keys.sort.each_with_object(+'') do |v, s|
                                 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
+              table_options << "<option value=\"#{prefix}brick_status\">(Status)</option>".html_safe if ::Brick.config.add_status
+              table_options << "<option value=\"#{prefix}brick_orphans\">(Orphans)</option>".html_safe if is_orphans
               css = +"<style>
 h1, h3 {
   margin-bottom: 0;
@@ -603,7 +603,21 @@ if (headerTop) {
               erd_markup = if @_brick_model
                              "<div id=\"mermaidErd\" class=\"mermaid\">
 erDiagram
-<% model_short_name = #{@_brick_model.name.split('::').last.inspect}
+<% def sidelinks(shown_classes, klass)
+     links = []
+     # %%% Not yet showing these as they can get just a bit intense!
+     # klass.reflect_on_all_associations.select { |a| shown_classes.key?(a.klass) }.each do |assoc|
+     #   unless shown_classes[assoc.klass].key?(klass.name)
+     #     links << \"    #\{klass.name.split('::').last} #\{assoc.macro == :belongs_to ? '}o--||' : '||--o{'} #\{assoc.klass.name.split('::').last} : \\\"\\\"\"n\"
+     #     shown_classes[assoc.klass][klass.name] = nil
+     #   end
+     # end
+     # shown_classes[klass] ||= {}
+     links.join
+   end
+
+   model_short_name = #{@_brick_model.name.split('::').last.inspect}
+   shown_classes = {}
    @_brick_bt_descrip&.each do |bt|
      bt_class = bt[1].first.first
      callbacks[bt_name = bt_class.name.split('::').last] = bt_class
@@ -613,6 +627,7 @@ erDiagram
         bt_underscored = bt[1].first.first.name.underscore.singularize
         bt.first unless bt.first.to_s == bt_underscored.split('/').last # Was:  bt_underscored.tr('/', '_')
         }\\\"\".html_safe %>
+<%=  sidelinks(shown_classes, bt_class).html_safe %>
 <% end
    last_through = nil
    @_brick_hm_counts&.each do |hm|
@@ -627,6 +642,7 @@ erDiagram
 %><%=    \"\n\"
 %><%   else
 %>  <%= \"#\{model_short_name} ||--o{ #\{through_name}\".html_safe %> : \"\"
+<%=      sidelinks(shown_classes, through_assoc.active_record).html_safe %>
 <%       last_through = through
        end
 %>    <%= \"#\{through_name} }o--|| #\{hm_name}\".html_safe %> : \"\"
@@ -636,6 +652,7 @@ erDiagram
             hm.first.to_s unless hm.first.to_s.downcase == hm_class.name.underscore.pluralize.tr('/', '_')
           }\\\"\".html_safe %><%
      end %>
+<%=  sidelinks(shown_classes, hm_class).html_safe %>
 <% end
    def dt_lookup(dt)
      { 'integer' => 'int', }[dt] || dt&.tr(' ', '_') || 'int'
@@ -989,11 +1006,13 @@ erDiagram
 <select id=\"tbl\">#{table_options}</select>
 <h1>Orphans<%= \" for #\{}\" if false %></h1>
 <% @orphans.each do |o|
-  via = \" (via #\{o[4]})\" unless \"#\{o[2].split('.').last.underscore.singularize}_id\" == o[4] %>
-  <a href=\"/<%= o[0].split('.').last %>/<%= o[1] %>\">
-    <%= \"#\{o[0]} #\{o[1]} refers#\{via} to non-existent #\{o[2]} #\{o[3]}#\{\" (in table \\\"#\{o[5]}\\\")\" if o[5]}\" %>
-  </a><br>
-<% end %>
+     if (klass = ::Brick.relations[o[0]]&.fetch(:class_name, nil)&.constantize) %>
+<%=    via = \" (via #\{o[4]})\" unless \"#\{o[2].split('.').last.underscore.singularize}_id\" == o[4]
+       link_to(\"#\{o[0]} #\{o[1]} refers#\{via} to non-existent #\{o[2]} #\{o[3]}#\{\" (in table \\\"#\{o[5]}\\\")\" if o[5]}\",
+               send(\"#\{klass._brick_index(:singular)\}_path\".to_sym, o[1])) %>
+  <br>
+<%   end
+   end %>
 #{script}"
                          end
 
@@ -1324,6 +1343,45 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
         # go make sure we've loaded additional references (virtual foreign keys and polymorphic associations).
         # (This should only happen if for whatever reason the initializer file was not exactly config/initializers/brick.rb.)
         ::Brick.load_additional_references
+
+        # If the RailsAdmin gem is present, add our auto-creatable model names into its list of viable models.
+        if Object.const_defined?('RailsAdmin')
+          RailsAdmin::Config.class_exec do
+            class << self
+
+            private
+
+              alias _brick_viable_models viable_models
+              def viable_models
+                return _brick_viable_models if class_variables.include?(:@@system_models)
+
+                @@system_models = (vm = _brick_viable_models) + (::Brick.auto_models - vm)
+              end
+            end
+          end
+
+          RailsAdmin::Config::Actions::Show.class_exec do
+            register_instance_option :enabled? do
+              !(bindings[:object] && bindings[:object].class.is_view?)
+            end
+          end
+
+          RailsAdmin::Config::Actions::HistoryShow.class_exec do
+            register_instance_option :enabled? do
+              !(bindings[:object] && bindings[:object].class.is_view?)
+            end
+          end
+
+          RailsAdmin.config do |config|
+            ::Brick.relations.select { |_k, v| v.key?(:isView) }.each do |_k, relation|
+              config.model(relation[:class_name]) do # new_model_class
+                list do
+                  sort_by (sort_col = relation[:cols].first.first)
+                end
+              end
+            end
+          end
+        end
       end
     end
   end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -96,7 +96,6 @@ if ActiveRecord.version < ::Gem::Version.new('5')
   )
 end
 
-
 # puts ::Brick::Util._patch_require(
 #     'cucumber/cli/options.rb', '/cucumber/cli/options', # /cli/options
 #     ['  def extract_environment_variables',
@@ -123,7 +122,7 @@ module Brick
   end
 
   class << self
-    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading
+    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models
 
     def set_db_schema(params = nil)
       schema = (params ? params['_brick_schema'] : ::Brick.default_schema)
@@ -540,6 +539,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}"
       end
       puts "\n"
@@ -548,84 +548,112 @@ In config/initializers/brick.rb appropriate entries would look something like:
 
   module RouteSet
     def finalize!
-      return super if ::Brick.routes_done
-
-      ::Brick.routes_done = true
-      tables = []
-      views = []
-      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:"
-      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
+      unless ::Rails.application.routes.named_routes.route_defined?(:brick_status_path)
+        existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
+        ::Rails.application.routes.append do
+          tables = []
+          views = []
+          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, 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
-          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:
-        controller_prefix = (::Brick.config.path_prefix ? "#{::Brick.config.path_prefix}/" : '')
-        ::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))
-              full_resource = "#{schema_name}/#{v[:resource]}"
-              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
-            else
-              # Normally goes to something like:  /api/v1/employees
-              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
+          # %%% 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:
+          controller_prefix = (::Brick.config.path_prefix ? "#{::Brick.config.path_prefix}/" : '')
+          ::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))
+                full_resource = "#{schema_name}/#{v[:resource]}"
+                send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              else
+                # Normally goes to something like:  /api/v1/employees
+                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
-            else
-              brick_routes_create.call(schema_name, controller_name, v, options)
+
+              if (class_name = v.fetch(:class_name, nil))
+                if v.key?(:isView)
+                  view_class_length = class_name.length if class_name.length > view_class_length
+                  views
+                else
+                  table_class_length = class_name.length if class_name.length > table_class_length
+                  tables
+                end << [class_name, full_resource || v[:resource]]
+              end
             end
+          end
 
-            if (class_name = v.fetch(:class_name, nil))
-              if v.key?(:isView)
-                view_class_length = class_name.length if class_name.length > view_class_length
-                views
+          if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
+            get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: 'brick_status')
+          end
+
+          if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
+            get("/#{controller_prefix}brick_orphans", to: 'brick_gem#orphans', as: 'brick_orphans')
+          end
+
+          unless ::Brick.routes_done
+            if Object.const_defined?('Rswag::Ui')
+              rswag_path = ::Rails.application.routes.routes.find { |r| r.app.app == Rswag::Ui::Engine }&.instance_variable_get(:@path_formatter)&.instance_variable_get(:@parts)&.join
+              if (doc_endpoint = Rswag::Ui.config.config_object[:urls]&.last)
+                puts "Mounting OpenApi 3.0 documentation endpoint for \"#{doc_endpoint[:name]}\" on #{doc_endpoint[:url]}"
+                send(:get, doc_endpoint[:url], { to: 'brick_openapi#index' })
+                endpoint_parts = doc_endpoint[:url]&.split('/')
+                if rswag_path && endpoint_parts
+                  puts "API documentation now available when navigating to:  /#{endpoint_parts&.find(&:present?)}/index.html"
+                else
+                  puts "In order to make documentation available you can put this into your routes.rb:"
+                  puts "  mount Rswag::Ui::Engine => '/#{endpoint_parts&.find(&:present?) || 'api-docs'}'"
+                end
               else
-                table_class_length = class_name.length if class_name.length > table_class_length
-                tables
-              end << [class_name, full_resource || v[:resource]]
+                sample_path = rswag_path || '/api-docs'
+                puts
+                puts "Brick:  rswag-ui gem detected -- to make OpenAPI 3.0 documentation available from a path such as  '#{sample_path}/v1/swagger.json',"
+                puts '        put code such as this in an initializer:'
+                puts '  Rswag::Ui.configure do |config|'
+                puts "    config.swagger_endpoint '#{sample_path}/v1/swagger.json', 'API V1 Docs'"
+                puts '  end'
+                unless rswag_path
+                  puts
+                  puts '        and put this into your routes.rb:'
+                  puts "  mount Rswag::Ui::Engine => '/api-docs'"
+                end
+              end
             end
-          end
-        end
-        puts "\n" if tables.present? || views.present?
-        if tables.present?
-          puts "Classes that can be built from tables:#{' ' * (table_class_length - 38)}  Path:"
-          puts "======================================#{' ' * (table_class_length - 38)}  ====="
-          ::Brick.display_classes(controller_prefix, tables, table_class_length)
-        end
-        if views.present?
-          puts "Classes that can be built from views:#{' ' * (view_class_length - 37)}  Path:"
-          puts "=====================================#{' ' * (view_class_length - 37)}  ====="
-          ::Brick.display_classes(controller_prefix, views, view_class_length)
-        end
 
-        if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
-          get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: 'brick_status')
-        end
-        if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
-          get("/#{controller_prefix}brick_orphans", to: 'brick_gem#orphans', as: 'brick_orphans')
-        end
-        if Object.const_defined?('Rswag::Ui') && doc_endpoint = Rswag::Ui.config.config_object[:urls].last
-          # Serves JSON swagger info from a path such as  '/api-docs/v1/swagger.json'
-          puts "Mounting swagger info endpoint for \"#{doc_endpoint[:name]}\" on #{doc_endpoint[:url]}"
-          send(:get, doc_endpoint[:url], { to: 'brick_swagger#index' })
+            ::Brick.routes_done = true
+            puts "\n" if tables.present? || views.present?
+            if tables.present?
+              puts "Classes that can be built from tables:#{' ' * (table_class_length - 38)}  Path:"
+              puts "======================================#{' ' * (table_class_length - 38)}  ====="
+              ::Brick.display_classes(controller_prefix, tables, table_class_length)
+            end
+            if views.present?
+              puts "Classes that can be built from views:#{' ' * (view_class_length - 37)}  Path:"
+              puts "=====================================#{' ' * (view_class_length - 37)}  ====="
+              ::Brick.display_classes(controller_prefix, views, view_class_length)
+            end
+          end
         end
       end
       super

data/lib/generators/brick/install_generator.rb

@@ -98,40 +98,40 @@ module Brick
 
         bar = case (possible_additional_references = possible_additional_references.values.flatten).length
               when 0
-+"# Brick.additional_references = [['orders', 'customer_id', 'customer'],
-#                                ['customer', 'region_id', 'regions']]"
++"  # Brick.additional_references = [['orders', 'customer_id', 'customer'],
+  #                                ['customer', 'region_id', 'regions']]"
               when 1
-+"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
-# Brick.additional_references = [#{possible_additional_references.first}]"
++"  # # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+  # Brick.additional_references = [#{possible_additional_references.first}]"
               else
-+"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
-# Brick.additional_references = [
-#   #{possible_additional_references.join(",\n#   ")}
-# ]"
++"  # # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+  # Brick.additional_references = [
+  #   #{possible_additional_references.join(",\n  #   ")}
+  # ]"
               end
       if resembles_fks.length > 0
-        bar << "\n# # Columns named somewhat like a foreign key which you may want to consider:
-# #   #{resembles_fks.join(', ')}"
+        bar << "\n  # # Columns named somewhat like a foreign key which you may want to consider:
+  # #   #{resembles_fks.join(', ')}"
       end
 
       poly = case (possible_polymorphics = possible_polymorphics.values.flatten.map { |poss_poly| "#{poss_poly} => nil"}).length
       when 0
 " like this:
-# Brick.polymorphics = {
-#                        'comments.commentable' => nil,
-#                        'images.imageable' => nil
-#                      }"
+  # 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} }"
+  # # 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} }"
 
       else
 ".
-# # Here are possible polymorphic associations that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
-# Brick.polymorphics = {
-#   #{possible_polymorphics.join(",\n#   ")}
-# }"
+  # # Here are possible polymorphic associations that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+  # Brick.polymorphics = {
+  #   #{possible_polymorphics.join(",\n  #   ")}
+  # }"
       end
 
       create_file(filename, "# frozen_string_literal: true
@@ -139,161 +139,169 @@ 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.
-# Brick.enable_routes = true # Setting this to \"false\" will disable routes in development
-# Brick.enable_models = false
-# Brick.enable_controllers = true # Setting this to \"false\" will disable controllers in development
-# Brick.enable_views = true # Setting this to \"false\" will disable views in development
-
-# ::Brick.api_root = '/api/v1/' # Path from which to serve out API resources when the RSwag gem is present
-
-# # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
-# Brick.skip_database_views = true
-
-# # Any tables or views you'd like to skip when auto-creating models
-# Brick.exclude_tables = ['custom_metadata', 'version_info']
-
-# # Class that auto-generated models should inherit from
-# Brick.models_inherit_from = ApplicationRecord
-
-# # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
-# Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
-
-# # COLUMN SEQUENCING AND INCLUSION / EXCLUSION
-
-# # By default if there is a primary key present then rows in an index view are ordered by this primary key.  To
-# # use a different rule for doing ORDER BY, you can override this default ordering done by The Brick, for instance
-# # to have the rows in a contact list sorted by email:
-# Brick.order = { 'contacts' => { _brick_default: :email } }
-# # or by last name then first name:
-# Brick.order = { 'contacts' => { _brick_default: [:lastname, :firstname] } }
-# # Totally legitimate to have the default order be the name of a belongs_to or has_many association instead of an
-# # actual column name, in which case for has_many it just orders by the count of how many records are associated,
-# # and for belongs_to it's based on the primary table's DSL if any is defined (since that is what is used to
-# # calculate what is shown when a foreign table lists out related records).  If contacts relates to addresses,
-# # then this is perfectly fine:
-# Brick.order = { 'contacts' => { _brick_default: :address } }
-# # You can even have a specific custom clause used in the ORDER BY.  In this case it is recommended to include a
-# # special placeholder for the table name with the sequence \"^^^\".  Here is an example of having the default
-# # ordering happening on the \"code\" column, and also defining custom sorting to be done, in this case proper
-# # ordering if that code is stored as a dotted numeric value:
-# Brick.order = { 'document_trees' => { _brick_default: :code,
-#                                       code: \"ORDER BY STRING_TO_ARRAY(^^^.code, '.')::int[]\" } }
-
-# # Sequence of columns for each model.  This also allows you to add read-only calculated columns in the same
-# # kind of way that they can be added in the include: portion of include/exclude columns, below.
-# # Designated by { <table name> => [<column name>, <column name>] }
-# Brick.column_sequence = { 'users' => ['email', 'profile.firstname', 'profile.lastname'] }
-
-# # Specific columns to include or exclude for each model.  If there are only inclusions then only those
-# # columns show.  If there are any exclusions then all non-excluded columns are attempted to be shown,
-# # which negates the usefulness of inclusions except to add calculated column detail built from DSL.
-# # Designated by <table name>.<column name>
-# Brick.column_sequence = { 'users' =>   { include: ['email', 'profile.firstname', 'profile.lastname'] },
-#                           'profile' => { exclude: ['birthdate'] } }
-
-# # EXTRA FOREIGN KEYS AND OTHER HAS_MANY SETTINGS
-
-# # Additional table references which are used to create has_many / belongs_to associations inside auto-created
-# # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
-# # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
-# # performance reasons or just out of sheer laziness these might be missing.
-# # Each of these virtual foreign keys is defined as an array having three values:
-# #   foreign table name / foreign key column / primary table name.
-# # (We boldly expect that the primary key identified by ActiveRecord on the primary table will be accurate,
-# # usually this is \"id\" but there are some good smarts that are used in case some other column has been set
-# # to be the primary key.)
+if Object.const_defined?('Brick')
+  # # 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.
+  # Brick.enable_routes = true # Setting this to \"false\" will disable routes in development
+  # Brick.enable_models = false
+  # Brick.enable_controllers = true # Setting this to \"false\" will disable controllers in development
+  # Brick.enable_views = true # Setting this to \"false\" will disable views in development
+
+  # # If The Brick sees that RSwag gem is present, it allows for API resources to be automatically served out.
+  # # You can configure the root path for these resources:
+  # ::Brick.api_root = '/api/v1/'
+  # # You may also want to add an OpenAPI 3.0 documentation endpoint using Rswag::Ui:
+  # Rswag::Ui.configure do |config|
+  #   config.swagger_endpoint '/api-docs/v1/swagger.json', 'API V1 Docs'
+  # end
+
+  # # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
+  # Brick.skip_database_views = true
+
+  # # Any tables or views you'd like to skip when auto-creating models
+  # Brick.exclude_tables = ['custom_metadata', 'version_info']
+
+  # # Class that auto-generated models should inherit from
+  # Brick.models_inherit_from = ApplicationRecord
+
+  # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
+  # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
+
+  # # COLUMN SEQUENCING AND INCLUSION / EXCLUSION
+
+  # # By default if there is a primary key present then rows in an index view are ordered by this primary key.  To
+  # # use a different rule for doing ORDER BY, you can override this default ordering done by The Brick, for instance
+  # # to have the rows in a contact list sorted by email:
+  # Brick.order = { 'contacts' => { _brick_default: :email } }
+  # # or by last name then first name:
+  # Brick.order = { 'contacts' => { _brick_default: [:lastname, :firstname] } }
+  # # Totally legitimate to have the default order be the name of a belongs_to or has_many association instead of an
+  # # actual column name, in which case for has_many it just orders by the count of how many records are associated,
+  # # and for belongs_to it's based on the primary table's DSL if any is defined (since that is what is used to
+  # # calculate what is shown when a foreign table lists out related records).  If contacts relates to addresses,
+  # # then this is perfectly fine:
+  # Brick.order = { 'contacts' => { _brick_default: :address } }
+  # # You can even have a specific custom clause used in the ORDER BY.  In this case it is recommended to include a
+  # # special placeholder for the table name with the sequence \"^^^\".  Here is an example of having the default
+  # # ordering happening on the \"code\" column, and also defining custom sorting to be done, in this case proper
+  # # ordering if that code is stored as a dotted numeric value:
+  # Brick.order = { 'document_trees' => { _brick_default: :code,
+  #                                       code: \"ORDER BY STRING_TO_ARRAY(^^^.code, '.')::int[]\" } }
+
+  # # Sequence of columns for each model.  This also allows you to add read-only calculated columns in the same
+  # # kind of way that they can be added in the include: portion of include/exclude columns, below.
+  # # Designated by { <table name> => [<column name>, <column name>] }
+  # Brick.column_sequence = { 'users' => ['email', 'profile.firstname', 'profile.lastname'] }
+
+  # # Specific columns to include or exclude for each model.  If there are only inclusions then only those
+  # # columns show.  If there are any exclusions then all non-excluded columns are attempted to be shown,
+  # # which negates the usefulness of inclusions except to add calculated column detail built from DSL.
+  # # Designated by <table name>.<column name>
+  # Brick.column_sequence = { 'users' =>   { include: ['email', 'profile.firstname', 'profile.lastname'] },
+  #                           'profile' => { exclude: ['birthdate'] } }
+
+  # # EXTRA FOREIGN KEYS AND OTHER HAS_MANY SETTINGS
+
+  # # Additional table references which are used to create has_many / belongs_to associations inside auto-created
+  # # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
+  # # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
+  # # performance reasons or just out of sheer laziness these might be missing.
+  # # Each of these virtual foreign keys is defined as an array having three values:
+  # #   foreign table name / foreign key column / primary table name.
+  # # (We boldly expect that the primary key identified by ActiveRecord on the primary table will be accurate,
+  # # usually this is \"id\" but there are some good smarts that are used in case some other column has been set
+  # # to be the primary key.)
 #{bar}
 
-# # Custom columns to add to a table, minimally defined with a name and DSL string.
-# Brick.custom_columns = { 'users' =>  { messages:    ['[COUNT(messages)] messages', 'messages'] },
-#                          'orders' => { salesperson:  '[salesperson.first] [salesperson.last]',
-#                                        products:    ['[COUNT(order_items.product)] products', 'order_items.product' ] }
-#                        }
-
-# # Skip creating a has_many association for these (only retain the belongs_to built from this additional_reference).
-# # (Uses the same exact three-part format as would define an additional_reference)
-# # Say for instance that we didn't care to display the favourite colours that users have:
-# Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
-
-# # Skip showing counts for these specific has_many associations when building auto-generated #index views.
-# # When there are related tables with a significant number of records (generally 100,000 or more), this can lessen
-# # the load on the database considerably, sometimes fixing what might appear to be an index page that just \"hangs\"
-# # for no apparent reason.
-# Brick.skip_index_hms = ['User.litany_of_woes']
-
-# # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
-# # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
-# # using the primary model name and the association name which you instead want to have treated as a \"has_one\":
-# Brick.has_ones = [['User', 'user_profile']]
-# # If you want to use an alternate name for the \"has_one\", such as in the case above calling the association \"profile\"
-# # instead of \"user_profile\", then apply that as a third parameter like this:
-# Brick.has_ones = [['User', 'user_profile', 'profile']]
-
-# # We normally don't show the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\", and also do
-# # not consider them when finding associative tables to support an N:M association.  (That is, ones that can be a
-# # part of a has_many :through association.)  If you want to use different exclusion columns than our defaults
-# # then this setting resets that list.  For instance, here is an override that is useful in the Sakila sample
-# # database:
-# Brick.metadata_columns = ['last_update']
-
-# # Columns for which to add a validate presence: true even though the database doesn't have them marked as NOT NULL.
-# # Designated by <table name>.<column name>
-# Brick.not_nullables = ['users.name']
-
-# # FRIENDLY DSL
-
-# # A simple DSL is available to allow more user-friendly display of objects.  Normally a user object might be shown
-# # as its first non-metadata column, or if that is not available then something like \"User #45\" where 45 is that
-# # object's ID.  If there is no primary key then even that is not possible, so the object's .to_s method is called.
-# # To override these defaults and specify exactly what you want shown, such as first names and last names for a
-# # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
-# Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
-
-# # SINGLE TABLE INHERITANCE
-
-# # Specify STI subclasses either directly by name or as a general module prefix that should always relate to a specific
-# # parent STI class.  The prefixed :: here for these examples is mandatory.  Also having a suffixed :: means instead of
-# # a class reference, this is for a general namespace reference.  So in this case requests for, say, either of the
-# # non-existent classes Animals::Cat or Animals::Goat (or anything else with the module prefix of \"Animals::\" would
-# # build a model that inherits from Animal.  And a request specifically for the class Snake would build a new model
-# # that inherits from Reptile, and no other request would do this -- only specifically for Snake.  The ending ::
-# # indicates that it's a module prefix instead of a specific class name.
-# 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'] }
-
-# # POLYMORPHIC ASSOCIATIONS
-
-# # 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_behavior = :namespaced
-#{Brick.config.schema_behavior.present? ? "Brick.schema_behavior = { multitenant: { schema_to_analyse: #{
+  # # Custom columns to add to a table, minimally defined with a name and DSL string.
+  # Brick.custom_columns = { 'users' =>  { messages:    ['[COUNT(messages)] messages', 'messages'] },
+  #                          'orders' => { salesperson:  '[salesperson.first] [salesperson.last]',
+  #                                        products:    ['[COUNT(order_items.product)] products', 'order_items.product' ] }
+  #                        }
+
+  # # Skip creating a has_many association for these (only retain the belongs_to built from this additional_reference).
+  # # (Uses the same exact three-part format as would define an additional_reference)
+  # # Say for instance that we didn't care to display the favourite colours that users have:
+  # Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
+
+  # # Skip showing counts for these specific has_many associations when building auto-generated #index views.
+  # # When there are related tables with a significant number of records (generally 100,000 or more), this can lessen
+  # # the load on the database considerably, sometimes fixing what might appear to be an index page that just \"hangs\"
+  # # for no apparent reason.
+  # Brick.skip_index_hms = ['User.litany_of_woes']
+
+  # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
+  # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
+  # # using the primary model name and the association name which you instead want to have treated as a \"has_one\":
+  # Brick.has_ones = [['User', 'user_profile']]
+  # # If you want to use an alternate name for the \"has_one\", such as in the case above calling the association \"profile\"
+  # # instead of \"user_profile\", then apply that as a third parameter like this:
+  # Brick.has_ones = [['User', 'user_profile', 'profile']]
+
+  # # We normally don't show the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\", and also do
+  # # not consider them when finding associative tables to support an N:M association.  (That is, ones that can be a
+  # # part of a has_many :through association.)  If you want to use different exclusion columns than our defaults
+  # # then this setting resets that list.  For instance, here is an override that is useful in the Sakila sample
+  # # database:
+  # Brick.metadata_columns = ['last_update']
+
+  # # Columns for which to add a validate presence: true even though the database doesn't have them marked as NOT NULL.
+  # # Designated by <table name>.<column name>
+  # Brick.not_nullables = ['users.name']
+
+  # # FRIENDLY DSL
+
+  # # A simple DSL is available to allow more user-friendly display of objects.  Normally a user object might be shown
+  # # as its first non-metadata column, or if that is not available then something like \"User #45\" where 45 is that
+  # # object's ID.  If there is no primary key then even that is not possible, so the object's .to_s method is called.
+  # # To override these defaults and specify exactly what you want shown, such as first names and last names for a
+  # # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
+  # Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
+
+  # # SINGLE TABLE INHERITANCE
+
+  # # Specify STI subclasses either directly by name or as a general module prefix that should always relate to a specific
+  # # parent STI class.  The prefixed :: here for these examples is mandatory.  Also having a suffixed :: means instead of
+  # # a class reference, this is for a general namespace reference.  So in this case requests for, say, either of the
+  # # non-existent classes Animals::Cat or Animals::Goat (or anything else with the module prefix of \"Animals::\" would
+  # # build a model that inherits from Animal.  And a request specifically for the class Snake would build a new model
+  # # that inherits from Reptile, and no other request would do this -- only specifically for Snake.  The ending ::
+  # # indicates that it's a module prefix instead of a specific class name.
+  # 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'] }
+
+  # # POLYMORPHIC ASSOCIATIONS
+
+  # # 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_behavior = :namespaced
+#{Brick.config.schema_behavior.present? ? "  Brick.schema_behavior = { multitenant: { schema_to_analyse: #{
   Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil).inspect}" :
-"# Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering'"
+"  # Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering'"
 } } }
 
-# # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
+  # # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 
-# # DEFAULT ROOT ROUTE
+  # # DEFAULT ROOT ROUTE
 
-# # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
-# # route to go to the :index action for what would be a controller for that table.  You can specify any controller
-# # name and action you wish in order to override this and have that be the default route when none other has been
-# # specified in routes.rb or elsewhere.  (Or just use an empty string in order to disable this behaviour.)
-# Brick.default_route_fallback = 'customers' # This defaults to \"customers#index\"
-# Brick.default_route_fallback = 'orders#outstanding' # Example of a non-RESTful route
-# Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
+  # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
+  # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
+  # # name and action you wish in order to override this and have that be the default route when none other has been
+  # # specified in routes.rb or elsewhere.  (Or just use an empty string in order to disable this behaviour.)
+  # Brick.default_route_fallback = 'customers' # This defaults to \"customers#index\"
+  # Brick.default_route_fallback = 'orders#outstanding' # Example of a non-RESTful route
+  # Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
+end
 ")
       end
     end

metadata

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