brick 1.0.58 → 1.0.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 508d41fa8b75089e0467ece56ab53fc78b651f3951eabe62d108a62fa8b0f35e
-  data.tar.gz: dcd419560d850fb2014aab3076a6a80f5a555320ac2c2183e3381a916d94dbc8
+  metadata.gz: 67de1c0cde3f28379388dfe0c2aa488197c5cfaad1a108408b506ba66ab64b38
+  data.tar.gz: 7d3e40960043e5e09e483dee791dd5f7c1d0f54f692a39ec2ef85b1b5cba1073
 SHA512:
-  metadata.gz: 49c90c7fbb1845e151f91b9df7f3b639d587e6239dae5e7f31306807a2b4dc7ac83436d78d46839accfea7c614fd2a94f2460443ea3daae424d280fae17cac77
-  data.tar.gz: 7dd02fd9ab902cfe6359b6be95101ec3a89c47d8b7bc71692ab4537f5ffeb3a24a4ee73063fc10b3d4197ce59fd5c94380f7534f66647d8c03dd512c6ef0c334
+  metadata.gz: 90ae5f021e562d3188c4bde03e9b71a744417c5223f5736cff97cce90646b8b06860b245dcb718414fdce00df2c772bcbe1ad0d102310d7f3ff030641591387d
+  data.tar.gz: 704f2dde1c0043a141d96ff272346ac583e7f784df494bb4ce39f4bf5e2cd06ffadfa37783a1bfb0671c5a5fd120819c9f286e5c9bd0608764aa10338840d881

data/lib/brick/config.rb

@@ -230,6 +230,11 @@ module Brick
       @mutex.synchronize { @not_nullables = columns }
     end
 
+    # Add status page showing all resources and what files have been built out for them
+    def add_status
+      true
+    end
+
     # Add a special page to show references to non-existent records ("orphans")
     def add_orphans
       true

data/lib/brick/extensions.rb

@@ -373,6 +373,7 @@ module ActiveRecord
     end
 
     def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+      is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
@@ -397,12 +398,14 @@ module ActiveRecord
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         columns.each do |col|
-          if (col_name = col.name) == 'class'
-            col_alias = ' AS _class'
-          end
-          # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
-          cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col.name)&.first&.start_with?('xml')
-          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
+          col_alias = ' AS _class' if (col_name = col.name) == 'class'
+          selects << if is_mysql
+                       "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
+                     else
+                       # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
+                       cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col.name)&.first&.start_with?('xml')
+                       "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
+                     end
         end
       end
 
@@ -430,7 +433,11 @@ module ActiveRecord
               if used_col_aliases.key?(col_alias = "_brfk_#{v.first}__#{sel_col.last}")
                 col_alias = "_brfk_#{v.first}__#{v1[idx][-2..-1].map(&:to_s).join('__')}"
               end
-              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+              selects << if is_mysql
+                           "`#{field_tbl_name}`.`#{sel_col.last}` AS `#{col_alias}`"
+                         else
+                           "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+                         end
               used_col_aliases[col_alias] = nil
               v1[idx] << col_alias
             end
@@ -439,7 +446,11 @@ module ActiveRecord
               # Accommodate composite primary key by allowing id_col to come in as an array
               ((id_col = k1.primary_key).is_a?(Array) ? id_col : [id_col]).each do |id_part|
                 id_for_tables[v.first] << if id_part
-                                            selects << "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+                                            selects << if is_mysql
+                                                         "#{"`#{tbl_name}`.`#{id_part}`"} AS `#{(id_alias = "_brfk_#{v.first}__#{id_part}")}`"
+                                                       else
+                                                         "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+                                                       end
                                             id_alias
                                           end
               end
@@ -646,7 +657,7 @@ Module.class_exec do
                full_class_name << "::#{self.name}" unless self == Object
                full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
                if (plural_class_name == 'BrickSwagger' ||
-                  (::Brick.config.add_orphans && plural_class_name == 'BrickGem') ||
+                  ((::Brick.config.add_status || ::Brick.config.add_orphans) && plural_class_name == 'BrickGem') ||
                   model = self.const_get(full_class_name))
                  # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
@@ -667,45 +678,11 @@ Module.class_exec do
              elsif ::Brick.enable_models?
                # Custom inheritable Brick base model?
                class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
-               # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-               # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-
-               if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
-                  base_module != Object # ... or otherwise already in some namespace?
-                 schema_name = [(singular_schema_name = name.underscore),
-                                (schema_name = singular_schema_name.pluralize),
-                                name,
-                                name.pluralize].find { |s| Brick.db_schemas.include?(s) }
-               end
-               plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
-               # If it's namespaced then we turn the first part into what would be a schema name
-               singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
-
-               if base_model
-                 schema_name = name.underscore # For the auto-STI namespace models
-                 table_name = base_model.table_name
-                 Object.send(:build_model, base_module, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
-               else
-                 # Adjust for STI if we know of a base model for the requested model name
-                 # %%% Does not yet work with namespaced model names.  Perhaps prefix with plural_class_name when doing the lookups here.
-                 table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
-                                base_model.table_name
-                              else
-                                ActiveSupport::Inflector.pluralize(singular_table_name)
-                              end
-                 if ::Brick.apartment_multitenant &&
-                    Apartment.excluded_models.include?(table_name.singularize.camelize)
-                   schema_name = Apartment.default_schema
-                 end
-                 # Maybe, just maybe there's a database table that will satisfy this need
-                 if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
-                   Object.send(:build_model, schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
-                 end
-               end
+               Object.send(:build_model, relations, base_module, name, class_name, inheritable_name)
              end
     if result
       built_class, code = result
-      puts "\n#{code}"
+      puts "\n#{code}\n"
       built_class
     elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}") && !schema_name
 #         module_prefixes = type_name.split('::')
@@ -727,7 +704,42 @@ class Object
 
   private
 
-    def build_model(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
+    def build_model(relations, base_module, base_name, class_name, inheritable_name = nil)
+      if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+         base_module != Object # ... or otherwise already in some namespace?
+        schema_name = [(singular_schema_name = base_name.underscore),
+                       (schema_name = singular_schema_name.pluralize),
+                       base_name,
+                       base_name.pluralize].find { |s| Brick.db_schemas.include?(s) }
+      end
+      plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
+      # If it's namespaced then we turn the first part into what would be a schema name
+      singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
+
+      if base_model
+        schema_name = base_name.underscore # For the auto-STI namespace models
+        table_name = base_model.table_name
+        build_model_worker(base_module, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
+      else
+        # Adjust for STI if we know of a base model for the requested model name
+        # %%% Does not yet work with namespaced model names.  Perhaps prefix with plural_class_name when doing the lookups here.
+        table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
+                       base_model.table_name
+                     else
+                       ActiveSupport::Inflector.pluralize(singular_table_name)
+                     end
+        if ::Brick.apartment_multitenant &&
+           Apartment.excluded_models.include?(table_name.singularize.camelize)
+          schema_name = Apartment.default_schema
+        end
+        # Maybe, just maybe there's a database table that will satisfy this need
+        if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
+          build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
+        end
+      end
+    end
+
+    def build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
       if ::Brick.apartment_multitenant &&
          schema_name == Apartment.default_schema
         relation = relations["#{schema_name}.#{matching}"]
@@ -893,7 +905,7 @@ class Object
             end
           end
         end
-        code << "end # model #{full_name}\n\n"
+        code << "end # model #{full_name}\n"
       [built_model, code]
     end
 
@@ -989,6 +1001,17 @@ class Object
       self.send(macro, assoc_name, **options)
     end
 
+    def default_ordering(table_name, pk)
+      case (order_tbl = ::Brick.config.order[table_name]) && (order_default = order_tbl[:_brick_default])
+      when Array
+        order_default.map { |od_part| order_tbl[od_part] || od_part }
+      when Symbol
+        order_tbl[order_default] || order_default
+      else
+        pk.map(&:to_sym) # If it's not a custom ORDER BY, just use the key
+      end
+    end
+
     def build_controller(namespace, class_name, plural_class_name, model, relations)
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
@@ -1002,6 +1025,9 @@ class Object
         # Brick-specific pages
         case plural_class_name
         when 'BrickGem'
+          self.define_method :status do
+            instance_variable_set(:@resources, ::Brick.get_status_of_resources)
+          end
           self.define_method :orphans do
             instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params)))
           end
@@ -1073,27 +1099,9 @@ class Object
           # Normal (non-swagger) request
 
           # %%% Allow params to define which columns to use for order_by
