brick 1.0.78 → 1.0.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f0716e20661f909922bdcddf3401b79b87c33c7b118d1581dfdf9861dd702c
-  data.tar.gz: 45323c512a8c7490b0ac715595ead6e6299d06a442b9c723318b90bcdce6106d
+  metadata.gz: 17bf4590fae09ac7d48f3f607996bf6297d530a9b87f338ae4519178431bfa9c
+  data.tar.gz: 65c67de2f3cadad727971c31d2ce6aba476cdfb28dcfdb8f440028cd1657f3e0
 SHA512:
-  metadata.gz: 2ef6ac2089e1150bc9c74c6625fc3e7627f5ee06a42d1a2d5fe43790d99156abacc27ba2e042044ee42171f352718d99ae8b468ec9dca4350cd6631bead51ce7
-  data.tar.gz: 8c4da365eb99677930a9f35f0cd5981b91adc790a13ecf55b5369da03fdf1592cccd01f911457cf204aa8769767d5a8537d856ff7080dec75543524b3e680904
+  metadata.gz: f96ad491da932e615513d0b92b98dee2ceea3327a5938d1ae1c9f81b0cde29193a465227cf13510bbcb2306a68e72e097a02ce5f2f0f6308c00c6b5bb714fcf9
+  data.tar.gz: b0058bd2ba86e8d2a89276cf38061a07de63a509d65532d173079f255f73d3293b8550f902d9be00f2ff9962ba76a142691d1ce7fe28b1786de429120f3d9d31

data/lib/brick/extensions.rb

@@ -614,15 +614,16 @@ module ActiveRecord
         count_column = if hm.options[:through]
                          # Build the chain of JOINs going to the final destination HMT table
                          # (Usually just one JOIN, but could be many.)
-                         x = [hmt_assoc = hm]
+                         hmt_assoc = hm
+                         x = []
                          x.unshift(hmt_assoc) while hmt_assoc.options[:through] && (hmt_assoc = klass.reflect_on_association(hmt_assoc.options[:through]))
-                         from_clause = +"#{x.first.klass.table_name} br_t0"
+                         from_clause = +"#{x.first.table_name} br_t0"
                          fk_col = x.shift.foreign_key
                          link_back = [klass.primary_key] # %%% Inverse path back to the original object -- used to build out a link with a filter
                          idx = 0
                          bail_out = nil
-                         x[0..-2].map do |a|
-                           from_clause << "\n LEFT OUTER JOIN #{a.klass.table_name} br_t#{idx += 1} "
+                         x.map do |a|
+                           from_clause << "\n LEFT OUTER JOIN #{a.table_name} br_t#{idx += 1} "
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
                                             "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
                                           elsif src_ref.options[:as]
@@ -637,18 +638,22 @@ module ActiveRecord
                                             "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
                                           end
                            link_back.unshift(a.source_reflection.name)
-                           [a.klass.table_name, a.foreign_key, a.source_reflection.macro]
+                           [a.table_name, a.foreign_key, a.source_reflection.macro]
                          end
                          next if bail_out
-                         # count_column is determined from the last HMT member
-                         if (src_ref = x.last.source_reflection).macro == :belongs_to # Traditional HMT using an associative table
-                           "br_t#{idx}.#{x.last.foreign_key}"
+                         # 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]}"
+                           nix << k
+                           bail_out = true
+                         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
                            "br_t#{idx}.#{src_ref.active_record.primary_key}"
                          end
                        else
-                         fk_col = hm.foreign_key
-                         poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
+                         fk_col = (inv = hm.inverse_of)&.foreign_key || hm.foreign_key
+                         poly_type = inv.foreign_type if hm.options.key?(:as)
                          pk = hm.klass.primary_key
                          (pk.is_a?(Array) ? pk.first : pk) || '*'
                        end
@@ -684,11 +689,11 @@ module ActiveRecord
         end
         unless from_clause
           hm_table_name = if is_mysql
-                            "`#{hm.klass.table_name}`"
+                            "`#{hm.table_name}`"
                           elsif is_postgres || is_mssql
-                            "\"#{(hm.klass.table_name).gsub('.', '"."')}\""
+                            "\"#{(hm.table_name).gsub('.', '"."')}\""
                           else
-                            hm.klass.table_name
+                            hm.table_name
                           end
         end
         group_bys = ::Brick.is_oracle || is_mssql ? selects : (1..selects.length).to_a
@@ -1030,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('::')
@@ -1065,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"
@@ -1383,7 +1397,7 @@ class Object
           ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
           order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
 
-          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), nil,
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by,
                                                                   translations = {},
                                                                   join_array = ::Brick::JoinArray.new)
           # %%% Add custom HM count columns
@@ -1658,7 +1672,10 @@ module ActiveRecord::ConnectionHandling
       # .default_schema are specified then we can work with non-tenanted models more appropriately
       if (apartment = Object.const_defined?('Apartment')) &&
          File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
-        load apartment_initializer
+        unless @_apartment_loaded
+          load apartment_initializer
+          @_apartment_loaded = true
+        end
         apartment_excluded = Apartment.excluded_models
       end
       # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
@@ -1924,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
 
@@ -2148,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

@@ -813,6 +813,24 @@ erDiagram
                  hms_keys << (assoc_name = (assoc = hm.first).name.to_s)
                  "#{assoc_name.inspect} => [#{(assoc.options[:through] && !assoc.through_reflection).inspect}, #{assoc.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
                end.join(', ')}}
+     # If the resource is missing, has the user simply created an inappropriately pluralised name for a table?
+     @#{table_name} ||= if dym_list = instance_variables.reject do |entry|
+                             entry.to_s.start_with?('@_') ||
+                             ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
+                           end
+                          msg = \"Can't find resource \\\"#{table_name}\\\".\"
+                           # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
+                          if (dym = DidYouMean::SpellChecker.new(dictionary: dym_list).correct('@#{table_name}')).present?
+                            msg << \"\nIf you meant \\\"#\{found_dym = dym.first[1..-1]}\\\" then to avoid this message add this entry into inflections.rb:\n\"
+                            msg << \"  inflect.singular('#\{found_dym}', '#{obj_name}')\"
+                            puts
+                            puts \"WARNING:  #\{msg}\"
+                            puts
+                            @#{table_name} = instance_variable_get(dym.first.to_sym)
+                          else
+                            raise ActiveRecord::RecordNotFound.new(msg)
+                          end
+                        end
      col_keys = @#{table_name}.columns.each_with_object([]) do |col, s|
        col_name = col.name
        next if @_brick_incl&.exclude?(col_name) ||
@@ -1306,6 +1324,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 = 78
+    TINY = 80
 
     # 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)
@@ -179,13 +178,21 @@ module Brick
 
         case a.macro
         when :belongs_to
-          s.first[a.foreign_key] = if a.polymorphic?
-                                     primary_tables = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }&.last&.fetch(:inverse_table, [])
-                                     models = primary_tables&.map { |table| table.singularize.camelize.constantize }
-                                     [a.name, models, true]
-                                   else
-                                     [a.name, a.klass]
-                                   end
+          if a.polymorphic?
+            rel_poly_bt = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }
+            if (primary_tables = rel_poly_bt&.last&.fetch(:inverse_table, [])).is_a?(Array)
+              models = primary_tables&.map { |table| table.singularize.camelize.constantize }
+              s.first[a.foreign_key] = [a.name, models, true]
+            else
+              # This will come up when using Devise invitable when invited_by_class_name is not
+              # specified because in that circumstance it adds a polymorphic :invited_by association,
+              # along with appropriate invited_by_type and invited_by_id columns.
+              puts "Missing any real indication as to which models \"has_many\" this polymorphic BT in model #{a.active_record.name}:"
+              puts "  belongs_to :#{a.name}, polymorphic: true"
+            end
+          else
+            s.first[a.foreign_key] = [a.name, a.klass]
+          end
         when :has_many, :has_one # This gets has_many as well as has_many :through
           # %%% weed out ones that don't have an available model to reference
           s.last[a.name] = a
@@ -532,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"
@@ -540,84 +548,90 @@ 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)
-            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
-              else
-                table_class_length = class_name.length if class_name.length > table_class_length
-                tables
-              end << [class_name, full_resource || v[:resource]]
+              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
-        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' })
+          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' })
+          end
+
+          unless ::Brick.routes_done
+            ::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

metadata

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