brick 1.0.6 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 634669de2074746d62642b8c9108070b78e92b14f7924ac969404b240de2267d
-  data.tar.gz: 7614fa456fcaeb6bc68227230088fe3adeed31278241a000f3fb19792b763d26
+  metadata.gz: cfc0c2e81700a407de1fe154d337dd83d756a29fba0914db5eeb1974198720d2
+  data.tar.gz: 0051e6b4fe55d1e9f4cc4614aabd941a6947f66af5ac41f35725df594217fd2d
 SHA512:
-  metadata.gz: 3b89ed9c8ffe3c63e098a3f7a8e5a9987db0c00bfe2c917b7c2acefebc30653a4a88d091852b8f8e6128daa310e7c7742d10611acfb0ffe7d06cc6c01da7068e
-  data.tar.gz: 98d58b4461b9e85537da640e3940316553d142a341547086ce614f75d9366145c8818beb6e972ac93a77e7209b034eb64a64eb9a078f6afb91fbbd008e3ade69
+  metadata.gz: 445acf196541b17429bb7c5f93b64ebd51cc4c3b1fcc4cec7fcb43cca6e47ed86a027bc0010b3053a763414809a390509d9da9c296c4eab85bbd794a3553ba90
+  data.tar.gz: 110cd25429c21410effe398a61c4284876d49e222267987e0c5e0e09b5ab8e84bd4991fbd36257077f5178fa3fcba661970162e574744c2f8d2b80ec4a1e2d51

data/lib/brick/config.rb

@@ -65,13 +65,30 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
-    # Associations to treat has a has_one
+    # Skip creating a has_many association for these
+    def skip_hms
+      @mutex.synchronize { @skip_hms }
+    end
+
+    def skip_hms=(skips)
+      @mutex.synchronize { @skip_hms = skips }
+    end
+
+    # Associations to treat as a has_one
     def has_ones
       @mutex.synchronize { @has_ones }
     end
 
-    def has_ones=(references)
-      @mutex.synchronize { @has_ones = references }
+    def has_ones=(hos)
+      @mutex.synchronize { @has_ones = hos }
+    end
+
+    def model_descrips
+      @mutex.synchronize { @model_descrips }
+    end
+
+    def model_descrips=(descrips)
+      @mutex.synchronize { @model_descrips = descrips }
     end
 
     def skip_database_views
@@ -90,6 +107,14 @@ module Brick
       @mutex.synchronize { @exclude_tables = value }
     end
 
+    def table_name_prefixes
+      @mutex.synchronize { @table_name_prefixes }
+    end
+
+    def table_name_prefixes=(value)
+      @mutex.synchronize { @table_name_prefixes = value }
+    end
+
     def metadata_columns
       @mutex.synchronize { @metadata_columns }
     end

data/lib/brick/extensions.rb

@@ -46,7 +46,56 @@ module ActiveRecord
     # Used to show a little prettier name for an object
     def brick_descrip
       klass = self.class
-      klass.primary_key ? "#{klass.name} ##{send(klass.primary_key)}" : to_s
+      # If available, parse simple DSL attached to a model in order to provide a friendlier name.
+      # Object property names can be referenced in square brackets like this:
+      # { 'User' => '[profile.firstname] [profile.lastname]' }
+
+      # If there's no DSL yet specified, just try to find the first usable column on this model
+      unless ::Brick.config.model_descrips[klass.name]
+        descrip_col = (klass.columns.map(&:name) - klass._brick_get_fks -
+                      (::Brick.config.metadata_columns || []) -
+                      [klass.primary_key]).first
+        ::Brick.config.model_descrips[klass.name] = "[#{descrip_col}]" if descrip_col
+      end
+      if (dsl ||= ::Brick.config.model_descrips[klass.name])
+        caches = {}
+        output = +''
+        is_brackets_have_content = false
+        bracket_name = nil
+        dsl.each_char do |ch|
+          if bracket_name
+            if ch == ']' # Time to process a bracketed thing?
+              obj_name = +''
+              obj = self
+              bracket_name.split('.').each do |part|
+                obj_name += ".#{part}"
+                obj = if caches.key?(obj_name)
+                        caches[obj_name]
+                      else
+                        (caches[obj_name] = obj&.send(part.to_sym))
+                      end
+              end
+              is_brackets_have_content = true unless (obj&.to_s).blank?
+              output << (obj&.to_s || '')
+              bracket_name = nil
+            else
+              bracket_name << ch
+            end
+          elsif ch == '['
+            bracket_name = +''
+          else
+            output << ch
+          end
+        end
+        output += bracket_name if bracket_name
+      end
+      if is_brackets_have_content
+        output
+      elsif klass.primary_key
+        "#{klass.name} ##{send(klass.primary_key)}"
+      else
+        to_s
+      end
     end
 
   private
@@ -123,12 +172,13 @@ class Object
         # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
         plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
         singular_table_name = ActiveSupport::Inflector.underscore(model_name)
-        table_name = ActiveSupport::Inflector.pluralize(singular_table_name)
 
         # Adjust for STI if we know of a base model for the requested model name
-        if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
-          table_name = base_model.table_name
-        end
+        table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+                       base_model.table_name
+                     else
+                       ActiveSupport::Inflector.pluralize(singular_table_name)
+                     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?(m) })
@@ -155,7 +205,11 @@ class Object
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
         raise NameError.new("Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\".")
       end
-      base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ActiveRecord::Base
+      if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+        is_sti = true
+      else
+        base_model = ActiveRecord::Base
+      end
       code = +"class #{model_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
         Object.const_set(model_name.to_sym, new_model_class)
@@ -193,60 +247,93 @@ class Object
           code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
         end
 
-        fks = relation[:fks] || {}
-        fks.each do |_constraint_name, assoc|
-          assoc_name = assoc[:assoc_name]
-          inverse_assoc_name = assoc[:inverse][:assoc_name]
-          options = {}
-          singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
-          macro = if assoc[:is_bt]
-                    need_class_name = singular_table_name.underscore != assoc_name
-                    need_fk = "#{assoc_name}_id" != assoc[:fk]
-                    inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], assoc[:inverse])
-                    if (has_ones = ::Brick.config.has_ones.fetch(assoc[:inverse][:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
-                      inverse_assoc_name = if has_ones[singular_inv_assoc_name]
-                                             need_inverse_of = true
-                                             has_ones[singular_inv_assoc_name]
-                                           else
-                                             singular_inv_assoc_name
-                                           end
-                    end
-                    :belongs_to
-                  else
-                    # need_class_name = ActiveSupport::Inflector.singularize(assoc_name) == ActiveSupport::Inflector.singularize(table_name.underscore)
-                    # Are there multiple foreign keys out to the same table?
-                    assoc_name, need_class_name = _brick_get_hm_assoc_name(relation, assoc)
-                    need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
-                    # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
-                    if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
-                      assoc_name = if has_ones[singular_assoc_name]
-                                     need_class_name = true
-                                     has_ones[singular_assoc_name]
-                                   else
-                                     singular_assoc_name
-                                   end
-                      :has_one
+        unless is_sti
+          fks = relation[:fks] || {}
+          # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
+          hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
+            # The key in each hash entry (fk.first) is the constraint name
+            assoc_name = (assoc = fk.last)[:assoc_name]
+            inverse_assoc_name = assoc[:inverse]&.fetch(:assoc_name, nil)
+            options = {}
+            singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
+            macro = if assoc[:is_bt]
+                      need_class_name = singular_table_name.underscore != assoc_name
+                      need_fk = "#{assoc_name}_id" != assoc[:fk]
+                      if (inverse = assoc[:inverse])
+                        inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], inverse)
+                        if (has_ones = ::Brick.config.has_ones&.fetch(inverse[:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
+                          inverse_assoc_name = if has_ones[singular_inv_assoc_name]
+                                                need_inverse_of = true
+                                                has_ones[singular_inv_assoc_name]
+                                              else
+                                                singular_inv_assoc_name
+                                              end
+                        end
+                      end
+                      :belongs_to
                     else
-                      :has_many
+                      # need_class_name = ActiveSupport::Inflector.singularize(assoc_name) == ActiveSupport::Inflector.singularize(table_name.underscore)
+                      # Are there multiple foreign keys out to the same table?
+                      assoc_name, need_class_name = _brick_get_hm_assoc_name(relation, assoc)
+                      need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
+                      # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
+                      if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
+                        assoc_name = if has_ones[singular_assoc_name]
+                                      need_class_name = true
+                                      has_ones[singular_assoc_name]
+                                    else
+                                      singular_assoc_name
+                                    end
+                        :has_one
+                      else
+                        :has_many
+                      end
                     end
-                  end
-          # Figure out if we need to specially call out the class_name and/or foreign key
-          # (and if either of those then definitely also a specific inverse_of)
-          options[:class_name] = singular_table_name.camelize if need_class_name
-          options[:foreign_key] = assoc[:fk].to_sym if need_fk # Funky foreign key?
-          options[:inverse_of] = inverse_assoc_name.to_sym if need_class_name || need_fk || need_inverse_of
-          assoc_name = assoc_name.to_sym
-          code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
-          self.send(macro, assoc_name, **options)
-
-          # Look for any valid "has_many :through"
-          if macro == :has_many
-            relations[assoc[:inverse_table]][:hmt_fks].each do |k, hmt_fk|
-              next if k == assoc[:fk]
-
-              hmt_fk = ActiveSupport::Inflector.pluralize(hmt_fk)
-              code << "  has_many :#{hmt_fk}, through: #{assoc_name.inspect}\n"
-              self.send(:has_many, hmt_fk.to_sym, **{ through: assoc_name })
+            # Figure out if we need to specially call out the class_name and/or foreign key
+            # (and if either of those then definitely also a specific inverse_of)
+            options[:class_name] = singular_table_name.camelize if need_class_name
+            # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
+            if need_fk # Funky foreign key?
+              options[:foreign_key] = if assoc[:fk].is_a?(Array)
+                                        assoc_fk = assoc[:fk].uniq
+                                        assoc_fk.length < 2 ? assoc_fk.first : assoc_fk
+                                      else
+                                        assoc[:fk].to_sym
+                                      end
+            end
+            options[:inverse_of] = inverse_assoc_name.to_sym if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of)
+
+            # Prepare a list of entries for "has_many :through"
+            if macro == :has_many
+              relations[assoc[:inverse_table]][:hmt_fks].each do |k, hmt_fk|
+                next if k == assoc[:fk]
+
+                hmts[ActiveSupport::Inflector.pluralize(hmt_fk.last)] << [assoc, hmt_fk.first]
+              end
+            end
+
+            # And finally create a has_one, has_many, or belongs_to for this association
+            assoc_name = assoc_name.to_sym
+            code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
+            self.send(macro, assoc_name, **options)
+            hmts
+          end
+          hmts.each do |hmt_fk, fks|
+            fks.each do |fk|
+              source = nil
+              this_hmt_fk = if fks.length > 1
+                              singular_assoc_name = ActiveSupport::Inflector.singularize(fk.first[:inverse][:assoc_name])
+                              source = fk.last
+                              through = ActiveSupport::Inflector.pluralize(fk.first[:alternate_name])
+                              "#{singular_assoc_name}_#{hmt_fk}"
+                            else
+                              through = fk.first[:assoc_name]
+                              hmt_fk
+                            end
+              code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
+              options = { through: assoc_name }
+              options[:source] = source.to_sym if source
+              self.send(:has_many, this_hmt_fk.to_sym, **options)
             end
           end
         end
@@ -268,6 +355,7 @@ class Object
         code << "    @#{table_name}.brick_where(params)\n"
         code << "  end\n"
         self.define_method :index do
+          ::Brick.set_db_schema(params)
           ar_relation = model.primary_key ? model.order(model.primary_key) : model.all
           instance_variable_set(:@_brick_params, ar_relation.brick_where(params))
           instance_variable_set("@#{table_name}".to_sym, ar_relation)
@@ -278,6 +366,7 @@ class Object
           code << "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n"
           code << "  end\n"
           self.define_method :show do
+            ::Brick.set_db_schema(params)
             instance_variable_set("@#{singular_table_name}".to_sym, model.find(params[:id].split(',')))
           end
         end
@@ -293,7 +382,8 @@ class Object
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
-      if relation[:hm_counts][hm_assoc[:assoc_name]] > 1
+      binding.pry if hm_assoc.nil?
+      if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
         [ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name]), true]
       else
         [ActiveSupport::Inflector.pluralize(hm_assoc[:inverse_table]), nil]
@@ -319,9 +409,11 @@ module ActiveRecord::ConnectionHandling
       # Only for Postgres?  (Doesn't work in sqlite3)
       # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
-      case ActiveRecord::Base.connection.adapter_name
+    schema_sql = 'SELECT NULL AS table_schema;'
+    case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
         schema = 'public'
+        schema_sql = 'SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;'
       when 'Mysql2'
         schema = ActiveRecord::Base.connection.current_database
       when 'SQLite'
@@ -429,6 +521,10 @@ module ActiveRecord::ConnectionHandling
       else
       end
       if sql
+        ::Brick.db_schemas = ActiveRecord::Base.connection.execute(schema_sql)
+        ::Brick.db_schemas = ::Brick.db_schemas.to_a unless ::Brick.db_schemas.is_a?(Array)
+        ::Brick.db_schemas.map! { |row| row['table_schema'] } unless ::Brick.db_schemas.empty? || ::Brick.db_schemas.first.is_a?(String)
+        ::Brick.db_schemas -= ['information_schema', 'pg_catalog']
         ActiveRecord::Base.connection.execute(sql).each do |fk|
           fk = fk.values unless fk.is_a?(Array)
           ::Brick._add_bt_and_hm(fk, relations)
@@ -469,65 +565,69 @@ module Brick
   end # module Extensions
   # rubocop:enable Style/CommentedKeyword
 
-  def self._add_bt_and_hm(fk, relations = nil)
-    relations ||= ::Brick.relations
-    bt_assoc_name = fk[1].underscore
-    bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
-
-    bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
-    hms = (relation = relations.fetch(fk[2], nil))&.fetch(:fks) { relation[:fks] = {} }
-
-    unless (cnstr_name = fk[3])
-      # For any appended references (those that come from config), arrive upon a definitely unique constraint name
-      cnstr_base = cnstr_name = "(brick) #{fk[0]}_#{fk[2]}"
-      cnstr_added_num = 1
-      cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
-      missing = []
-      missing << fk[0] unless relations.key?(fk[0])
-      missing << fk[2] unless relations.key?(fk[2])
-      unless missing.empty?
-        tables = relations.reject { |k, v| v.fetch(:isView, nil) }.keys.sort
-        puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
-        return
+  class << self
+    def _add_bt_and_hm(fk, relations = nil)
+      relations ||= ::Brick.relations
+      bt_assoc_name = fk[1].underscore
+      bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
+
+      bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
+      hms = (relation = relations.fetch(fk[2], nil))&.fetch(:fks) { relation[:fks] = {} }
+
+      unless (cnstr_name = fk[3])
+        # For any appended references (those that come from config), arrive upon a definitely unique constraint name
+        cnstr_base = cnstr_name = "(brick) #{fk[0]}_#{fk[2]}"
+        cnstr_added_num = 1
+        cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
+        missing = []
+        missing << fk[0] unless relations.key?(fk[0])
+        missing << fk[2] unless relations.key?(fk[2])
+        unless missing.empty?
+          tables = relations.reject { |k, v| v.fetch(:isView, nil) }.keys.sort
+          puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
+          return
+        end
+        unless (cols = relations[fk[0]][:cols]).key?(fk[1])
+          columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
+          puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
+          return
+        end
+        if (redundant = bts.find { |k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == fk[2] })
+          puts "Brick: Additional reference #{fk.inspect} is redundant and can be removed.  (Already established by #{redundant.first}.)"
+          return
+        end
       end
-      unless (cols = relations[fk[0]][:cols]).key?(fk[1])
-        columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
-        puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
-        return
+      if (assoc_bt = bts[cnstr_name])
+        assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[1]] : assoc_bt[:fk].concat(fk[1])
+        assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
+      else
+        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: fk[2] }
       end
-      if (redundant = bts.find{|k, v| v[:inverse][:inverse_table] == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == fk[2] })
-        puts "Brick: Additional reference #{fk.inspect} is redundant and can be removed.  (Already established by #{redundant.first}.)"
-        return
+
+      unless ::Brick.config.skip_hms&.any? { |skip| fk[0] == skip[0] && fk[1] == skip[1] && fk[2] == skip[2] }
+        cnstr_name = "hm_#{cnstr_name}"
+        if (assoc_hm = hms.fetch(cnstr_name, nil))
+          assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
+          assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
+          assoc_hm[:inverse] = assoc_bt
+        else
+          assoc_hm = hms[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+          hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
+          hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
+        end
+        assoc_bt[:inverse] = assoc_hm
       end
+      # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
     end
 
-    if (assoc_bt = bts[cnstr_name])
-      assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[1]] : assoc_bt[:fk].concat(fk[1])
-      assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
-    else
-      assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: fk[2] }
+    # Rails < 4.0 doesn't have ActiveRecord::RecordNotUnique, so use the more generic ActiveRecord::ActiveRecordError instead
+    ar_not_unique_error = ActiveRecord.const_defined?('RecordNotUnique') ? ActiveRecord::RecordNotUnique : ActiveRecord::ActiveRecordError
+    class NoUniqueColumnError < ar_not_unique_error
     end
 
-    if (assoc_hm = hms[cnstr_name])
-      assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
-      assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
-      assoc_hm[:inverse] = assoc_bt
-    else
-      assoc_hm = hms[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
-      hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-      hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
+    # Rails < 4.2 doesn't have ActiveRecord::RecordInvalid, so use the more generic ActiveRecord::ActiveRecordError instead
+    ar_invalid_error = ActiveRecord.const_defined?('RecordInvalid') ? ActiveRecord::RecordInvalid : ActiveRecord::ActiveRecordError
+    class LessThanHalfAreMatchingColumnsError < ar_invalid_error
     end
-    assoc_bt[:inverse] = assoc_hm
-    # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
-  end
-
-  # Rails < 4.0 doesn't have ActiveRecord::RecordNotUnique, so use the more generic ActiveRecord::ActiveRecordError instead
-  ar_not_unique_error = ActiveRecord.const_defined?('RecordNotUnique') ? ActiveRecord::RecordNotUnique : ActiveRecord::ActiveRecordError
-  class NoUniqueColumnError < ar_not_unique_error
-  end
-
-  # Rails < 4.2 doesn't have ActiveRecord::RecordInvalid, so use the more generic ActiveRecord::ActiveRecordError instead
-  ar_invalid_error = ActiveRecord.const_defined?('RecordInvalid') ? ActiveRecord::RecordInvalid : ActiveRecord::ActiveRecordError
-  class LessThanHalfAreMatchingColumnsError < ar_invalid_error
   end
 end

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

@@ -16,12 +16,18 @@ module Brick
         # Specific database tables and views to omit when auto-creating models
         ::Brick.exclude_tables = app.config.brick.fetch(:exclude_tables, [])
 
+        # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
+        ::Brick.table_name_prefixes = app.config.brick.fetch(:table_name_prefixes, [])
+
         # Columns to treat as being metadata for purposes of identifying associative tables for has_many :through
         ::Brick.metadata_columns = app.config.brick.fetch(:metadata_columns, ['created_at', 'updated_at', 'deleted_at'])
 
         # Additional references (virtual foreign keys)
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
+        # Skip creating a has_many association for these
+        ::Brick.skip_hms = app.config.brick.fetch(:skip_hms, nil)
+
         # Has one relationships
         ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
       end
@@ -62,78 +68,148 @@ module Brick
                 # This gets has_many as well as has_many :through
                 # %%% weed out ones that don't have an available model to reference
                 bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
-                # Weed out has_manys that go to an associative table
-                associatives = hms.select { |k, v| v.options[:through] }.each_with_object({}) do |hmt, s|
-                  s[hmt.first] = hms.delete(hmt.last.options[:through]) # End up with a hash of HMT names pointing to join-table associations
-                end
-                hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>H#{hm.last.macro == :has_one ? 'O' : 'M'}#{'T' if hm.last.options[:through]} #{hm.first}</th>\n" }
-                hms_columns = hms.each_with_object(+'') do |hm, s|
-                  hm_fk_name = if hm.last.options[:through]
-                    associative = associatives[hm.last.name]
-                    "'#{associative.name}.#{associative.foreign_key}'"
-                  else
-                    hm.last.foreign_key
+                # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
+                # as well as any possible polymorphic associations
+                skip_hms = {}
+                associatives = hms.each_with_object({}) do |hmt, s|
+                  if (through = hmt.last.options[:through])
+                    skip_hms[through] = nil
+                    s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
+                  elsif hmt.last.inverse_of.nil?
+                    puts "SKIPPING #{hmt.last.name.inspect}"
+                    # %%% If we don't do this then below associative.name will find that associative is nil
+                    skip_hms[hmt.last.name] = nil
                   end
-                  s << if hm.last.macro == :has_many
+                end
+
+                schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
+                hms_columns = +'' # Used for 'index'
+                # puts skip_hms.inspect
+                hms_headers = hms.each_with_object([]) do |hm, s|
+                  next if skip_hms.key?(hm.last.name)
+
+                  if args.first == 'index'
+                    hm_fk_name = if hm.last.options[:through]
+                                   associative = associatives[hm.last.name]
+                                   "'#{associative.name}.#{associative.foreign_key}'"
+                                 else
+                                   hm.last.foreign_key
+                                 end
+                    hms_columns << if hm.last.macro == :has_many
 "<td>
   <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
 </td>\n"
-                         else # has_one
+                                   else # has_one
 "<td>
   <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
 </td>\n"
-                       end
+                                   end
+                  end
+                  s << [hm.last, "H#{hm.last.macro == :has_one ? 'O' : 'M'}#{'T' if hm.last.options[:through]} #{hm.first}"]
                 end
 
+                css = "<style>
+table {
+  border-collapse: collapse;
+  margin: 25px 0;
+  font-size: 0.9em;
+  font-family: sans-serif;
+  min-width: 400px;
+  box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+}
+
+table thead tr th, table tr th {
+  background-color: #009879;
+  color: #ffffff;
+  text-align: left;
+}
+
+table th, table td {
+  padding: 0.2em 0.5em;
+}
+
+.show-field {
+  background-color: #004998;
+}
+
+table tbody tr {
+  border-bottom: thin solid #dddddd;
+}
+
+table tbody tr:nth-of-type(even) {
+  background-color: #f3f3f3;
+}
+
+table tbody tr:last-of-type {
+  border-bottom: 2px solid #009879;
+}
+
+table tbody tr.active-row {
+  font-weight: bold;
+  color: #009879;
+}
+
+a.show-arrow {
+  font-size: 2.5em;
+  text-decoration: none;
+}
+</style>"
+
+                script = "<script>
+var schemaSelect = document.getElementById(\"schema\");
+if (schemaSelect) {
+  var brickSchema = changeout(location.href, \"_brick_schema\");
+  if (brickSchema) {
+    [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
+  }
+  schemaSelect.value = brickSchema || \"public\";
+  schemaSelect.focus();
+  schemaSelect.addEventListener(\"change\", function () {
+    location.href = changeout(location.href, \"_brick_schema\", this.value);
+  });
+}
+function changeout(href, param, value) {
+  var hrefParts = href.split(\"?\");
+  var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
+  params = params.reduce(function (s, v) { var parts = v.split(\"=\"); s[parts[0]] = parts[1]; return s; }, {});
+  if (value === undefined) return params[param];
+  params[param] = value;
+  return hrefParts[0] + \"?\" + Object.keys(params).reduce(function (s, v) { s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
+}
+</script>"
+
                 inline = case args.first
                 when 'index'
-                  "<p style=\"color: green\"><%= notice %></p>
-
+"#{css}
+<p style=\"color: green\"><%= notice %></p>#{"
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
 <h1>#{model_name.pluralize}</h1>
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
-
 <table id=\"#{table_name}\">
-  <tr>
-  <% is_first = true; is_need_id_col = nil
-     bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
+  <thead><tr>#{"<th></th>" if pk }
+  <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
      @#{table_name}.columns.map(&:name).each do |col| %>
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
-    <% if bt = bts[col]
-        if is_first
-          is_first = false
-          is_need_id_col = true %>
-          </th><th>
-        <% end %>
+    <% if (bt = bts[col]) %>
       BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
-    <% else
-        is_first = false %>
+    <% else %>
       <%= col %>
     <% end %>
     </th>
   <% end %>
-  <% if is_first # STILL haven't been able to write a first non-key / non-metadata column?
-    is_first = false
-    is_need_id_col = true %>
-    <th></th>
-  <% end %>
-#{hms_headers}
-  </tr>
+  #{hms_headers.map { |h| "<th>#{h.last}</th>\n" }.join}
+  </tr></thead>
 
+  <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
-  <tr>
-    <% is_first = true
-       if is_need_id_col
-         is_first = false %>
-      <td><%= link_to \"#\{#{obj_name}.class.name\} ##\{#{obj_name}.id\}\", #{obj_name} %></td>
-    <% end %>
+  <tr>#{"
+    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'show-arrow' } %></td>" if pk }
     <% #{obj_name}.attributes.each do |k, val| %>
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%= obj = bt[1].find_by(bt.last => val); link_to(obj.brick_descrip, obj) if obj %>
-      <% elsif is_first %>
-        <%= is_first = false; link_to val, #{obj_name}_path(#{obj_name}.#{pk}) %>
+        <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, bt_obj) if bt_obj %>
       <% else %>
         <%= val %>
       <% end %>
@@ -142,13 +218,55 @@ module Brick
 #{hms_columns}
     <!-- td>X</td -->
   </tr>
+  </tbody>
   <% end %>
 </table>
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
-"
+#{script}"
                 when 'show'
-                  "<%= @#{@_brick_model.name.underscore}.inspect %>"
+  "#{css}
+    <p style=\"color: green\"><%= notice %></p>#{"
+    <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+    <h1>#{model_name}: <%= (obj = @#{obj_name}.first).brick_descrip %></h1>
+    <%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
+  <table>
+  <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
+      @#{obj_name}.first.attributes.each do |k, val| %>
+    <tr>
+    <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+    <th class=\"show-field\">
+    <% if (bt = bts[k]) %>
+      BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
+    <% else %>
+      <%= k %>
+    <% end %>
+    </th>
+    <td>
+    <% if (bt = bts[k]) %>
+      <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, bt_obj) if bt_obj %>
+    <% else %>
+      <%= val %>
+    <% end %>
+    </td>
+    </tr>
+  <% end %>
+  </table>
+
+  #{hms_headers.map do |hm|
+    next unless (pk = hm.first.klass.primary_key)
+  "<table id=\"#{hm_name = hm.first.name.to_s}\">
+    <tr><th>#{hm.last}</th></tr>
+    <% if (collection = @#{obj_name}.first.#{hm_name}).empty? %>
+      <tr><td>(none)</td></tr>
+    <% else %>
+      <% collection.order(#{pk.inspect}).uniq.each do |#{hm_singular_name = hm_name.singularize}| %>
+        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm_singular_name}_path(#{hm_singular_name}.#{pk})) %></td></tr>
+      <% end %>
+    <% end %>
+  </table>" end.join}
+#{script}"
+
                 end
                 # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
                 keys = options.has_key?(:locals) ? options[:locals].keys : []
@@ -194,7 +312,7 @@ module Brick
         # Find associative tables that can be set up for has_many :through
         ::Brick.relations.each do |_key, tbl|
           tbl_cols = tbl[:cols].keys
-          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = fk.last[:inverse_table] if fk.last[:is_bt]; s }
+          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
           # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
           # foreign keys then it can act as an associative table and thus be used with has_many :through.
           if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -86,6 +86,13 @@ module Brick
   end
 
   class << self
+    attr_accessor :db_schemas
+
+    def set_db_schema(params)
+      schema = params['_brick_schema'] || 'public'
+      ActiveRecord::Base.connection.execute("SET SEARCH_PATH='#{schema}';") if schema && ::Brick.db_schemas&.include?(schema)
+    end
+
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
     def relations
       connections = Brick.instance_variable_get(:@relations) ||
@@ -98,23 +105,10 @@ module Brick
       model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
         case a.macro
         when :belongs_to
-          # Build #brick_descrip if needed
-          if a.klass.instance_methods(false).exclude?(:brick_descrip)
-            descrip_col = (a.klass.columns.map(&:name) - a.klass._brick_get_fks -
-                          (::Brick.config.metadata_columns || []) -
-                          [a.klass.primary_key]).first&.to_sym
-            if descrip_col
-              a.klass.define_method :brick_descrip do
-                send(descrip_col)
-              end
-            end
-          end
-
           s.first[a.foreign_key] = [a.name, a.klass]
         when :has_many, :has_one
           s.last[a.name] = a
         end
-        s
       end
     end
 
@@ -180,6 +174,11 @@ module Brick
       Brick.config.exclude_tables = value
     end
 
+    # @api public
+    def table_name_prefixes=(value)
+      Brick.config.table_name_prefixes = value
+    end
+
     # @api public
     def metadata_columns=(value)
       Brick.config.metadata_columns = value
@@ -196,7 +195,19 @@ module Brick
       end
     end
 
-    # Associations to treat has a has_one
+    # Skip creating a has_many association for these
+    # (Uses the same exact three-part format as would define an additional_reference)
+    # @api public
+    def skip_hms=(skips)
+      if skips
+        skips = skips.call if skips.is_a?(Proc)
+        skips = skips.to_a unless skips.is_a?(Array)
+        skips = [skips] unless skips.empty? || skips.first.is_a?(Array)
+        Brick.config.skip_hms = skips
+      end
+    end
+
+    # Associations to treat as a has_one
     # @api public
     def has_ones=(hos)
       if hos
@@ -211,6 +222,11 @@ module Brick
       end
     end
 
+    # DSL templates for individual models to provide prettier descriptions of objects
+    # @api public
+    def model_descrips=(descrips)
+      Brick.config.model_descrips = descrips
+    end
 
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.

data/lib/generators/brick/install_generator.rb

@@ -19,6 +19,62 @@ module Brick
 
     def create_initializer_file
       unless File.exists?(filename = 'config/initializers/brick.rb')
+        # See if we can make suggestions for additional_references
+        resembles_fks = []
+        possible_additional_references = (relations = ::Brick.relations).each_with_object([]) do |v, s|
+          v.last[:cols].each do |col, _type|
+            col_down = col.downcase
+            is_possible = true
+            if col_down.end_with?('_id')
+              col_down = col_down[0..-4]
+            elsif col_down.end_with?('id')
+              col_down = col_down[0..-3]
+              is_possible = false if col_down.length < 3 # Was it simply called "id" or something else really short?
+            elsif col_down.start_with?('id_')
+              col_down = col_down[3..-1]
+            elsif col_down.start_with?('id')
+              col_down = col_down[2..-1]
+            else
+              is_possible = false
+            end
+            if col_down.start_with?('fk_')
+              is_possible = true
+              col_down = col_down[3..-1]
+            end
+            # This possible key not really a primary key and not yet used as a foreign key?
+            if is_possible && !(relation = relations.fetch(v.first, {}))[:pkey].first&.last&.include?(col) &&
+               !relations.fetch(v.first, {})[:fks]&.any? { |_k, v| v[:is_bt] && v[:fk] == col }
+              if (relations.fetch(f_table = col_down, nil) ||
+                 relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
+                 # Looks pretty promising ... just make sure a model file isn't present
+                 !File.exists?("app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb")
+                s << "['#{v.first}', '#{col}', '#{f_table}']"
+              else
+                resembles_fks << "#{v.first}.#{col}"
+              end
+            end
+          end
+          s
+        end
+
+        bar = case possible_additional_references.length
+      when 0
++"# Brick.additional_references = [['orders', 'customer_id', 'customer'],
+#                                ['customer', 'region_id', 'regions']]"
+      when 1
+        +"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+# Brick.additional_references = [[#{possible_additional_references.first}]"
+      else
+        +"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+# Brick.additional_references = [
+#   #{possible_additional_references.join(",\n#   ")}
+# ]"
+      end
+      if resembles_fks.length > 0
+        bar << "\n# # Columns named somewhat like a foreign key which you may want to consider:
+# #   #{resembles_fks.join(', ')}"
+      end
+
         create_file filename, "# frozen_string_literal: true
 
 # # Settings for the Brick gem
@@ -30,12 +86,15 @@ module Brick
 # Brick.enable_controllers = false
 # Brick.enable_views = false
 
-# # By default models are auto-created from database views, and set to be read-only.  This can be skipped.
+# # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
 # Brick.skip_database_views = true
 
 # # Any tables or views you'd like to skip when auto-creating models
 # Brick.exclude_tables = ['custom_metadata', 'version_info']
 
+# # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
+# Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
+
 # # Additional table references which are used to create has_many / belongs_to associations inside auto-created
 # # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
 # # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
@@ -44,9 +103,13 @@ module Brick
 # #   foreign table name / foreign key column / primary table name.
 # # (We boldly expect that the primary key identified by ActiveRecord on the primary table will be accurate,
 # # usually this is \"id\" but there are some good smarts that are used in case some other column has been set
-# # to be the primary key.
-# Brick.additional_references = [['orders', 'customer_id', 'customer'],
-#                                ['customer', 'region_id', 'regions']]
+# # to be the primary key.)
+#{bar}
+
+# # Skip creating a has_many association for these
+# # (Uses the same exact three-part format as would define an additional_reference)
+# # Say for instance that we didn't care to display the favourite colours that users have:
+# Brick.skip_hms = [['users', 'favourite_colour_id', 'colours']]
 
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
 # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
@@ -56,12 +119,20 @@ module Brick
 # # instead of \"user_profile\", then apply that as a third parameter like this:
 # Brick.has_ones = [['User', 'user_profile', 'profile']]
 
-# # We normally don't consider the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\" to count when
-# # finding tables which can serve as associative tables in an N:M association.  That is, ones that can be a
-# # part of a has_many :through association.  If you want to use different exclusion columns than our defaults
-# # then this setting resets that list.  For instance, here is the override for the Sakila sample database:
+# # We normally don't show the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\", and also do
+# # not consider them when finding associative tables to support an N:M association.  (That is, ones that can be a
+# # part of a has_many :through association.)  If you want to use different exclusion columns than our defaults
+# # then this setting resets that list.  For instance, here is an override that is useful in the Sakila sample
+# # database:
 # Brick.metadata_columns = ['last_updated']
 
+# # A simple DSL is available to allow more user-friendly display of objects.  Normally a user object might be shown
+# # as its first non-metadata column, or if that is not available then something like \"User #45\" where 45 is that
+# # object's ID.  If there is no primary key then even that is not possible, so the object's .to_s method is called.
+# # To override these defaults and specify exactly what you want shown, such as first names and last names for a
+# # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
+# Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
+
 # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
 # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
 # # name and action you wish in order to override this and have that be the default route when none other has been

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.10
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-19 00:00:00.000000000 Z
+date: 2022-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord