brick 1.0.190 → 1.0.192

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e7a12940f4ac57eea3c53bb3b437472f90bbaa857bd6611d3e871463add46f2
-  data.tar.gz: 8afb6e47cebd99a9b4172aa82d9447b71dd66e6df750249063b66b9b9ba939a9
+  metadata.gz: 148c8f46702d06322322c04487a1045e6d7a3927611394a84ffe138be78adb5e
+  data.tar.gz: 716bfaae50dc99809bc3aee4eecf5ff1c44325bca54271db225a765cdd97fb56
 SHA512:
-  metadata.gz: d5379ddb6c61675b5606730a771a3f95638829b8359b42fd78c0509836635a93d36b787b09f21a0b9321623c917a149508b643a68ff4474baf7b40739ad5eeed
-  data.tar.gz: 40b6c6dc4fd31b10632fafb572608ec1c6473b6efa1dab346f1c82fc4f9daa1faba6d3675b336a780291595e25ace20358a95205a9284e7c42ddf450efe1d0a4
+  metadata.gz: d97d94ed8d951718b34d1fc0d3ee8d023b3765bafc759fd41161155c927014ddec54a67e371363bbb17b18a614f4be16862d9cb51be313438050a3ce6e3356a2
+  data.tar.gz: efbd8b062eccd5d5441aa8e9fe6162bce076e188761f5c7877f9ca454899fc13873fa6cdf4db21cd2154e24c824487f56a085f41402432bd99486e17213e7f00

data/lib/brick/config.rb

@@ -399,6 +399,14 @@ module Brick
       @mutex.synchronize { @not_nullables = columns }
     end
 
+    def omit_empty_tables_in_dropdown
+      @mutex.synchronize { @omit_empty_tables_in_dropdown }
+    end
+
+    def omit_empty_tables_in_dropdown=(field_set)
+      @mutex.synchronize { @omit_empty_tables_in_dropdown = field_set }
+    end
+
     def always_load_fields
       @mutex.synchronize { @always_load_fields || {} }
     end

data/lib/brick/extensions.rb

@@ -82,8 +82,10 @@ module ActiveRecord
 
       def json_column?(col)
         col.type == :json || ::Brick.config.json_columns[table_name]&.include?(col.name) ||
-        (respond_to?(:attribute_types) && (attr_types = attribute_types[col.name]).respond_to?(:coder) &&
-         (attr_types.coder.is_a?(Class) ? attr_types.coder : attr_types.coder&.class)&.name&.end_with?('JSON'))
+        (
+          respond_to?(:attribute_types) && (attr_types = attribute_types[col.name]).respond_to?(:coder) &&
+          (attr_types.coder.is_a?(Class) ? attr_types.coder : attr_types.coder&.class)&.name&.end_with?('JSON')
+        )
       end
 
       def brick_foreign_type(assoc)
@@ -284,7 +286,10 @@ module ActiveRecord
                         end
                         this_obj&.to_s || ''
                       end
-              is_brackets_have_content = true unless datum.blank?
+              begin
+                is_brackets_have_content = true unless datum.blank?
+              rescue
+              end
               output << (datum || '')
               bracket_name = nil
             else
@@ -329,27 +334,10 @@ module ActiveRecord
     end
 
     # Providing a relation object allows auto-modules built from table name prefixes to work
-    def self._brick_index(mode = nil, separator = '_', relation = nil)
+    def self._brick_index(mode = nil, separator = nil, relation = nil)
       return if abstract_class?
 
-      tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
-      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
-      if (aps = relation&.fetch(:auto_prefixed_schema, nil)) && tbl_parts.last.start_with?(aps)
-        last_part = tbl_parts.last[aps.length..-1]
-        aps = aps[0..-2] if aps[-1] == '_'
-        tbl_parts[-1] = aps
-        tbl_parts << last_part
-      end
-      path_prefix = []
-      if ::Brick.config.path_prefix
-        tbl_parts.unshift(::Brick.config.path_prefix)
-        path_prefix << ::Brick.config.path_prefix
-      end
-      index = tbl_parts.map(&:underscore).join(separator)
-      # Rails applies an _index suffix to that route when the resource name isn't something plural
-      index << '_index' if mode != :singular && separator == '_' &&
-                           index == (path_prefix + [name&.underscore&.tr('/', '_') || '_']).join(separator)
-      index
+      ::Brick._brick_index(table_name, mode, separator, relation)
     end
 
     def self.brick_import_template
@@ -686,7 +674,7 @@ module ActiveRecord
       (cust_col_override || klass._br_cust_cols).each do |k, cc|
         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)
+          # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", nil, bts, hms)
           # binding.pry
           next
         end
@@ -806,6 +794,7 @@ module ActiveRecord
 
       # Add derived table JOIN for the has_many counts
       nix = []
+      previous = []
       klass._br_hm_counts.each do |k, hm|
         count_column = if hm.options[:through]
                          # Build the chain of JOINs going to the final destination HMT table
@@ -832,7 +821,7 @@ module ActiveRecord
                            through_sources.push(this_hm = src_ref.active_record.reflect_on_association(thr))
                          end
                          through_sources.push(src_ref) unless src_ref.belongs_to?
-                         from_clause = +"#{through_sources.first.table_name} br_t0"
+                         from_clause = +"#{_br_quoted_name(through_sources.first.table_name)} br_t0"
                          fk_col = through_sources.shift.foreign_key
 
                          idx = 0
@@ -900,7 +889,7 @@ module ActiveRecord
           next
         end
 
-        tbl_alias = "b_r_#{hm.name}"
+        tbl_alias = unique63("b_r_#{hm.name}", previous)
         on_clause = []
         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.table_name}.#{pri_key[idx]}" }
@@ -1105,6 +1094,19 @@ Might want to add this in your brick.rb:
     def shift_or_first(ary)
       ary.length > 1 ? ary.shift : ary.first
     end
+
+    def unique63(name, previous)
+      name = name[0..62] if name.length > 63
+      unique_num = 1
+      loop do
+        break unless previous.include?(name)
+
+        unique_suffix = "_#{unique_num += 1}"
+        name = "#{name[0..name.length - unique_suffix.length - 1]}#{unique_suffix}"
+      end
+      previous << name
+      name
+    end
   end
 
   module Inheritance
@@ -1360,7 +1362,7 @@ end
                    end
                  rescue NameError # If the const_get for the model has failed...
                    skip_controller = true
-                   # ... then just fall through and allow it to fail when trying to loading the ____Controller class normally.
+                   # ... then just fall through and allow it to fail when trying to load the ____Controller class normally.
                  end
                end
                unless skip_controller
@@ -1715,7 +1717,8 @@ class Object
               # options[:class_name] = hm.first[:inverse_table].singularize.camelize
               # options[:foreign_key] = hm.first[:fk].to_sym
               far_assoc = relations[hm.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == hm[1] }
-              options[:class_name] = ::Brick.namify(far_assoc.last[:inverse_table], :underscore).camelize
+              # Was:  ::Brick.namify(far_assoc.last[:inverse_table], :underscore).camelize
+              options[:class_name] = relations[far_assoc.last[:inverse_table]][:class_name]
               options[:foreign_key] = far_assoc.last[:fk].to_sym
             end
             options[:source] ||= hm[1].to_sym unless hmt_name.singularize == hm[1]
@@ -1744,7 +1747,7 @@ class Object
                 options[:optional] = true if assoc.key?(:optional)
                 if assoc.key?(:polymorphic) ||
                    # If a polymorphic association is missing but could be established then go ahead and put it into place.
-                   relations[assoc[:inverse_table]][:class_name].constantize.reflect_on_all_associations.find { |inv_assoc| !inv_assoc.belongs_to? && inv_assoc.options[:as].to_s == assoc[:assoc_name] }
+                   relations.fetch(assoc[:inverse_table], nil)&.fetch(:class_name, nil)&.constantize&.reflect_on_all_associations&.find { |inv_assoc| !inv_assoc.belongs_to? && inv_assoc.options[:as].to_s == assoc[:assoc_name] }
                   assoc[:polymorphic] ||= true
                   options[:polymorphic] = true
                 else
@@ -1802,9 +1805,9 @@ class Object
          ::Brick.config.schema_behavior[:multitenant] && singular_table_parts.first == 'public'
         singular_table_parts.shift
       end
-      options[:class_name] = "::#{assoc[:primary_class]&.name ||
-                                  singular_table_parts.map { |p| ::Brick.namify(p, :underscore).camelize}.join('::')
-                                 }" if need_class_name
+      if need_class_name
+        options[:class_name] = "::#{assoc[:primary_class]&.name || ::Brick.relations[inverse_table][:class_name]}"
+      end
       if need_fk # Funky foreign key?
         options_fk_key = :foreign_key
         if assoc[:fk].is_a?(Array)
@@ -2559,6 +2562,8 @@ class Object
                                     assoc_name = assoc_parts.join('.')
                                   else
                                     class_name_parts = ::Brick.namify(hm_assoc[:inverse_table], :underscore).split('.')
+                                    last_idx = class_name_parts.length - 1
+                                    class_name_parts[last_idx] = class_name_parts[last_idx].singularize
                                     real_name = class_name_parts.map(&:camelize).join('::')
                                     needs_class = (real_name != hm_assoc[:inverse_table].camelize)
                                   end
@@ -2645,6 +2650,10 @@ end.class_exec do
     orig_schema = nil
     if (relations = ::Brick.relations).keys == [:db_name]
       ::Brick.remove_instance_variable(:@_additional_references_loaded) if ::Brick.instance_variable_defined?(:@_additional_references_loaded)
+
+      # --------------------------------------------
+      # 1. Load three initializers early
+      #    (inflectsions.rb, brick.rb, apartment.rb)
       # Very first thing, load inflections since we'll be using .pluralize and .singularize on table and model names
       if File.exist?(inflections = ::Rails.root&.join('config/initializers/inflections.rb') || '')
         load inflections
@@ -2695,6 +2704,8 @@ end.class_exec do
       # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
+      # ---------------------------
+      # 2. Figure out schema things
       is_postgres = nil
       is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
       case ActiveRecord::Base.connection.adapter_name
@@ -2767,6 +2778,8 @@ end.class_exec do
 
       ::Brick.db_schemas ||= {}
 
+      # ---------------------
+      # 3. Tables and columns
       # %%% 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
@@ -2896,20 +2909,34 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       #   end
       # end
       # schema = ::Brick.default_schema # Reset back for this next round of fun
+
+      # ---------------------------------------------
+      # 4. Foreign key info
+      # (done in two parts which get JOINed together in Ruby code)
       kcus = nil
+      entry_type = nil
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2', 'Trilogy', 'SQLServer'
-        # All KCUs -- use this to virtually JOIN against fk_references in Ruby code
+        # Part 1 -- all KCUs
         sql = "SELECT CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME, ORDINAL_POSITION,
                       TABLE_NAME, COLUMN_NAME
               FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE#{"
-              WHERE CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
+              WHERE CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }#{"
+              WHERE CONSTRAINT_SCHEMA = '#{ActiveRecord::Base.connection.current_database&.tr("'", "''")}'" if is_mysql
+              }"
         kcus = ActiveRecord::Base.execute_sql(sql).each_with_object({}) do |v, s|
-                 key = "#{v['constraint_name']}.#{v['constraint_schema']}.#{v['constraint_catalog']}.#{v['ordinal_position']}"
-                 key << ".#{v['table_name']}.#{v['column_name']}" unless is_postgres || is_mssql
-                 s[key] = [v['constraint_schema'], v['table_name']]
+                 if (entry_type ||= v.is_a?(Array) ? :array : :hash) == :hash
+                   key = "#{v['constraint_name']}.#{v['constraint_schema']}.#{v['constraint_catalog']}.#{v['ordinal_position']}"
+                   key << ".#{v['table_name']}.#{v['column_name']}" unless is_postgres || is_mssql
+                   s[key] = [v['constraint_schema'], v['table_name']]
+                 else # Array
+                   key = "#{v[2]}.#{v[1]}.#{v[0]}.#{v[3]}"
+                   key << ".#{v[4]}.#{v[5]}" unless is_postgres || is_mssql
+                   s[key] = [v[1], v[4]]
+                 end
                end
 
+        # Part 2 -- fk_references
         sql = "SELECT kcu.CONSTRAINT_SCHEMA, kcu.TABLE_NAME, kcu.COLUMN_NAME,
             #{# These will get filled in with real values (effectively doing the JOIN in Ruby)
               is_postgres || is_mssql ? 'NULL as primary_schema, NULL as primary_table' :
@@ -2921,7 +2948,8 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
               ON kcu.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
               AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
               AND kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME#{"
-          WHERE kcu.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
+          WHERE kcu.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema}#{"
+          WHERE kcu.CONSTRAINT_SCHEMA = '#{ActiveRecord::Base.connection.current_database&.tr("'", "''")}'" if is_mysql}"
         fk_references = ActiveRecord::Base.execute_sql(sql)
       when 'SQLite'
         sql = "SELECT NULL AS constraint_schema, m.name, fkl.\"from\", NULL AS primary_schema, fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
@@ -2949,11 +2977,13 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       end
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-      ::Brick.default_schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      ::Brick.default_schema ||= 'public' if is_postgres
       fk_references&.each do |fk|
         fk = fk.values unless fk.is_a?(Array)
-        # Virtually JOIN against fk_references in order to change out the primary schema and primary table
-        if (kcu = kcus&.fetch("#{fk[6]}.#{fk[7]}.#{fk[8]}.#{fk[9]}", nil))
+        # Virtually JOIN KCUs to fk_references in order to fill in the primary schema and primary table
+        kcu_key = "#{fk[6]}.#{fk[7]}.#{fk[8]}.#{fk[9]}"
+        kcu_key << ".#{fk[3]}.#{fk[4]}" unless is_postgres || is_mssql
+        if (kcu = kcus&.fetch(kcu_key, nil))
           fk[3] = kcu[0]
           fk[4] = kcu[1]
         end
@@ -3000,18 +3030,86 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
                                     &.find { |k1, _v1| singular.start_with?(k1) && singular.length > k1.length }
                       ).present?
                      v[:auto_prefixed_schema] = tnp.first
-                     v[:resource] = rel_name.last[(tnp_length = tnp.first.length)..-1]
-                     [tnp.last, singular[tnp_length..-1]]
+                     # v[:resource] = rel_name.last[tnp.first.length..-1]
+                     [tnp.last, singular[tnp.first.length..-1]]
                    else
-                     v[:resource] = rel_name.last
+                     # v[:resource] = rel_name.last
                      [singular]
                    end
-      v[:class_name] = (schema_names + name_parts).map { |p| ::Brick.namify(p, :underscore).camelize }.join('::')
+      proposed_name_parts = (schema_names + name_parts).map { |p| ::Brick.namify(p, :underscore).camelize }
+      # Find out if the proposed name leads to a module or class that already exists and is not an AR class
+      colliding_thing = nil
+      loop do
+        klass = Object
+        proposed_name_parts.each do |part|
+          if klass.const_defined?(part)
+            klass = klass.const_get(part)
+          else
+            klass = nil
+            break
+          end
+        end
+        break if !klass || (klass < ActiveRecord::Base) # Break if all good -- no conflicts
+
+        # Find a unique name since there's already something that's non-AR with that same name
+        last_idx = proposed_name_parts.length - 1
+        proposed_name_parts[last_idx] = ::Brick.ensure_unique(proposed_name_parts[last_idx], 'X')
+        colliding_thing ||= klass
+      end
+      v[:class_name] = proposed_name_parts.join('::')
+      # Was:  v[:resource] = v[:class_name].underscore.tr('/', '.').pluralize
+      v[:resource] = proposed_name_parts.last.underscore.pluralize
+      if colliding_thing
+        message_start = if colliding_thing.is_a?(Module) && Object.const_defined?(:Rails) &&
+                           colliding_thing.constants.find { |c| colliding_thing.const_get(c) < Rails::Application }
+                          "The module for the Rails application itself, \"#{colliding_thing.name}\","
+                        else
+                          "Non-AR #{colliding_thing.class.name.downcase} \"#{colliding_thing.name}\""
+                        end
+        puts "WARNING:  #{message_start} already exists.\n  Will set up to auto-create model #{v[:class_name]} for table #{k}."
+      end
       # Track anything that's out-of-the-ordinary
       table_name_lookup[v[:class_name]] = k unless v[:class_name].underscore.pluralize == k
     end
     ::Brick.load_additional_references if ::Brick.initializer_loaded
 
+    if is_postgres
+      params = []
+      ActiveRecord::Base.execute_sql("-- inherited and partitioned tables counts
+      SELECT n.nspname, parent.relname,
+        ((SUM(child.reltuples::float) / greatest(SUM(child.relpages), 1))) *
+        (SUM(pg_relation_size(child.oid))::float / (current_setting('block_size')::float))::integer AS rowcount
+      FROM pg_inherits
+        INNER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
+        INNER JOIN pg_class child ON pg_inherits.inhrelid = child.oid
+        INNER JOIN pg_catalog.pg_namespace n ON n.oid = parent.relnamespace#{
+    if schema
+      params = params << schema
+      "
+      WHERE n.nspname = COALESCE(?, 'public')"
+    end}
+      GROUP BY n.nspname, parent.relname, child.reltuples, child.relpages, child.oid
+
+      UNION ALL
+
+      -- table count
+      SELECT n.nspname, pg_class.relname,
+        (pg_class.reltuples::float / greatest(pg_class.relpages, 1)) *
+          (pg_relation_size(pg_class.oid)::float / (current_setting('block_size')::float))::integer AS rowcount
+      FROM pg_class
+        INNER JOIN pg_catalog.pg_namespace n ON n.oid = pg_class.relnamespace#{
+    if schema
+      params = params << schema
+      "
+      WHERE n.nspname = COALESCE(?, 'public')"
+    end}
+      GROUP BY n.nspname, pg_class.relname, pg_class.reltuples, pg_class.relpages, pg_class.oid", params).each do |tblcount|
+        # %%% What is the default schema here?
+        prefix = "#{tblcount['nspname']}." unless tblcount['nspname'] == (schema || 'public')
+        relations.fetch("#{prefix}#{tblcount['relname']}", nil)&.[]=(:rowcount, tblcount['rowcount'].to_i.round)
+      end
+    end
+
     if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first)
       puts "Now switching back to \"#{orig_schema}\" schema."
       ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", orig_schema)
@@ -3151,7 +3249,7 @@ module Brick
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
         pri_tbl = is_class ? fk[4][:class].underscore : pri_tbl
         pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl&.singularize != bt_assoc_name
-        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", nil, bts, hms)
         missing = []
         missing << fk[1] unless relations.key?(fk[1])
         missing << primary_table unless is_class || relations.key?(primary_table)
@@ -3285,15 +3383,17 @@ module Brick
       end
     end
 
-    def ensure_unique(name, *sources)
+    def ensure_unique(name, delimiter, *sources)
       base = name
-      if (added_num = name.slice!(/_(\d+)$/))
+      delimiter ||= '_'
+      # By default ends up building this regex:  /_(\d+)$/
+      if (added_num = name.slice!(Regexp.new("#{delimiter}(\d+)$")))
         added_num = added_num[1..-1].to_i
       else
         added_num = 1
       end
       while (
-        name = "#{base}_#{added_num += 1}"
+        name = "#{base}#{delimiter}#{added_num += 1}"
         sources.each_with_object(nil) do |v, s|
           s || case v
                when Hash
@@ -3371,6 +3471,33 @@ module Brick
       end
     end
 
+    def _brick_index(tbl_name, mode = nil, separator = nil, relation = nil)
+      separator ||= '_'
+      res_name = (tbl_name_parts = tbl_name.split('.'))[0..-2].first
+      res_name << '.' if res_name
+      (res_name ||= +'') << (relation || ::Brick.relations.fetch(tbl_name, nil))&.fetch(:resource, nil) || tbl_name_parts.last
+
+      res_parts = ((mode == :singular) ? res_name.singularize : res_name).split('.')
+      res_parts.shift if ::Brick.apartment_multitenant && res_parts.length > 1 && res_parts.first == ::Brick.apartment_default_tenant
+      if (aps = relation&.fetch(:auto_prefixed_schema, nil)) && res_parts.last.start_with?(aps)
+        last_part = res_parts.last[aps.length..-1]
+        aps = aps[0..-2] if aps[-1] == '_'
+        res_parts[-1] = aps
+        res_parts << last_part
+      end
+      path_prefix = []
+      if ::Brick.config.path_prefix
+        res_parts.unshift(::Brick.config.path_prefix)
+        path_prefix << ::Brick.config.path_prefix
+      end
+      index = res_parts.map(&:underscore).join(separator)
+      index = index.tr('_', 'x') if separator == 'x'
+      # Rails applies an _index suffix to that route when the resource name isn't something plural
+      index << '_index' if mode != :singular && separator == '_' &&
+                           index == (path_prefix + [name&.underscore&.tr('/', '_') || '_']).join(separator)
+      index
+    end
+
     def find_col_renaming(api_ver_path, relation_name)
       ::Brick.config.api_column_renaming&.fetch(
         api_ver_path,

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

@@ -345,7 +345,8 @@ function linkSchemas() {
                                end
                     ::Brick.relations.each do |k, v|
                       unless k.is_a?(Symbol) || existing.key?(class_name = v[:class_name]) || Brick.config.exclude_tables.include?(k) ||
-                             class_name.blank? || class_name.include?('::')
+                             class_name.blank? || class_name.include?('::') ||
+                             ['ActiveAdminComment', 'MotorAlert', 'MotorAlertLock', 'MotorApiConfig', 'MotorAudit', 'MotorConfig', 'MotorDashboard', 'MotorForm', 'MotorNote', 'MotorNoteTag', 'MotorNoteTagTag', 'MotorNotification', 'MotorQuery', 'MotorReminder', 'MotorResource', 'MotorTag', 'MotorTaggableTag'].include?(class_name)
                         Object.const_get("#{class_name}Resource")
                       end
                     end
@@ -774,9 +775,18 @@ window.addEventListener(\"popstate\", linkSchemas);
               end
               # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
               # environment or whatever, then get either the controllers or routes list instead
-              prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
-              table_options = ::Brick.relations.each_with_object({}) do |rel, s|
-                                next if rel.first.is_a?(Symbol) || ::Brick.config.exclude_tables.include?(rel.first)
+              table_rels = if ::Brick.config.omit_empty_tables_in_dropdown
+                             ::Brick.relations.reject { |k, v| k.is_a?(Symbol) || v[:rowcount] == 0 }
+                           else
+                             ::Brick.relations
+                           end
+              table_options = table_rels.sort do |a, b|
+                                a[0] = '' if a[0].is_a?(Symbol)
+                                b[0] = '' if b[0].is_a?(Symbol)
+                                a.first <=> b.first
+                              end.each_with_object(+'') do |rel, s|
+                                next if rel.first.blank? || rel.last[:cols].empty? ||
+                                        ::Brick.config.exclude_tables.include?(rel.first)
 
                                 tbl_parts = rel.first.split('.')
                                 if (aps = rel.last.fetch(:auto_prefixed_schema, nil))
@@ -784,16 +794,16 @@ window.addEventListener(\"popstate\", linkSchemas);
                                   aps = aps[0..-2] if aps[-1] == '_'
                                   tbl_parts[-2] = aps
                                 end
-                                if tbl_parts.first == apartment_default_schema
-                                  tbl_parts.shift
-                                end
+                                tbl_parts.shift if tbl_parts.first == apartment_default_schema
                                 # %%% When table_name_prefixes are use then during rendering empty non-TNP
                                 # entries get added at some point when an attempt is made to find the table.
                                 # Will have to hunt that down at some point.
-                                s[tbl_parts.join('.')] = nil unless rel.last[:cols].empty?
-                              end.keys.sort.each_with_object(+'') do |v, s|
-                                s << "<option value=\"#{prefix}#{v.underscore.gsub('.', '/')}\">#{v}</option>"
+                                if (rowcount = rel.last.fetch(:rowcount, nil))
+                                  rowcount = rowcount > 0 ? " (#{rowcount})" : nil
+                                end
+                                s << "<option value=\"#{::Brick._brick_index(rel.first, nil, '/')}\">#{rel.first}#{rowcount}</option>"
                               end.html_safe
+              prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
               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
               table_options << "<option value=\"#{prefix}brick_crosstab\">(Crosstab)</option>".html_safe if is_crosstab
@@ -1476,7 +1486,7 @@ end
   %>
   <tr>
   <td><%= begin
-            kls = Object.const_get(::Brick.relations.fetch(r[0], nil)&.fetch(:class_name, nil))
+            kls = Object.const_get((rel = ::Brick.relations.fetch(r[0], nil))&.fetch(:class_name, nil))
           rescue
           end
           if kls.is_a?(Class) && (path_helper = respond_to?(bi_path = \"#\{kls._brick_index}_path\".to_sym) ? bi_path : nil)
@@ -1489,7 +1499,10 @@ end
          else
            ' class=\"dimmed\"'
          end&.html_safe %>><%= # Table
-          r[1] %></td>
+         if (rowcount = rel&.fetch(:rowcount, nil))
+           rowcount = (rowcount > 0 ? \" (#\{rowcount})\" : nil)
+         end
+         \"#\{r[1]}#\{rowcount}\" %></td>
   <td<%= lines = r[2]&.map { |line| \"#\{line.first}:#\{line.last}\" }
          ' class=\"dimmed\"'.html_safe unless r[2] %>><%= # Migration
           lines&.join('<br>')&.html_safe %></td>
@@ -1571,7 +1584,13 @@ end %>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><td><h1><%= page_title %></h1></td>
-<% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) %>
+<% rel = Brick.relations[#{model_name}.table_name]
+   if (in_app = rel.fetch(:existing, nil)&.fetch(:show, nil))
+     in_app = send(\"#\{in_app}_path\", #{pk.is_a?(String) ? "obj.#{pk}" : '[' + pk.map { |pk_part| "obj.#{pk_part}" }.join(', ') + ']' }) if in_app.is_a?(Symbol) %>
+     <td><%= link_to(::Brick::Rails::IN_APP.html_safe, in_app) %></td>
+<% end
+
+   if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) %>
   <td><%= link_to_brick(
       ::Brick::Rails::AVO_SVG.html_safe,
       { show_proc: Proc.new do |obj, relation|
@@ -1596,7 +1615,7 @@ end %>#{"
    end %>
 </table>
 <%
-if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %>
+if (description = rel&.fetch(:description, nil)) %>
   <span class=\"__brick\"><%= description %></span><br><%
 end
 %><%= link_to \"(See all #\{model_name.pluralize})\", see_all_path, { class: '__brick' } %>
@@ -1927,6 +1946,7 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
         end
 
         if ::Brick.enable_routes?
+          require 'brick/route_mapper'
           ActionDispatch::Routing::RouteSet.class_exec do
             # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
             prepend ::Brick::RouteSet

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

@@ -148,7 +148,8 @@ module Brick::Rails::FormBuilder
       '(hidden)'
     else
       if val.is_a?(String)
-        val = val.dup.force_encoding('UTF-8').strip
+        return ::Brick::Rails.display_binary(val) unless (val_utf8 = val.dup.force_encoding('UTF-8')).valid_encoding?
+        val = val_utf8.strip
         return CGI.escapeHTML(val) if is_xml
   
         if val.length > max_len

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

@@ -2,7 +2,7 @@ module Brick::Rails::FormTags
   # Our super speedy grid
   def brick_grid(relation = nil, sequence = nil, inclusions = nil, exclusions = nil,
                  cols = {}, bt_descrip: nil, poly_cols: nil, bts: {}, hms_keys: [], hms_cols: {},
-                 show_header: nil, show_row_count: nil, show_erd_button: nil, show_new_button: nil, show_avo_button: nil, show_aa_button: nil)
+                 show_header: nil, show_row_count: nil, show_erd_button: nil, show_in_app_button: nil, show_new_button: nil, show_avo_button: nil, show_aa_button: nil)
     # When a relation is not provided, first see if one exists which matches the controller name
     unless (relation ||= instance_variable_get("@#{controller_name}".to_sym))
       # Failing that, dig through the instance variables with hopes to find something that is an ActiveRecord::Relation
@@ -33,6 +33,7 @@ module Brick::Rails::FormTags
     out = +"<div id=\"headerTopContainer\"><table id=\"headerTop\"></table>
 "
     klass = relation.klass
+    rel = ::Brick.relations&.fetch(relation.table_name, nil)
     unless show_header == false
       out << "  <div id=\"headerTopAddNew\">
     <div id=\"headerButtonBox\">
@@ -43,6 +44,11 @@ module Brick::Rails::FormTags
       end
       unless show_erd_button == false
         out << "      <div id=\"imgErd\" title=\"Show ERD\"></div>
+"
+      end
+      if rel && show_in_app_button != false && (in_app = rel.fetch(:existing, nil)&.fetch(:index, nil))
+        in_app = send("#{in_app}_path") if in_app.is_a?(Symbol)
+        out << "      <td title=\"Show in app\">#{link_to(::Brick::Rails::IN_APP.html_safe, in_app)}</td>
 "
       end
       if show_avo_button != false && Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) && klass.name.exclude?('::')
@@ -151,7 +157,7 @@ module Brick::Rails::FormTags
     #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
     #     TinyTds::Error: Adaptive Server connection timed out
     #     (After restarting the server it worked fine again.)
-    rowCount = 0
+    row_count = 0
     relation.each do |obj|
       out << "<tr>\n"
       out << "<td class=\"col-sticky\">#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym,
@@ -252,13 +258,16 @@ module Brick::Rails::FormTags
         out << '</td>'
       end
       out << '</tr>'
-      rowCount += 1
+      row_count += 1
+    end
+    if rel && (total_row_count = rel.fetch(:rowcount, nil))
+      total_row_count = total_row_count > row_count ? " (out of #{total_row_count})" : nil
     end
     out << "  </tbody>
 </table>
 <script>
   var rowCount = document.getElementById(\"rowCount\");
-  if (rowCount) rowCount.innerHTML = \"#{pluralize(rowCount, "row")} &nbsp;\";
+  if (rowCount) rowCount.innerHTML = \"#{pluralize(row_count, "row")}#{total_row_count} &nbsp;\";
 </script>
 "