brick 1.0.48 → 1.0.51

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9c3989f395bc81df36b3f295c72029e92911bd24f8d146db5627fb29c1875f4
-  data.tar.gz: 97ae12a1562f9f9bae5f401016e219a5ad58218068f80d7fc0e732d61c4f3f90
+  metadata.gz: 9d0c2c69187f4d9b8eaa4a22777d3e517546bf355316012bf3e333064f8939b7
+  data.tar.gz: 33fcb2f6ca4373eba2db3a2891de392d9ef71ea693687328f72d23837cabdc46
 SHA512:
-  metadata.gz: c64d02f90b992640698523190a920467204a2fbb40fb9e21a3e7872ae469db3506bdf7fb535e54cd33157feb93ed43c2d1c11b2bea952bc9f034ac7e7dfb6b06
-  data.tar.gz: 6c01156b2b35f387e531ed6835a7517f5249b72ec53bb23d5d965c4b298a443d9a62e5694f9c1b4587f6ab04ef30590d7d9077e13c66b651ee8ed12b76282932
+  metadata.gz: 7136cb61d19325c1916e9d2e8e6cd7ed6c1d6838c77a216c5275bf4cc0d3540eeabf5caae152b49b9f5cf0d5ea7307bebd98f2fdbc03e651310c1cfc6fbec436
+  data.tar.gz: 81007bc391e9871ab0bbe80fc5aaa440da2685e1abe16d65d09419e31e93529232757db173cf97ba78ad3e719af760cac2d83b57cb7d97fa488399d93d3d2f76

data/lib/brick/config.rb

@@ -190,6 +190,30 @@ module Brick
       @mutex.synchronize { @table_name_prefixes = value }
     end
 
+    def order
+      @mutex.synchronize { @order || {} }
+    end
+
+    # Get something like:
+    # Override how code sorts with:
+    #   { 'on_call_list' => { code: "ORDER BY STRING_TO_ARRAY(code, '.')::int[]" } }
+    # Specify default thing to order_by with:
+    #   { 'on_call_list' => { _brick_default: [:last_name, :first_name] } }
+    #   { 'on_call_list' => { _brick_default: :sequence } }
+    def order=(orders)
+      @mutex.synchronize do
+        case (brick_default = orders.fetch(:_brick_default, nil))
+        when NilClass
+          orders[:_brick_default] = orders.keys.reject { |k| k == :_brick_default }.first
+        when String
+          orders[:_brick_default] = [brick_default.to_sym]
+        when Symbol
+          orders[:_brick_default] = [brick_default]
+        end
+        @order = orders
+      end
+    end
+
     def metadata_columns
       @mutex.synchronize { @metadata_columns }
     end

data/lib/brick/extensions.rb

@@ -221,6 +221,68 @@ module ActiveRecord
       template
     end
 
+    class << self
+      # belongs_to DSL descriptions
+      def _br_bt_descrip
+        @_br_bt_descrip ||= {}
+      end
+      # has_many count definitions
+      def _br_hm_counts
+        @_br_hm_counts ||= {}
+      end
+      # has_many :through associative tables
+      def _br_associatives
+        @_br_associatives ||= {}
+      end
+    end
+
+    # Search for BT, HM, and HMT DSL stuff
+    def self._brick_calculate_bts_hms(translations, join_array)
+      bts, hms, associatives = ::Brick.get_bts_and_hms(self)
+      bts.each do |_k, bt|
+        next if bt[2] # Polymorphic?
+
+        # join_array will receive this relation name when calling #brick_parse_dsl
+        _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
+                                   else
+                                     { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
+                                   end
+      end
+      skip_klass_hms = ::Brick.config.skip_index_hms[self.name] || {}
+      hms.each do |k, hm|
+        next if skip_klass_hms.key?(k)
+
+        if hm.macro == :has_one
+          # For our purposes a :has_one is similar enough to a :belongs_to that we can just join forces
+          _br_bt_descrip[k] = { hm.klass => hm.klass.brick_parse_dsl(join_array, k, translations) }
+        else # Standard :has_many
+          _br_hm_counts[k] = hm
+        end
+      end
+    end
+
+    def self._brick_calculate_ordering(ordering, is_do_txt = true)
+      quoted_table_name = table_name.split('.').map { |x| "\"#{x}\"" }.join('.')
+      order_by_txt = [] if is_do_txt
+      ordering = [ordering] if ordering && !ordering.is_a?(Array)
+      order_by = ordering&.map do |ord_part| # %%% If a term is also used as an eqi-condition in the WHERE clause, it can be omitted from ORDER BY
+                   case ord_part
+                   when String
+                     ord_expr = ord_part.gsub('^^^', quoted_table_name)
+                     order_by_txt&.<<("Arel.sql(#{ord_expr})")
+                     Arel.sql(ord_expr)
+                   else # Expecting only Symbol
+                     ord_part = "_br_#{ord_part}_ct" if _br_hm_counts.key?(ord_part)
+                     # Retain any reference to a bt_descrip as being a symbol
+                     # Was:  "#{quoted_table_name}.\"#{ord_part}\""
+                     order_by_txt&.<<(_br_bt_descrip.key?(ord_part) ? ord_part : ord_part.inspect)
+                     ord_part
+                   end
+                 end
+      [order_by, order_by_txt]
+    end
+
   private
 
     def self._brick_get_fks
@@ -310,16 +372,15 @@ module ActiveRecord
       end
     end
 
-    def brick_select(params, selects = nil, bt_descrip = {}, hm_counts = {}, join_array = ::Brick::JoinArray.new
-      # , is_add_bts, is_add_hms
-    )
-      is_add_bts = is_add_hms = true
+    def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
+        next if ['_brick_schema', '_brick_order'].include?(k)
+
         case (ks = k.split('.')).length
         when 1
-          next unless klass._brick_get_fks.include?(k)
+          next unless klass.column_names.any?(k) || klass._brick_get_fks.include?(k)
         when 2
           assoc_name = ks.first.to_sym
           # Make sure it's a good association name and that the model has that column name
@@ -345,33 +406,6 @@ module ActiveRecord
         end
       end
 
-      # Search for BT, HM, and HMT DSL stuff
-      translations = {}
-      if is_add_bts || is_add_hms
-        bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
-        bts.each do |_k, bt|
-          next if bt[2] # Polymorphic?
-
-          # join_array will receive this relation name when calling #brick_parse_dsl
-          bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                   bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
-                                 else
-                                   { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
-                                 end
-        end
-        skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
-        hms.each do |k, hm|
-          next if skip_klass_hms.key?(k)
-
-          if hm.macro == :has_one
-            # For our purposes a :has_one is similar enough to a :belongs_to that we can just join forces
-            bt_descrip[k] = { hm.klass => hm.klass.brick_parse_dsl(join_array, k, translations) }
-          else # Standard :has_many
-            hm_counts[k] = hm
-          end
-        end
-      end
-
       if join_array.present?
         left_outer_joins!(join_array)
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
@@ -380,7 +414,8 @@ module ActiveRecord
         chains = rel_dupe._brick_chains
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
-        bt_columns = bt_descrip.each_with_object([]) do |v, s|
+        used_col_aliases = {} # Used to make sure there is not a name clash
+        bt_columns = klass._br_bt_descrip.each_with_object([]) do |v, s|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
 
@@ -391,7 +426,12 @@ module ActiveRecord
 
               # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
               is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
-              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
+              # If it's not unique then also include the belongs_to association name before the column name
+              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}\""
+              used_col_aliases[col_alias] = nil
               v1[idx] << col_alias
             end
 
@@ -416,11 +456,10 @@ module ActiveRecord
         end
       end
       # Add derived table JOIN for the has_many counts
-      hm_counts.each do |k, hm|
+      klass._br_hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
-                         fk_col = (associative = associatives[hm.name])&.foreign_key
-                         hm.foreign_key if fk_col
+                         hm.foreign_key if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
@@ -450,6 +489,25 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
       where!(wheres) unless wheres.empty?
+      # Must parse the order_by and see if there are any symbols which refer to BT associations
+      # as they must be expanded to find the corresponding _br_model__column naming for each.
+      if order_by.present?
+        final_order_by = *order_by.each_with_object([]) do |v, s|
+          if v.is_a?(Symbol)
+            # Add the ordered series of columns derived from the BT based on its DSL
+            if (bt_cols = klass._br_bt_descrip[v])
+              bt_cols.values.each do |v1|
+                v1.each { |v2| s << v2.last if v2.length > 1 }
+              end
+            else
+              s << v
+            end
+          else # String stuff just comes straight through
+            s << v
+          end
+        end
+        order!(*final_order_by)
+      end
       limit!(1000) # Don't want to get too carried away just yet
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
@@ -489,12 +547,23 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
                               this_module.const_set(module_name.to_sym, Module.new)
                             end
             end
-            if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
-              this_module.const_get(class_name)
-            else
-              # Build STI subclass and place it into the namespace module
-              this_module.const_set(class_name, klass = Class.new(self))
-              klass
+            begin
+              if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
+                this_module.const_get(class_name)
+              else
+                # Build STI subclass and place it into the namespace module
+                this_module.const_set(class_name, klass = Class.new(self))
+                klass
+              end
+            rescue NameError => err
+              if column_names.include?(inheritance_column)
+                puts "Table #{table_name} has column #{inheritance_column} which ActiveRecord expects to use as its special inheritance column."
+                puts "Unfortunately the value \"#{type_name}\" does not seem to refer to a valid type name, greatly confusing matters.  If that column is intended to be used for data and not STI, consider putting this line into your Brick initializer so that only for this table that column will not clash with ActiveRecord:"
+                puts "  Brick.sti_type_column = { 'rails_#{inheritance_column}' => ['#{table_name}'] }"
+                self
+              else
+                raise
+              end
             end
           end
         end
@@ -545,6 +614,8 @@ Module.class_exec do
       return possible
     end
     class_name = args.first.to_s
+    # self.name is nil when a model name is requested in an .erb file
+    base_module = (self < ActiveRecord::Migration || !self.name) ? Object : self
     # 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
     # that is, checking #qualified_name_for with:  from_mod, const_name
@@ -552,14 +623,17 @@ Module.class_exec do
     # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
     # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
     # If the file really exists, go and snag it:
-    if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = (self.name || class_name)&.split('::'))
-      filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
-    end
-    if is_found
-      return self._brick_const_missing(*args)
-    # elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-    #   my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
-    #   return my_const
+    if ActiveSupport::Dependencies.search_for_file(class_name.underscore)
+      return base_module._brick_const_missing(*args)
+      # elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
+      #   my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
+      #   return my_const
+    else
+      filepath = base_module.name&.split('::')&.[](0..-2) unless base_module == Object
+      filepath = ((filepath || []) + [class_name]).join('/').underscore + '.rb'
+      if ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
+        return base_module._brick_const_missing(*args)
+      end
     end
 
     relations = ::Brick.relations
@@ -578,7 +652,7 @@ Module.class_exec do
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
-                   self == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
+                   base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
                    (schema_name = [(singular_table_name = class_name.underscore),
                                    (table_name = singular_table_name.pluralize),
                                    class_name,
@@ -586,7 +660,7 @@ Module.class_exec do
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
                # Build out a module for the schema if it's namespaced
                # schema_name = schema_name.camelize
-               self.const_set(schema_name.to_sym, (built_module = Module.new))
+               base_module.const_set(schema_name.to_sym, (built_module = Module.new))
 
                [built_module, "module #{schema_name}; end\n"]
                #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
@@ -596,8 +670,8 @@ Module.class_exec do
                # 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("::#{self.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
-                  self != Object # ... or otherwise already in some namespace?
+               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,
@@ -610,7 +684,7 @@ Module.class_exec do
                if base_model
                  schema_name = name.underscore # For the auto-STI namespace models
                  table_name = base_model.table_name
-                 Object.send(:build_model, self, inheritable_name, model_name, singular_table_name, table_name, relations, 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.
@@ -635,15 +709,15 @@ Module.class_exec do
       built_class
     elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}") && !schema_name
 #         module_prefixes = type_name.split('::')
-#         path = self.name.split('::')[0..-2] + []
+#         path = base_module.name.split('::')[0..-2] + []
 #         module_prefixes.unshift('') unless module_prefixes.first.blank?
 #         candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
-      self._brick_const_missing(*args)
-    # elsif self != Object
+      base_module._brick_const_missing(*args)
+    # elsif base_module != Object
     #   module_parent.const_missing(*args)
     else
-      puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
-      self._brick_const_missing(*args)
+      puts "MISSING! #{base_module.name} #{args.inspect} #{table_name}"
+      base_module._brick_const_missing(*args)
     end
   end
 end
@@ -784,15 +858,15 @@ class Object
                              "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
                            else # Use BT names to provide uniqueness
                              if self.name.underscore.singularize == hm.first[:alternate_name]
-                              #  Has previously been:
-                              # # If it folds back on itself then look at the other side
-                              # # (At this point just infer the source be the inverse of the first has_many that
-                              # # we find that is not ourselves.  If there are more than two then uh oh, can't
-                              # # yet handle that rare circumstance!)
-                              # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
-                              # options[:source] = other.first[:inverse][:assoc_name].to_sym
-                              #  And also has been:
-                              # hm.first[:inverse][:assoc_name].to_sym
+                               #  Has previously been:
+                               # # If it folds back on itself then look at the other side
+                               # # (At this point just infer the source be the inverse of the first has_many that
+                               # # we find that is not ourselves.  If there are more than two then uh oh, can't
+                               # # yet handle that rare circumstance!)
+                               # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
+                               # options[:source] = other.first[:inverse][:assoc_name].to_sym
+                               #  And also has been:
+                               # hm.first[:inverse][:assoc_name].to_sym
                                options[:source] = hm.last.to_sym
                              else
                                through = hm.first[:alternate_name].pluralize
@@ -926,21 +1000,26 @@ class Object
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
         # Brick-specific pages
-        if plural_class_name == 'BrickGem'
+        case plural_class_name
+        when 'BrickGem'
           self.define_method :orphans do
             instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params)))
           end
           return [new_controller_class, code + ' # BrickGem controller']
+        when 'BrickSwagger'
+          is_swagger = true # if request.format == :json)
         end
 
-        unless (is_swagger = plural_class_name == 'BrickSwagger') # && request.format == :json)
-          code << "  def index\n"
-          code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
-          code << "    @#{table_name}.brick_select(params)\n"
-          code << "  end\n"
-        end
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
+          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
+          # wants to do an ORDER BY based on any of that
+          translations = {}
+          join_array = ::Brick::JoinArray.new
+          is_add_bts = is_add_hms = true
+          # This builds out bt_descrip and hm_counts on the model
+          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+
           if is_swagger
             json = { 'openapi': '3.0.1', 'info': { 'title': 'API V1', 'version': 'v1' },
                      'servers': [
@@ -990,6 +1069,32 @@ class Object
             render inline: json.to_json, content_type: request.format
             return
           end
+
+          # 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"
+
           ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
@@ -1003,19 +1108,16 @@ class Object
             return
           end
 
-          quoted_table_name = model.table_name.split('.').map { |x| "\"#{x}\"" }.join('.')
-          order = pk.each_with_object([]) { |pk_part, s| s << "#{quoted_table_name}.\"#{pk_part}\"" }
-          ar_relation = order.present? ? model.order("#{order.join(', ')}") : model.all
-          @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by, translations, join_array)
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
-          counts = hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
+          counts = model._br_hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
           instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
-          @_brick_bt_descrip = bt_descrip
-          @_brick_hm_counts = hm_counts
+          @_brick_bt_descrip = model._br_bt_descrip
+          @_brick_hm_counts = model._br_hm_counts
           @_brick_join_array = join_array
         end
 
@@ -1049,7 +1151,17 @@ class Object
             # end
 
             is_need_params = true
-            # code << "  # (Define :edit, and :destroy)\n"
+            # code << "  # (Define :destroy)\n"
+            code << "  def edit\n"
+            code << find_by_id
+            code << "  end\n"
+            self.define_method :edit do
+              ::Brick.set_db_schema(params)
+              id = is_pk_string ? params[:id] : params[:id]&.split(/[\/,_]/)
+              id = id.first if id.is_a?(Array) && id.length == 1
+              instance_variable_set("@#{singular_table_name}".to_sym, model.find(id))
+            end
+
             code << "  def update\n"
             code << find_by_id
             params_name = "#{singular_table_name}_params"
@@ -1083,8 +1195,12 @@ class Object
           if is_need_params
             code << "private\n"
             code << "  def #{params_name}\n"
+            permits = model.columns_hash.keys.map { |c| c.to_sym.inspect } +
+                      model.reflect_on_all_associations.each_with_object([]) do |assoc, s|
+                        s << "#{assoc.name.to_s.singularize}_ids: []" if assoc.macro == :has_many && assoc.options[:through]
+                      end
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
-                             }).permit(#{model.columns_hash.keys.map { |c| c.to_sym.inspect }.join(', ')})\n"
+                             }).permit(#{permits.join(', ')})\n"
             code << "  end\n"
             self.define_method(params_name) do
               params.require(require_name.to_sym).permit(model.columns_hash.keys)

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

@@ -33,6 +33,9 @@ module Brick
         # Additional references (virtual foreign keys)
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
+        # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
+        ::Brick.order = app.config.brick.fetch(:order, {})
+
         # Skip creating a has_many association for these
         ::Brick.exclude_hms = app.config.brick.fetch(:exclude_hms, nil)
 
@@ -55,7 +58,9 @@ module Brick
             def template_exists?(*args, **options)
               (::Brick.config.add_orphans && args.first == 'orphans') ||
               _brick_template_exists?(*args, **options) ||
-              set_brick_model(args)
+              # Do not auto-create a template when it's searching for an application.html.erb, which comes in like:  ["edit", ["games", "application"]]
+              ((args[1].length == 1 || args[1][-1] != 'application') &&
+               set_brick_model(args))
             end
 
             def set_brick_model(find_args)
@@ -101,7 +106,7 @@ module Brick
                 path_obj_name = model_name.underscore.tr('/', '_')
                 table_name = obj_name.pluralize
                 template_link = nil
-                bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
+                bts, hms = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
                 hms_columns = [] # Used for 'index'
                 skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
                 hms_headers = hms.each_with_object([]) do |hm, s|
@@ -109,7 +114,7 @@ module Brick
                               "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if hm_assoc.options[:through]
-                                 associative = associatives[hm.first]
+                                 associative = @_brick_model._br_associatives[hm.first]
                                  tbl_nm = if hm_assoc.options[:source]
                                             associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
                                           else
@@ -163,12 +168,12 @@ module Brick
               # %%% 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
               apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
-              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).map do |tbl|
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
                                   tbl = tbl_parts.last
                                 end
-                                tbl
-                              end.sort.each_with_object(+'') do |v, s|
+                                s[tbl] = nil
+                              end.keys.sort.each_with_object(+'') do |v, s|
                                 s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
                               end.html_safe
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
@@ -199,6 +204,9 @@ table thead tr th, table tr th {
   color: #fff;
   text-align: left;
 }
+#headerTop th:hover, #headerTop th:hover {
+  background-color: #18B090;
+}
 table thead tr th a, table tr th a {
   color: #80FFB8;
 }
@@ -547,30 +555,33 @@ if (headerTop) {
 <br>
 <table id=\"headerTop\">
 <table id=\"#{table_name}\">
-  <thead><tr>#{'<th></th>' if pk.present?}<%
+  <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%
      col_order = []
      @#{table_name}.columns.each do |col|
        next if (#{(pk || []).inspect}.include?(col_name = col.name) && col.type == :integer && !bts.key?(col_name)) ||
                ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
 
        col_order << col_name
-    %><th<%= \" title = \\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>><%
+    %><th<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %><%
        if (bt = bts[col_name]) %>
-         BT <%
+         <%= \" x-order=\\\"#\{bt.first}\\\"\".html_safe unless bt[2] # Allow sorting any BT except polymorphics
+         %>>BT <%
          bt[1].each do |bt_pair| %><%=
            bt_pair.first.bt_link(bt.first) %> <%
          end %><%
-       else %><%=
-         col_name %><%
+       else %><%= \" x-order=\\\"#\{col_name}\\\"\".html_safe if true # Currently we always allow click to sort
+         %>><%= col_name %><%
        end
     %></th><%
      end
      # Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name
   %>#{hms_headers.map do |h|
+        # Currently we always allow click to sort
+        "<th#{" x-order=\"#{h.first.name}\"" if true}>" +
         if h.first.options[:through] && !h.first.through_reflection
-    "<th>#{h[1]} #{h[2]} %></th>" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+    "#{h[1]} #{h[2]} %></th>" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
         else
-    "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
+    "#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
         end
       end.join
   }</tr></thead>
@@ -658,7 +669,7 @@ end
     <tr>
     <% next if (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
                ::Brick.config.metadata_columns.include?(k) %>
-    <th class=\"show-field\"<%= \" title = \\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
+    <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
     <% has_fields = true
       if (bt = bts[k])
         # Add a final member in this array with descriptive options to be used in <select> drop-downs
@@ -729,9 +740,14 @@ end
       <% when :uuid %>
         <%=
           # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
-          # If it's not yet enabled then:  enable_extension 'uuid-ossp'
+          # If it's not yet enabled then:  create extension \"uuid-ossp\";
           # ActiveUUID gem created a new :uuid type
           val %>
+      <% when :ltree %>
+        <%=
+          # In Postgres labels of data stored in a hierarchical tree-like structure
+          # If it's not yet enabled then:  create extension ltree;
+          val %>
       <% when :binary, :primary_key %>
       <% end %>
     <% end %>
@@ -789,6 +805,15 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
 </script>
 <% end %>
 <script>
+<% # Make column headers sort when clicked
+   # %%% Create a smart javascript routine which can do this client-side %>
+[... document.getElementsByTagName(\"TH\")].forEach(function (th) {
+  th.addEventListener(\"click\", function (e) {
+    var xOrder;
+    if (xOrder = this.getAttribute(\"x-order\"))
+      location.href = changeout(location.href, \"_brick_order\", xOrder);
+  });
+});
 document.querySelectorAll(\"input, select\").forEach(function (inp) {
   var origVal = getInpVal(),
       prevVal = origVal;

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -172,14 +172,14 @@ module Brick
       # 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|
+      hms.each do |hmt|
         if (through = hmt.last.options[:through])
           skip_hms[through] = nil # if hms[through]
           # binding.pry if !hms[through]
           # End up with a hash of HMT names pointing to join-table associations
           # Last part was:  hmt.last.name
           # Changed up because looking for:  hms[:issue_issue_duplicates]
-          s[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
+          model._br_associatives[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
         elsif hmt.last.inverse_of.nil?
           puts "SKIPPING #{hmt.last.name.inspect}"
           # %%% If we don't do this then below associative.name will find that associative is nil
@@ -187,7 +187,7 @@ module Brick
         end
       end
       skip_hms.each { |k, _v| hms.delete(k) }
-      [bts, hms, associatives]
+      [bts, hms]
     end
 
     # Switches Brick auto-models on or off, for all threads
@@ -283,6 +283,11 @@ module Brick
       end
     end
 
+    # @api public
+    def order=(value)
+      Brick.config.order = value
+    end
+
     # Skip creating a has_many association for these
     # (Uses the same exact three-part format as would define an additional_reference)
     # @api public

data/lib/generators/brick/install_generator.rb

@@ -159,6 +159,41 @@ module Brick
 # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
 # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
 
+# # COLUMN SEQUENCING AND INCLUSION / EXCLUSION
+
+# # By default if there is a primary key present then rows in an index view are ordered by this primary key.  To
+# # use a different rule for doing ORDER BY, you can override this default ordering done by The Brick, for instance
+# # to have the rows in a contact list sorted by email:
+# Brick.order = { 'contacts' => { _brick_default: :email } }
+# # or by last name then first name:
+# Brick.order = { 'contacts' => { _brick_default: [:lastname, :firstname] } }
+# # Totally legitimate to have the default order be the name of a belongs_to or has_many association instead of an
+# # actual column name, in which case for has_many it just orders by the count of how many records are associated,
+# # and for belongs_to it's based on the primary table's DSL if any is defined (since that is what is used to
+# # calculate what is shown when a foreign table lists out related records).  If contacts relates to addresses,
+# # then this is perfectly fine:
+# Brick.order = { 'contacts' => { _brick_default: :address } }
+# # You can even have a specific custom clause used in the ORDER BY.  In this case it is recommended to include a
+# # special placeholder for the table name with the sequence \"^^^\".  Here is an example of having the default
+# # ordering happening on the \"code\" column, and also defining custom sorting to be done, in this case proper
+# # ordering if that code is stored as a dotted numeric value:
+# Brick.order = { 'document_trees' => { _brick_default: :code,
+#                                       code: \"ORDER BY STRING_TO_ARRAY(^^^.code, '.')::int[]\" } }
+
+# # Sequence of columns for each model.  This also allows you to add read-only calculated columns in the same
+# # kind of way that they can be added in the include: portion of include/exclude columns, below.
+# # Designated by { <table name> => [<column name>, <column name>] }
+# Brick.column_sequence = { 'users' => ['email', 'profile.firstname', 'profile.lastname'] }
+
+# # Specific columns to include or exclude for each model.  If there are only inclusions then only those
+# # columns show.  If there are any exclusions then all non-excluded columns are attempted to be shown,
+# # which negates the usefulness of inclusions except to add calculated column detail built from DSL.
+# # Designated by <table name>.<column name>
+# Brick.column_sequence = { 'users' =>   { include: ['email', 'profile.firstname', 'profile.lastname'] },
+#                           'profile' => { exclude: ['birthdate'] } }
+
+# # EXTRA FOREIGN KEYS AND OTHER HAS_MANY SETTINGS
+
 # # Additional table references which are used to create has_many / belongs_to associations inside auto-created
 # # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
 # # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
@@ -176,8 +211,9 @@ module Brick
 # Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
 
 # # Skip showing counts for these specific has_many associations when building auto-generated #index views.
-# # When there are related tables with a significant number of records, this can lessen the load on the database
-# # considerably, sometimes fixing what might appear to be an index page that just \"hangs\" for no apparent reason.
+# # When there are related tables with a significant number of records (generally 100,000 or more), this can lessen
+# # the load on the database considerably, sometimes fixing what might appear to be an index page that just \"hangs\"
+# # for no apparent reason.
 # Brick.skip_index_hms = ['User.litany_of_woes']
 
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
@@ -199,6 +235,8 @@ module Brick
 # # Designated by <table name>.<column name>
 # Brick.not_nullables = ['users.name']
 
+# # FRIENDLY DSL
+
 # # A simple DSL is available to allow more user-friendly display of objects.  Normally a user object might be shown
 # # as its first non-metadata column, or if that is not available then something like \"User #45\" where 45 is that
 # # object's ID.  If there is no primary key then even that is not possible, so the object's .to_s method is called.
@@ -206,6 +244,8 @@ module Brick
 # # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
 # Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
 
+# # SINGLE TABLE INHERITANCE
+
 # # Specify STI subclasses either directly by name or as a general module prefix that should always relate to a specific
 # # parent STI class.  The prefixed :: here for these examples is mandatory.  Also having a suffixed :: means instead of
 # # a class reference, this is for a general namespace reference.  So in this case requests for, say, either of the
@@ -221,6 +261,8 @@ module Brick
 # Brick.sti_type_column = 'sti_type'
 # Brick.sti_type_column = { 'rails_type' => ['sales.specialoffer'] }
 
+# # POLYMORPHIC ASSOCIATIONS
+
 # # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes in the case that
 # # it wasn't originally specified.
 # Brick.schema_behavior = :namespaced
@@ -231,6 +273,8 @@ module Brick
 
 # # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 
+# # DEFAULT ROOT ROUTE
+
 # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
 # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
 # # name and action you wish in order to override this and have that be the default route when none other has been

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.48
+  version: 1.0.51
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-20 00:00:00.000000000 Z
+date: 2022-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord