brick 1.0.80 → 1.0.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17bf4590fae09ac7d48f3f607996bf6297d530a9b87f338ae4519178431bfa9c
-  data.tar.gz: 65c67de2f3cadad727971c31d2ce6aba476cdfb28dcfdb8f440028cd1657f3e0
+  metadata.gz: 74df340edd3b41626ea7f72409064b27ae10ddfd6eb41dd66ecc6704044156bd
+  data.tar.gz: 82181c7ffe7a26b6ab02bfc4faaedf031d78e5e4880f6316e1ea2143da8a9655
 SHA512:
-  metadata.gz: f96ad491da932e615513d0b92b98dee2ceea3327a5938d1ae1c9f81b0cde29193a465227cf13510bbcb2306a68e72e097a02ce5f2f0f6308c00c6b5bb714fcf9
-  data.tar.gz: b0058bd2ba86e8d2a89276cf38061a07de63a509d65532d173079f255f73d3293b8550f902d9be00f2ff9962ba76a142691d1ce7fe28b1786de429120f3d9d31
+  metadata.gz: 644d3d343e774f8682a575c8fad849c27ee60c279e30a689874b608f056b1aee39a936ec85e91878d2200deeaf49ad78188866b6548ccf6dae43fbadbe80752a
+  data.tar.gz: '09f1f3383f9db0f3519215bb372a238478a0ae5176090bd2992a4f43f6e41b8aaef9f2a449573413ee886cc08cd94b868e0ec81a822b20d8dd0cc9e4eebf635e'

data/lib/brick/extensions.rb

@@ -59,6 +59,10 @@ end
 
 module ActiveRecord
   class Base
+    def self.is_brick?
+      instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
+    end
+
     def self._assoc_names
       @_assoc_names ||= {}
     end
@@ -521,7 +525,7 @@ module ActiveRecord
         # CUSTOM COLUMNS
         # ==============
         klass._br_cust_cols.each do |k, cc|
-          if respond_to?(k) # Name already taken?
+          if rel_dupe.respond_to?(k) # Name already taken?
             # %%% Use ensure_unique here in this kind of fashion:
             # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
             # binding.pry
@@ -641,11 +645,13 @@ module ActiveRecord
                            [a.table_name, a.foreign_key, a.source_reflection.macro]
                          end
                          next if bail_out
+
                          # count_column is determined from the originating HMT member
                          if (src_ref = hm.source_reflection).nil?
                            puts "*** Warning:  Could not determine destination model for this HMT association in model #{klass.name}:\n  has_many :#{hm.name}, through: :#{hm.options[:through]}"
+                           puts
                            nix << k
-                           bail_out = true
+                           next
                          elsif src_ref.macro == :belongs_to # Traditional HMT using an associative table
                            "br_t#{idx}.#{hm.foreign_key}"
                          else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
@@ -676,15 +682,15 @@ module ActiveRecord
                          pri_tbl.table_name
                        end
         on_clause = []
-        if fk_col.is_a?(Array) # Composite key?
-          fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl_name}.#{pri_tbl.primary_key[idx]}" }
-          selects = fk_col.dup
-        else
-          selects = [fk_col]
-          on_clause << "#{tbl_alias}.#{fk_col} = #{pri_tbl_name}.#{pri_tbl.primary_key}"
-        end
+        hm_selects = if fk_col.is_a?(Array) # Composite key?
+                       fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl_name}.#{pri_tbl.primary_key[idx]}" }
+                       fk_col.dup
+                     else
+                       on_clause << "#{tbl_alias}.#{fk_col} = #{pri_tbl_name}.#{pri_tbl.primary_key}"
+                       [fk_col]
+                     end
         if poly_type
-          selects << poly_type
+          hm_selects << poly_type
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
         unless from_clause
@@ -696,9 +702,9 @@ module ActiveRecord
                             hm.table_name
                           end
         end
-        group_bys = ::Brick.is_oracle || is_mssql ? selects : (1..selects.length).to_a
+        group_bys = ::Brick.is_oracle || is_mssql ? hm_selects : (1..hm_selects.length).to_a
         join_clause = "LEFT OUTER
-JOIN (SELECT #{selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
+JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
           }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
