brick 1.0.46 → 1.0.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1442fb46672a819689a1f15aa16e2dd53647a057ea38948431746d3d8baf66f0
-  data.tar.gz: 38d26e09e226d37e87737cba35f76ee3b2413dc4474ac8ecba582297205789aa
+  metadata.gz: 8b42f1ad45e6dc942ed2e875d39318f8705f9a467c0cb31f267a71a01053bfd4
+  data.tar.gz: 1e8f0cd1c374c5d75be4e4f1a8b659dd32b46f991c85cce4d234a6949d017e4b
 SHA512:
-  metadata.gz: 8cb9e747cffb1e33f045f07656891b8e17ac4349661f897aa01886bae6fb7c2e4687f1021e04173266ab60cf330ec71f58514aeb670669f30ea8c6dd4140e943
-  data.tar.gz: 54166ef84adaeab00c2d6408e9a9a6c5da5998bd278b0db490943d2d8da2701938cdc87a4c40ff65ac2cbe7196a7eb014a4b3b08dfd2ff5aa2ec426af00d38ab
+  metadata.gz: 437d415278f01a2ffced31687f77324c21416e6e7ef395d6a5d3db5a1853ccfb301c01716747ba4427417164a1200100205e7b7c75443bef83f1050f01683dda
+  data.tar.gz: d42367f291f2900876c5263aab30280f7b5b3d9f205c4199349b9e24d35326b5457e1db8fd0d39a512f59af9691bbe44e29dd05d3384d5a0013c05ffe6447d8c

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,62 @@ module ActiveRecord
       template
     end
 
+    # belongs_to DSL descriptions
+    def self._br_bt_descrip
+      @_br_bt_descrip ||= {}
+    end
+    # has_many count definitions
+    def self._br_hm_counts
+      @_br_hm_counts ||= {}
+    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,13 +366,12 @@ 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)
@@ -345,33 +400,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 +408,7 @@ 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|
+        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?
 
@@ -416,7 +444,7 @@ 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
@@ -450,12 +478,31 @@ 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
 
   private
-
+  
     def shift_or_first(ary)
       ary.length > 1 ? ary.shift : ary.first
     end
@@ -596,7 +643,7 @@ 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("::#{name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+               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?
                  schema_name = [(singular_schema_name = name.underscore),
                                 (schema_name = singular_schema_name.pluralize),
@@ -619,7 +666,7 @@ Module.class_exec do
                               else
                                 ActiveSupport::Inflector.pluralize(singular_table_name)
                               end
-                 if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') &&
+                 if ::Brick.apartment_multitenant &&
                     Apartment.excluded_models.include?(table_name.singularize.camelize)
                    schema_name = Apartment.default_schema
                  end
@@ -654,7 +701,7 @@ class Object
   private
 
     def build_model(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
-      if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') &&
+      if ::Brick.apartment_multitenant &&
          schema_name == Apartment.default_schema
         relation = relations["#{schema_name}.#{matching}"]
       end
@@ -665,7 +712,7 @@ class Object
                                       schema_name
                                     else
                                       matching = "#{schema_name}.#{matching}"
-                                      (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.singularize.camelize))
+                                      (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.camelize))
                                     end
                     "#{schema_module&.name}::#{inheritable_name || model_name}"
                   end
@@ -773,33 +820,47 @@ class Object
       end # class definition
       # Having this separate -- will this now work out better?
         built_model.class_exec do
-          hmts&.each do |hmt_fk, fks|
+          hmts&.each do |hmt_fk, hms|
             hmt_fk = hmt_fk.tr('.', '_')
-            fks.each do |fk|
-              # %%% Will not work with custom has_many name
-              through = ::Brick.config.schema_behavior[:multitenant] ? fk.first[:assoc_name] : fk.first[:inverse_table].tr('.', '_').pluralize
-              hmt_name = if fks.length > 1
-                           if fks[0].first[:inverse][:assoc_name] == fks[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
-                             "#{hmt_fk}_through_#{fk.first[:assoc_name]}"
+            hms.each do |hm|
+              # %%% Need to confirm that HMTs work when they are built from has_manys with custom names
+              through = ::Brick.config.schema_behavior[:multitenant] ? hm.first[:assoc_name] : hm.first[:inverse_table].tr('.', '_').pluralize
+              options = {}
+              hmt_name = if hms.length > 1
+                           if hms[0].first[:inverse][:assoc_name] == hms[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
+                             "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
                            else # Use BT names to provide uniqueness
-                             through = fk.first[:alternate_name].pluralize
-                             singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
+                             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
+                               options[:source] = hm.last.to_sym
+                             else
+                               through = hm.first[:alternate_name].pluralize
+                             end
+                             singular_assoc_name = hm.first[:inverse][:assoc_name].singularize
                              "#{singular_assoc_name}_#{hmt_fk}"
                            end
                          else
                            hmt_fk
                          end
-              options = { through: through.to_sym }
+              options[:through] = through.to_sym
               if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
-                hmt_name = "#{hmt_name.singularize}_#{fk.first[:assoc_name]}"
+                hmt_name = "#{hmt_name.singularize}_#{hm.first[:assoc_name]}"
                 # Was:
-                # options[:class_name] = fk.first[:inverse_table].singularize.camelize
-                # options[:foreign_key] = fk.first[:fk].to_sym
-                far_assoc = relations[fk.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == fk.last }
+                # 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.last }
                 options[:class_name] = far_assoc.last[:inverse_table].singularize.camelize
                 options[:foreign_key] = far_assoc.last[:fk].to_sym
               end
-              options[:source] = fk.last.to_sym unless hmt_name.singularize == fk.last
+              options[:source] ||= hm.last.to_sym unless hmt_name.singularize == hm.last
               code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
               self.send(:has_many, hmt_name.to_sym, **options)
             end
@@ -832,7 +893,7 @@ class Object
                 if (inverse = assoc[:inverse])
                   # If it's multitenant with something like:  public.____ ...
                   if (it_parts = inverse_table.split('.')).length > 1 &&
-                     ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') &&
+                     ::Brick.apartment_multitenant &&
                      it_parts.first == Apartment.default_schema
                     it_parts.shift # ... then ditch the generic schema name
                   end
@@ -912,21 +973,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': [
@@ -976,6 +1042,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'
@@ -989,19 +1081,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
 
@@ -1128,7 +1217,8 @@ module ActiveRecord::ConnectionHandling
       end
       # Load the initializer for the Apartment gem a little early so that if .excluded_models and
       # .default_schema are specified then we can work with non-tenanted models more appropriately
-      if Object.const_defined?('Apartment') && File.exist?(apartment_initializer = Rails.root.join('config/initializers/apartment.rb'))
+      apartment = Object.const_defined?('Apartment')
+      if apartment && File.exist?(apartment_initializer = Rails.root.join('config/initializers/apartment.rb'))
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
@@ -1331,17 +1421,20 @@ module ActiveRecord::ConnectionHandling
       end
     end
 
-    apartment = Object.const_defined?('Apartment') && Apartment
     tables = []
     views = []
     relations.each do |k, v|
       name_parts = k.split('.')
+      idx = 1
+      name_parts = name_parts.map do |x|
+        ((idx += 1) < name_parts.length ? x.singularize : x).camelize
+      end
       if v.key?(:isView)
         views
       else
         name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
         tables
-      end << name_parts.map { |x| x.singularize.camelize }.join('::')
+      end << name_parts.join('::')
     end
     unless tables.empty?
       puts "\nClasses that can be built from tables:"
@@ -1423,7 +1516,7 @@ module Brick
       unless (cnstr_name = fk[5])
         # 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
+        pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl&.singularize != bt_assoc_name
         cnstr_base = cnstr_name = "(brick) #{for_tbl}_#{pri_tbl}"
         cnstr_added_num = 1
         cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
@@ -1449,6 +1542,8 @@ module Brick
           return
         end
       end
+      return unless bts # Rails 5.0 and older can have bts end up being nil
+
       if (assoc_bt = bts[cnstr_name])
         if is_polymorphic
           # Assuming same fk (don't yet support composite keys for polymorphics)

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)
 
@@ -105,13 +108,26 @@ module Brick
                 hms_columns = [] # Used for 'index'
                 skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
                 hms_headers = hms.each_with_object([]) do |hm, s|
-                  hm_stuff = [(hm_assoc = hm.last), "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}", (assoc_name = hm.first)]
+                  hm_stuff = [(hm_assoc = hm.last),
+                              "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_assoc.name]
-                                associative && "'#{associative.name}.#{associative.foreign_key}'"
-                              else
-                                hm_assoc.foreign_key
-                              end
+                                 associative = associatives[hm.first]
+                                 tbl_nm = if hm_assoc.options[:source]
+                                            associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
+                                          else
+                                            associative.name
+                                          end
+                                 # If there is no inverse available for the source belongs_to association, make one based on the class name
+                                 unless tbl_nm
+                                   tbl_nm = associative.class_name.underscore
+                                   tbl_nm.slice!(0) if tbl_nm[0] == ('/')
+                                   tbl_nm = tbl_nm.tr('/', '_').pluralize
+                                 end
+                                 "'#{tbl_nm}.#{associative.foreign_key}'"
+                               else
+                                 hm_assoc.foreign_key
+                               end
                   case args.first
                   when 'index'
                     hms_columns << if hm_assoc.macro == :has_many
@@ -149,7 +165,7 @@ module Brick
               schema_options = ::Brick.db_schemas.keys.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
               # %%% 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.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && Apartment.default_schema
+              apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).map do |tbl|
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
                                   tbl = tbl_parts.last
@@ -186,6 +202,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;
 }
@@ -524,7 +543,7 @@ if (headerTop) {
        k, id = @_brick_params.first
        id = id.first if id.is_a?(Array) && id.length == 1
        origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
-       if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| puts fk.inspect; fk[:fk] == key_parts.last }) &&
+       if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| fk[:fk] == key_parts.last }) &&
           (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
          <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination.name.underscore.tr('/', '_')\}_path\".to_sym, id) %></h3><%
        end
@@ -534,30 +553,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 if true # Currently we always allow click to sort
+         %>>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>
@@ -645,7 +667,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
@@ -716,9 +738,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 %>
@@ -776,6 +803,13 @@ 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) {
+    location.href = changeout(location.href, \"_brick_order\", this.getAttribute(\"x-order\"));
+  });
+});
 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 = 46
+    TINY = 49
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -47,7 +47,6 @@ end
 
 # Add left_outer_join! to Associations::JoinDependency and Relation::QueryMethods
 if ActiveRecord.version < ::Gem::Version.new('5')
-  is_add_left_outer_join = true
   ::Brick::Util._patch_require(
     'active_record/associations/join_dependency.rb', '/activerecord', # /associations
       ["def join_constraints(outer_joins)
@@ -140,6 +139,13 @@ module Brick
       (@relations ||= {})[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
     end
 
+    def apartment_multitenant
+      if @apartment_multitenant.nil?
+        @apartment_multitenant = ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment')
+      end
+      @apartment_multitenant
+    end
+
     # If multitenancy is enabled, a list of non-tenanted "global" models
     def non_tenanted_models
       @pending_models ||= {}
@@ -168,8 +174,12 @@ module Brick
       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
+          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]
         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
@@ -273,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
@@ -447,7 +462,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
         ::Brick.relations.each do |rel_name, v|
           rel_name = rel_name.split('.').map(&:underscore)
           schema_names = rel_name[0..-2]
-          schema_names.shift if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && schema_names.first == Apartment.default_schema
+          schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
           k = rel_name.last
           unless existing_controllers.key?(controller_name = k.pluralize)
             options = {}
@@ -477,7 +492,8 @@ require 'brick/version_number'
 # Older versions of ActiveRecord would only show more serious error information from "panic" level, which is
 # a level only available in Postgres 12 and older.  This patch will allow older and newer versions of Postgres
 # to work along with fairly old versions of Rails.
-if Object.const_defined?('PG::VERSION') && ActiveRecord.version < ::Gem::Version.new('4.2.6')
+if (is_postgres = (Object.const_defined?('PG::VERSION') || Gem::Specification.find_all_by_name('pg').present?)) &&
+   ActiveRecord.version < ::Gem::Version.new('4.2.6')
   ::Brick::Util._patch_require(
     'active_record/connection_adapters/postgresql_adapter.rb', '/activerecord', ["'panic'", "'error'"]
   )
@@ -485,13 +501,28 @@ end
 
 require 'active_record'
 require 'active_record/relation'
-require 'active_record/relation/query_methods' if is_add_left_outer_join
+# To support adding left_outer_join
+require 'active_record/relation/query_methods' if ActiveRecord.version < ::Gem::Version.new('5')
+require 'rails/railtie' if ActiveRecord.version < ::Gem::Version.new('4.2')
 
 # Rake tasks
 class Railtie < Rails::Railtie
   Dir.glob("#{File.expand_path(__dir__)}/brick/tasks/**/*.rake").each { |task| load task }
 end
 
+# Rails < 4.2 does not have env
+module Rails
+  unless respond_to?(:env)
+    def self.env
+      @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")
+    end
+
+    def self.env=(environment)
+      @_env = ActiveSupport::StringInquirer.new(environment)
+    end
+  end
+end
+
 # Major compatibility fixes for ActiveRecord < 4.2
 # ================================================
 ActiveSupport.on_load(:active_record) do
@@ -506,6 +537,15 @@ ActiveSupport.on_load(:active_record) do
           end
         end
       end
+      # ActiveRecord < 4.2 does not have default_timezone
+      # :singleton-method:
+      # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
+      # dates and times from the database. This is set to :utc by default.
+      unless respond_to?(:default_timezone)
+        puts "ADDING!!! 4.w"
+        mattr_accessor :default_timezone, instance_writer: false
+        self.default_timezone = :utc
+      end
     end
 
     # Rails < 4.0 cannot do #find_by, #find_or_create_by, or do #pluck on multiple columns, so here are the patches:
@@ -711,58 +751,60 @@ ActiveSupport.on_load(:active_record) do
         end
       end
 
-      if is_add_left_outer_join
-        # Final pieces for left_outer_joins support, which was derived from this commit:
-        # https://github.com/rails/rails/commit/3f46ef1ddab87482b730a3f53987e04308783d8b
-        module Associations
-          class JoinDependency
-            def make_left_outer_joins(parent, child)
-              tables    = child.tables
-              join_type = Arel::Nodes::OuterJoin
-              info      = make_constraints parent, child, tables, join_type
-
-              [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
-            end
+      # Final pieces for left_outer_joins support, which was derived from this commit:
+      # https://github.com/rails/rails/commit/3f46ef1ddab87482b730a3f53987e04308783d8b
+      module Associations
+        class JoinDependency
+          def make_left_outer_joins(parent, child)
+            tables    = child.tables
+            join_type = Arel::Nodes::OuterJoin
+            info      = make_constraints parent, child, tables, join_type
+
+            [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
           end
         end
-        module Querying
-          delegate :left_outer_joins, to: :all
+      end
+      module Querying
+        delegate :left_outer_joins, to: :all
+      end
+      class Relation
+        unless MULTI_VALUE_METHODS.include?(:left_outer_joins)
+          _multi_value_methods = MULTI_VALUE_METHODS + [:left_outer_joins]
+          send(:remove_const, :MULTI_VALUE_METHODS)
+          MULTI_VALUE_METHODS = _multi_value_methods
         end
-        class Relation
-          MULTI_VALUE_METHODS = MULTI_VALUE_METHODS + [:left_outer_joins] unless MULTI_VALUE_METHODS.include?(:left_outer_joins)
+      end
+      module QueryMethods
+        attr_writer :left_outer_joins_values
+        def left_outer_joins_values
+          @left_outer_joins_values ||= []
         end
-        module QueryMethods
-          attr_writer :left_outer_joins_values
-          def left_outer_joins_values
-            @left_outer_joins_values ||= []
-          end
 
-          def left_outer_joins(*args)
-            check_if_method_has_arguments!(:left_outer_joins, args)
+        def left_outer_joins(*args)
+          check_if_method_has_arguments!(:left_outer_joins, args)
 
-            args.compact!
-            args.flatten!
+          args.compact!
+          args.flatten!
 
-            spawn.left_outer_joins!(*args)
-          end
+          spawn.left_outer_joins!(*args)
+        end
 
-          def left_outer_joins!(*args) # :nodoc:
-            self.left_outer_joins_values += args
-            self
-          end
+        def left_outer_joins!(*args) # :nodoc:
+          self.left_outer_joins_values += args
+          self
+        end
 
-          def build_left_outer_joins(manager, outer_joins)
-            buckets = outer_joins.group_by do |join|
-              case join
-              when Hash, Symbol, Array
-                :association_join
-              else
-                raise ArgumentError, 'only Hash, Symbol and Array are allowed'
-              end
+        def build_left_outer_joins(manager, outer_joins)
+          buckets = outer_joins.group_by do |join|
+            case join
+            when Hash, Symbol, Array
+              :association_join
+            else
+              raise ArgumentError, 'only Hash, Symbol and Array are allowed'
             end
-
-            build_join_query(manager, buckets, Arel::Nodes::OuterJoin)
           end
+
+          build_join_query(manager, buckets, Arel::Nodes::OuterJoin)
         end
       end
       # (End of left_outer_joins support)
@@ -784,7 +826,8 @@ ActiveSupport.on_load(:active_record) do
 end
 
 # Do this earlier because stuff here gets mixed into JoinDependency::JoinAssociation and AssociationScope
-if ActiveRecord.version < ::Gem::Version.new('5.0') && Object.const_defined?('PG::Connection')
+if is_postgres && ActiveRecord.version < ::Gem::Version.new('5.0') # Was:  && Object.const_defined?('PG::Connection')
+  require 'pg' # For ActiveRecord < 4.2
   # Avoid pg gem deprecation warning:  "You should use PG::Connection, PG::Result, and PG::Error instead"
   PGconn = PG::Connection
   PGresult = PG::Result

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.46
+  version: 1.0.49
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-15 00:00:00.000000000 Z
+date: 2022-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: fancy_gets
   requirement: !ruby/object:Gem::Requirement