-          ordering = if (order_tbl = ::Brick.config.order[table_name])
-                       case (order_default = order_tbl[:_brick_default])
-                       when Array
-                         order_default.map { |od_part| order_tbl[od_part] || od_part }
-                       when Symbol
-                         order_tbl[order_default] || order_default
-                       else
-                         pk
-                       end
-                     else
-                       pk # If it's not a custom ORDER BY, just use the key
-                     end
-          order_by, order_by_txt = model._brick_calculate_ordering(ordering)
-          if (order_params = params['_brick_order']&.split(',')&.map(&:to_sym)) # Overriding the default by providing a querystring param?
-            order_by, _ = model._brick_calculate_ordering(order_params, true) # Don't do the txt part
-          end
-
-          code << "  def index\n"
-          code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
-          code << "    @#{table_name}.brick_select(params)\n"
-          code << "  end\n"
+          # Overriding the default by providing a querystring param?
+          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.set_db_schema(params)
           if request.format == :csv # Asking for a template?
@@ -1126,6 +1134,12 @@ class Object
           @_brick_join_array = join_array
         end
 
+        _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk))
+        code << "  def index\n"
+        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
+        code << "    @#{table_name}.brick_select(params)\n"
+        code << "  end\n"
+
         is_pk_string = nil
         if (pk_col = model&.primary_key)
           code << "  def show\n"
@@ -1255,7 +1269,7 @@ class Object
             # Get column names for params from relations[model.table_name][:cols].keys
           end
         # end
-        code << "end # #{namespace_name}#{class_name}\n\n"
+        code << "end # #{namespace_name}#{class_name}\n"
       end # class definition
       [built_controller, code]
     end
@@ -1312,7 +1326,7 @@ module ActiveRecord::ConnectionHandling
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
-      # Only for Postgres?  (Doesn't work in sqlite3)
+      # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
       is_postgres = nil
@@ -1347,7 +1361,7 @@ module ActiveRecord::ConnectionHandling
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
       end
 
-      ::Brick.db_schemas ||= []
+      ::Brick.db_schemas ||= {}
 
       if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
@@ -1363,41 +1377,11 @@ module ActiveRecord::ConnectionHandling
       # %%% Retrieve internal ActiveRecord table names like this:
       # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
       # For if it's not SQLite -- so this is the Postgres and MySQL version
-      sql ||= "SELECT t.table_schema AS schema, t.table_name AS relation_name, t.table_type,#{"
-          pg_catalog.obj_description((t.table_schema || '.' || t.table_name)::regclass, 'pg_class') AS table_description," if is_postgres}
-          c.column_name, c.data_type,
-          COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
-          tc.constraint_type AS const, kcu.constraint_name AS \"key\",
-          c.is_nullable
-        FROM INFORMATION_SCHEMA.tables AS t
-          LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
-            AND t.table_name = c.table_name
-          LEFT OUTER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu ON
-            -- ON kcu.CONSTRAINT_CATALOG = t.table_catalog AND
-            kcu.CONSTRAINT_SCHEMA = c.table_schema
-            AND kcu.TABLE_NAME = c.table_name
-            AND kcu.position_in_unique_constraint IS NULL
-            AND kcu.ordinal_position = c.ordinal_position
-          LEFT OUTER JOIN INFORMATION_SCHEMA.table_constraints AS tc
-            ON kcu.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
-            AND kcu.TABLE_NAME = tc.TABLE_NAME
-            AND kcu.CONSTRAINT_NAME = tc.constraint_name
-        WHERE t.table_schema NOT IN ('information_schema', 'pg_catalog')#{"
-          AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }
-  --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
-          AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
-        ORDER BY 1, t.table_type DESC, c.ordinal_position"
       measures = []
       case ActiveRecord::Base.connection.adapter_name
       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'
-        ar_smtn = if ActiveRecord::Base.respond_to?(:schema_migrations_table_name)
-                    ActiveRecord::Base.schema_migrations_table_name
-                  else
-                    'schema_migrations'
-                  end
-        ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
-        ActiveRecord::Base.execute_sql(sql, ar_smtn, ar_imtn).each do |r|
+        ActiveRecord::Base.retrieve_schema_and_tables(sql, is_postgres, schema).each do |r|
           # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
           # is the default schema, usually 'public'.
           schema_name = if ::Brick.config.schema_behavior[:multitenant]
@@ -1424,23 +1408,23 @@ module ActiveRecord::ConnectionHandling
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
         end
       else # MySQL2 acts a little differently, bringing back an array for each row
-        ActiveRecord::Base.execute_sql(sql).each do |r|
-          relation = relations[(relation_name = r[0])] # here relation represents a table or view from the database
-          relation[:isView] = true if r[1] == 'VIEW' # table_type
-          col_name = r[2]
-          key = case r[5] # constraint type
+        ActiveRecord::Base.retrieve_schema_and_tables(sql).each do |r|
+          relation = relations[(relation_name = r[1])] # here relation represents a table or view from the database
+          relation[:isView] = true if r[2] == 'VIEW' # table_type
+          col_name = r[3]
+          key = case r[6] # constraint type
                 when 'PRIMARY KEY'
                   # key
-                  relation[:pkey][r[6] || relation_name] ||= []
+                  relation[:pkey][r[7] || relation_name] ||= []
                 when 'UNIQUE'
-                  relation[:ukeys][r[6] || "#{relation_name}.#{col_name}"] ||= []
+                  relation[:ukeys][r[7] || "#{relation_name}.#{col_name}"] ||= []
                   # key = (relation[:ukeys] = Hash.new { |h, k| h[k] = [] }) if key.is_a?(Array)
                   # key[r['key']]
                 end
           key << col_name if key
           cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
           # 'data_type', 'max_length'
-          cols[col_name] = [r[3], r[4], measures&.include?(col_name)]
+          cols[col_name] = [r[4], r[5], measures&.include?(col_name)]
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
         end
       end
@@ -1476,9 +1460,11 @@ module ActiveRecord::ConnectionHandling
             INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu2
               ON kcu2.CONSTRAINT_CATALOG = rc.UNIQUE_CONSTRAINT_CATALOG
               AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
-              AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+              AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME#{"
+              AND kcu2.TABLE_NAME = kcu1.REFERENCED_TABLE_NAME
+              AND kcu2.COLUMN_NAME = kcu1.REFERENCED_COLUMN_NAME" unless is_postgres }
               AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION#{"
-          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }"
+          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
           # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
       when 'SQLite'
         sql = "SELECT m.name, fkl.\"from\", fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
@@ -1494,12 +1480,14 @@ module ActiveRecord::ConnectionHandling
           # Multitenancy makes things a little more general overall, except for non-tenanted tables
           if apartment_excluded&.include?(fk[1].singularize.camelize)
             fk[0] = Apartment.default_schema
-          elsif fk[0] == 'public' || (is_multitenant && fk[0] == schema)
+          elsif is_postgres && (fk[0] == 'public' || (is_multitenant && fk[0] == schema)) ||
+                !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[0])
             fk[0] = nil
           end
           if apartment_excluded&.include?(fk[4].singularize.camelize)
             fk[3] = Apartment.default_schema
-          elsif fk[3] == 'public' || (is_multitenant && fk[3] == schema)
+          elsif is_postgres && (fk[3] == 'public' || (is_multitenant && fk[3] == schema)) ||
+                !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[3])
             fk[3] = nil
           end
           ::Brick._add_bt_and_hm(fk, relations)
@@ -1533,6 +1521,41 @@ module ActiveRecord::ConnectionHandling
 
     ::Brick.load_additional_references if initializer_loaded
   end
+
+  def retrieve_schema_and_tables(sql = nil, is_postgres = nil, schema = nil)
+    sql ||= "SELECT t.table_schema AS \"schema\", t.table_name AS relation_name, t.table_type,#{"
+      pg_catalog.obj_description((t.table_schema || '.' || t.table_name)::regclass, 'pg_class') AS table_description," if is_postgres}
+      c.column_name, c.data_type,
+      COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
+      tc.constraint_type AS const, kcu.constraint_name AS \"key\",
+      c.is_nullable
+    FROM INFORMATION_SCHEMA.tables AS t
+      LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
+        AND t.table_name = c.table_name
+      LEFT OUTER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu ON
+        -- ON kcu.CONSTRAINT_CATALOG = t.table_catalog AND
+        kcu.CONSTRAINT_SCHEMA = c.table_schema
+        AND kcu.TABLE_NAME = c.table_name
+        AND kcu.position_in_unique_constraint IS NULL
+        AND kcu.ordinal_position = c.ordinal_position
+      LEFT OUTER JOIN INFORMATION_SCHEMA.table_constraints AS tc
+        ON kcu.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+        AND kcu.TABLE_NAME = tc.TABLE_NAME
+        AND kcu.CONSTRAINT_NAME = tc.constraint_name
+    WHERE t.table_schema #{
+         is_postgres ? "NOT IN ('information_schema', 'pg_catalog')" : "= '#{ActiveRecord::Base.connection.current_database.tr("'", "''")}'"}#{"
+      AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }
+  --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
+      AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
+    ORDER BY 1, t.table_type DESC, 2, c.ordinal_position"
+    ar_smtn = if ActiveRecord::Base.respond_to?(:schema_migrations_table_name)
+                ActiveRecord::Base.schema_migrations_table_name
+              else
+                'schema_migrations'
+              end
+    ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
+    ActiveRecord::Base.execute_sql(sql, ar_smtn, ar_imtn)
+  end
 end
 
 # ==========================================
@@ -1680,6 +1703,59 @@ module Brick
       assoc_bt[:inverse] = assoc_hm
     end
 
+    # Identify built out routes, migrations, models,
+    # (and also soon controllers and views!)
+    # for each resource
+    def get_status_of_resources
+      rails_root = ::Rails.root.to_s
+      migrations = if Dir.exist?(mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{rails_root}/db/migrate")
+                     Dir["#{mig_path}/**/*.rb"].each_with_object(Hash.new { |h, k| h[k] = [] }) do |v, s|
+                       File.read(v).split("\n").each do |line|
+                         # For all non-commented lines, look for any that have "create_table", "alter_table", or "drop_table"
+                         if !line.lstrip.start_with?('#') &&
+                            (idx = (line.index('create_table ') || line.index('create_table('))&.+(13)) ||
+                            (idx = (line.index('alter_table ') || line.index('alter_table('))&.+(12)) ||
+                            (idx = (line.index('drop_table ') || line.index('drop_table('))&.+(11))
+                           tbl = line[idx..-1].match(/([:'"\w\.]+)/)&.captures&.first
+                           if tbl
+                             s[tbl.tr(':\'"', '').pluralize] << v
+                             break
+                           end
+                         end
+                       end
+                     end
+                   end
+      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
+         ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
+        Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+      else
+        Zeitwerk::Loader.eager_load_all
+      end
+      abstract_activerecord_bases = ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
+      # abstract_activerecord_bases << ActiveRecord::Base
+      models = if Dir.exist?(model_path = "#{rails_root}/app/models")
+                 Dir["#{model_path}/**/*.rb"].each_with_object({}) do |v, s|
+                   File.read(v).split("\n").each do |line|
+                     # For all non-commented lines, look for any that start with "class " and also "< ApplicationRecord"
+                     if line.lstrip.start_with?('class') && (idx = line.index('class'))
+                       model = line[idx + 5..-1].match(/[\s:]+([\w:]+)/)&.captures&.first
+                       if model && abstract_activerecord_bases.exclude?(model)
+                         klass = begin
+                                   model.constantize
+                                 rescue
+                                 end
+                         s[model.underscore.tr('/', '.').pluralize] = [
+                           v.start_with?(rails_root) ? v[rails_root.length + 1..-1] : v,
+                           klass
+                         ]
+                       end
+                     end
+                   end
+                 end
+               end
+      ::Brick.relations.keys.map { |v| [(r = v.pluralize), (model = models[r])&.last&.table_name || v, migrations&.fetch(r, nil), model&.first] }
+    end
+
     # Locate orphaned records
     def find_orphans(multi_schema)
       is_default_schema = multi_schema&.==(Apartment.default_schema)

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

@@ -56,6 +56,7 @@ module Brick
             # Used by Rails 5.0 and above
             alias :_brick_template_exists? :template_exists?
             def template_exists?(*args, **options)
+              (::Brick.config.add_status && args.first == 'status') ||
               (::Brick.config.add_orphans && args.first == 'orphans') ||
               _brick_template_exists?(*args, **options) ||
               # Do not auto-create a template when it's searching for an application.html.erb, which comes in like:  ["edit", ["games", "application"]]
@@ -96,11 +97,12 @@ module Brick
                        @_brick_model ||
                        (ActionView.version < ::Gem::Version.new('5.0') && args[1].is_a?(Array) ? set_brick_model(args) : nil)
                      )&.name) ||
+                     (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
                      (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']])
                 return _brick_find_template(*args, **options)
               end
 
-              unless is_orphans
+              unless is_status || is_orphans
                 pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
                 obj_name = model_name.split('::').last.underscore
                 path_obj_name = model_name.underscore.tr('/', '_')
@@ -148,7 +150,6 @@ module Brick
                                    ", nil, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
                                  end
                     hm_entry << ']'
-                    puts hm_entry
                     hms_columns << hm_entry
                   when 'show', 'update'
                     hm_stuff << if hm_fk_name
@@ -613,8 +614,9 @@ if (headerTop) {
       });
     });
   </script>
-<% end %>
-<table id=\"headerTop\">
+<% end
+
+%><table id=\"headerTop\">
 <table id=\"#{table_name}\">
   <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%=
      # Consider getting the name from the association -- hm.first.name -- if a more \"friendly\" alias should be used for a screwy table name
@@ -708,6 +710,53 @@ if (headerTop) {
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{path_obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
+
+                       when 'status'
+# Status page - list of all resources and 5 things they do or don't have present, and what is turned on and off
+# Must load all models, and then find what table names are represented
+# Easily could be multiple files involved (STI for instance)
++"#{css}
+<p style=\"color: green\"><%= notice %></p>#{"
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
+<select id=\"tbl\">#{table_options}</select>
+<h1>Status</h1>
+<table id=\"status\"><thead><tr>
+  <th>Resource</th>
+  <th>Table</th>
+  <th>Migration</th>
+  <th>Model</th>
+  <th>Route</th>
+  <th>Controller</th>
+  <th>Views</th>
+</tr></thead>
+<tbody>
+<% # (listing in schema.rb)
+   # Solid colour if file or route entry is present
+  @resources.each do |r|
+  %>
+  <tr>
+  <td><%= link_to(r[0], \"/#\{r[0].tr('.', '/')}\") %></td>
+  <td<%= if r[1]
+           ' class=\"orphan\"' unless ::Brick.relations.key?(r[1])
+         else
+           ' class=\"dimmed\"'
+         end&.html_safe %>><%= # Table
+          r[1] %></td>
+  <td<%= ' class=\"dimmed\"'.html_safe unless r[2] %>><%= # Migration
+          r[2]&.join('<br>')&.html_safe %></td>
+  <td<%= ' class=\"dimmed\"'.html_safe unless r[3] %>><%= # Model
+          r[3] %></td>
+  <td<%= ' class=\"dimmed\"'.html_safe unless r[4] %>><%= # Route
+               %></td>
+  <td<%= ' class=\"dimmed\"'.html_safe unless r[5] %>><%= # Controller
+               %></td>
+  <td<%= ' class=\"dimmed\"'.html_safe unless r[6] %>><%= # Views
+               %></td>
+  <tr>
+<% end %>
+</tbody><table>
+#{script}"
+
                        when 'orphans'
                          if is_orphans
 +"#{css}

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -484,6 +484,9 @@ In config/initializers/brick.rb appropriate entries would look something like:
               send(:resources, controller_name.to_sym, **options)
             end
           end
+          if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
+            get('/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('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
           end

data/lib/generators/brick/migrations_generator.rb

@@ -85,10 +85,9 @@ module Brick
       # Generate a list of tables that can be chosen
       chosen = gets_list(list: tables, chosen: tables.dup)
       schemas = chosen.each_with_object({}) do |v, s|
-        schema = if v.split('.').length > 1
-                   v.first
-                 end
-        s[schema] = nil if schema && [::Brick.default_schema, 'public'].exclude?(schema)
+        if (v_parts = v.split('.')).length > 1
+          s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
+        end
       end
       # Start the timestamps back the same number of minutes from now as expected number of migrations to create
       current_mig_time = Time.now - (schemas.length + chosen.length).minutes
@@ -130,7 +129,7 @@ module Brick
                        tbl_parts.first
                      end
                    end
-          unless built_schemas.key?(schema)
+          unless schema.blank? || built_schemas.key?(schema)
             mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
             migration_file_write(mig_path, "create_db_schema_#{schema}", current_mig_time += 1.minute, ar_version, mig)
             built_schemas[schema] = nil

data/lib/generators/brick/{model_generator.rb → models_generator.rb}

@@ -6,63 +6,72 @@ require 'fancy_gets'
 
 module Brick
   # Auto-generates models, controllers, or views
-  class ModelGenerator < ::Rails::Generators::Base
+  class ModelsGenerator < ::Rails::Generators::Base
     include FancyGets
     # include ::Rails::Generators::Migration
 
-    # # source_root File.expand_path('templates', __dir__)
-    # class_option(
-    #   :with_changes,
-    #   type: :boolean,
-    #   default: false,
-    #   desc: 'Add IMPORT_TEMPLATE to model'
-    # )
-
     desc 'Auto-generates models, controllers, or views.'
 
-    def brick_model
-      # %%% If Apartment is active, ask which schema they want
+    def brick_models
+      # %%% If Apartment is active and there's no schema_to_analyse, ask which schema they want
 
       # Load all models
-      Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
+        ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
+        Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+      else
+        Zeitwerk::Loader.eager_load_all
+      end
 
       # Generate a list of viable models that can be chosen
       longest_length = 0
       model_info = Hash.new { |h, k| h[k] = {} }
       tableless = Hash.new { |h, k| h[k] = [] }
-      models = ActiveRecord::Base.descendants.reject do |m|
-        trouble = if m.abstract_class?
-                    true
-                  elsif !m.table_exists?
-                    tableless[m.table_name] << m.name
-                    ' (No Table)'
-                  else
-                    this_f_keys = (model_info[m][:f_keys] = m.reflect_on_all_associations.select { |a| a.macro == :belongs_to }) || []
-                    column_names = (model_info[m][:column_names] = m.columns.map(&:name) - [m.primary_key, 'created_at', 'updated_at', 'deleted_at'] - this_f_keys.map(&:foreign_key))
-                    if column_names.empty? && this_f_keys && !this_f_keys.empty?
-                      fk_message = ", although #{this_f_keys.length} foreign keys"
-                      " (No columns#{fk_message})"
-                    end
-                  end
-        # puts "#{m.name}#{trouble}" if trouble&.is_a?(String)
-        trouble
+      existing_models = ActiveRecord::Base.descendants.reject do |m|
+        m.abstract_class? || !m.table_exists? || ::Brick.relations.key?(m.table_name)
       end
+      models = ::Brick.relations.keys.map do |tbl|
+        tbl_parts = tbl.split('.')
+        tbl_parts.shift if [::Brick.default_schema, 'public'].include?(tbl_parts.first)
+        tbl_parts[-1] = tbl_parts[-1].singularize
+        tbl_parts.join('/').camelize
+      end - existing_models.map(&:name)
       models.sort! do |a, b| # Sort first to separate namespaced stuff from the rest, then alphabetically
-        is_a_namespaced = a.name.include?('::')
-        is_b_namespaced = b.name.include?('::')
+        is_a_namespaced = a.include?('::')
+        is_b_namespaced = b.include?('::')
         if is_a_namespaced && !is_b_namespaced
           1
         elsif !is_a_namespaced && is_b_namespaced
           -1
         else
-          a.name <=> b.name
+          a <=> b
         end
       end
       models.each do |m| # Find longest name in the list for future use to show lists on the right side of the screen
-        if longest_length < (len = m.name.length)
+        if longest_length < (len = m.length)
           longest_length = len
         end
       end
+      chosen = gets_list(list: models, chosen: models.dup)
+      relations = ::Brick.relations
+      chosen.each do |model_name|
+        # %%% If we're in a schema then make sure the module file exists
+        base_module = if (model_parts = model_name.split('::')).length > 1
+                        "::#{model_parts.first}".constantize
+                      else
+                        Object
+                      end
+        _built_model, code = Object.send(:build_model, relations, base_module, base_module.name, model_parts.last)
+        path = ['models']
+        path.concat(model_parts.map(&:underscore))
+        dir = +"#{::Rails.root}/app"
+        path[0..-2].each do |path_part|
+          dir << "/#{path_part}"
+          Dir.mkdir(dir) unless Dir.exists?(dir)
+        end
+        File.open("#{dir}/#{path.last}.rb", 'w') { |f| f.write code } unless code.blank?
+      end
+      puts "\n*** Created #{chosen.length} model files under app/models ***"
     end
 
   private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.58
+  version: 1.0.61
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -239,7 +239,7 @@ files:
 - lib/generators/brick/USAGE
 - lib/generators/brick/install_generator.rb
 - lib/generators/brick/migrations_generator.rb
-- lib/generators/brick/model_generator.rb
+- lib/generators/brick/models_generator.rb
 - lib/generators/brick/templates/add_object_changes_to_versions.rb.erb
 - lib/generators/brick/templates/create_versions.rb.erb
 homepage: https://github.com/lorint/brick