@@ -735,8 +741,10 @@ JOIN (SELECT #{selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')},
             else
               s << v
             end
-          else # String stuff just comes straight through
+          else # String stuff (which defines a custom ORDER BY) just comes straight through
             s << v
+            # Avoid "PG::InvalidColumnReference: ERROR: for SELECT DISTINCT, ORDER BY expressions must appear in select list" in Postgres
+            selects << v if is_distinct
           end
         end
         order!(*final_order_by)
@@ -909,7 +917,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'
@@ -1138,6 +1146,7 @@ class Object
       end # class definition
       # Having this separate -- will this now work out better?
         built_model.class_exec do
+          @_brick_built = true
           hmts&.each do |hmt_fk, hms|
             hmt_fk = hmt_fk.tr('.', '_')
             hms.each do |hm|
@@ -1312,13 +1321,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
@@ -1329,7 +1338,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': {
@@ -1426,7 +1435,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"
@@ -1564,7 +1573,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]
@@ -1754,7 +1763,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
@@ -1785,7 +1794,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 =

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

@@ -130,15 +130,15 @@ module Brick
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 tbl_nm = if hm_assoc.options[:source]
-                                            associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
+                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :belongs_to
+                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
                                           else
-                                            associative.name
+                                            source.inverse_of&.name # For HM -> HM style HMT
                                           end
                                  # If there is no inverse available for the source belongs_to association, make one based on the class name
                                  unless tbl_nm
                                    tbl_nm = associative.class_name.underscore
-                                   tbl_nm.slice!(0) if tbl_nm[0] == ('/')
+                                   tbl_nm.slice!(0) if tbl_nm[0] == '/'
                                    tbl_nm = tbl_nm.tr('/', '_').pluralize
                                  end
                                  "'#{tbl_nm}.#{associative.foreign_key}'"
@@ -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
 
@@ -1312,10 +1331,18 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
             prepend ::Brick::RouteSet
           end
           # Do the root route before the Rails Welcome one would otherwise take precedence
-          unless (route = ::Brick.config.default_route_fallback).blank? ||
-                 ::Rails.application.routes.named_routes.send(:routes)[:root]
-            ::Rails.application.routes.append do
-              send(:root, "#{route}#{'#index' unless route.index('#')}")
+          if (route = ::Brick.config.default_route_fallback).present?
+            action = "#{route}#{'#index' unless route.index('#')}"
+            if ::Brick.config.path_prefix
+              ::Rails.application.routes.append do
+                send(:namespace, ::Brick.config.path_prefix) do
+                  send(:root, action)
+                end
+              end
+            elsif ::Rails.application.routes.named_routes.send(:routes)[:root].nil?
+              ::Rails.application.routes.append do
+                send(:root, action)
+              end
             end
           end
         end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -113,15 +113,15 @@ if Gem::Specification.all_names.any? { |g| g.start_with?('rails-') }
   require 'brick/frameworks/rails'
 end
 module Brick
-  def self.sti_models
-    @sti_models ||= {}
-  end
+  class << self
+    def sti_models
+      @sti_models ||= {}
+    end
 
-  def self.existing_stis
-    @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
-  end
+    def existing_stis
+      @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
+    end
 
-  class << self
     attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models
 
     def set_db_schema(params = nil)
@@ -203,11 +203,9 @@ module Brick
       skip_hms = {}
       hms.each do |hmt|
         if (through = hmt.last.options[:through])
-          skip_hms[through] = nil # if hms[through]
-          # binding.pry if !hms[through]
+          # ::Brick.relations[hmt.last.through_reflection.table_name]
+          skip_hms[through] = nil if hms[through] && model.is_brick?
           # End up with a hash of HMT names pointing to join-table associations
-          # Last part was:  hmt.last.name
-          # Changed up because looking for:  hms[:issue_issue_duplicates]
           model._br_associatives[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
         elsif hmt.last.inverse_of.nil?
           puts "SKIPPING #{hmt.last.name.inspect}"
@@ -612,13 +610,35 @@ In config/initializers/brick.rb appropriate entries would look something like:
             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' })
-          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
+                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
+
             ::Brick.routes_done = true
             puts "\n" if tables.present? || views.present?
             if tables.present?

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,171 @@ 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.)
+  # This defaults to \"customers#index\", and if there was also a prefix set called \"admin\" then it would instead
+  # go to \"admin/customers#index\".
+  # Brick.default_route_fallback = 'customers'
+  # 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.80
+  version: 1.0.82
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-17 00:00:00.000000000 Z
+date: 2022-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord