brick 1.0.75 → 1.0.76

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd5fdf68935981a46106c879f5ac1fb44ac790c269c3eb2c5429cd67880f916
-  data.tar.gz: 260ce60eeaf2e4b17ca5b5e76e54960c4d2685c9cb9d8549a35a16ce49b5a36c
+  metadata.gz: 615640b22db113a3959644ee9c2d08ff3a2b37aa10f12dc92d68effef091c228
+  data.tar.gz: b0d3e616b0f44584cf6960f8b8b191fc449b9afc426a6486da11c2deadece7a6
 SHA512:
-  metadata.gz: 00f45ff020fcd729c2115f6d9f6ab0ab588247b2d727de7e1bd6acf53fa685ef76eeecce181a7a0c4659d8156971f88466915749cfad44e993993179435acdbd
-  data.tar.gz: 74f0b40c44bae3729624ca0ba6a378f9067e4b0aa98460a03aa193e292432576327991d8c2a107317d8ce51ce223eee780a0d632d5805ca14b91a1b55388259f
+  metadata.gz: 02a9f1c74af24e1e23df8b64972d7af8d74bbb870f1510b69d0814f362959e2527f2a7ee9ff7ca65187eb97be4fad1136d64bea7e01a8327a57608924a8f12d8
+  data.tar.gz: '0265977b746d0955c76bef269067d14363cda4373fc5f726f19fb284baf31d0df3bdaae6ffad7301b71cd630a2745db4d30f1da79ec43ef4ae1a92bc986058e9'

data/lib/brick/config.rb

@@ -90,6 +90,15 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
+    # Custom columns to add to a table, minimally defined with a name and DSL string
+    def custom_columns
+      @mutex.synchronize { @custom_columns }
+    end
+
+    def custom_columns=(cust_cols)
+      @mutex.synchronize { @custom_columns = cust_cols }
+    end
+
     # Skip creating a has_many association for these
     def exclude_hms
       @mutex.synchronize { @exclude_hms }

data/lib/brick/extensions.rb

@@ -100,73 +100,86 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, emit_dsl = false, is_polymorphic = false)
-      build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
-      build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
+      unless build_array.is_a?(::Brick::JoinArray)
+        build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
+        build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+      end
+      prefix = [prefix] unless prefix.is_a?(Array)
       members = []
+      unless dsl || (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
+        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
+        x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
+        return members
+      end
+
+      # Do the actual dirty work of recursing through nested DSL
       bracket_name = nil
-      prefix = [prefix] unless prefix.is_a?(Array)
-      if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
-        dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
-        dsl3 = +'' # To return expanded DSL that is nested from another model
-        klass = nil
-        dsl.each_char do |ch|
-          if bracket_name
-            if ch == ']' # Time to process a bracketed thing?
-              parts = bracket_name.split('.')
-              first_parts = parts[0..-2].map do |part|
-                klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
-                puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
-                part_sym
-              end
-              parts = prefix + first_parts + [parts[-1]]
-              if parts.length > 1
-                unless is_polymorphic
-                  s = build_array
-                  parts[0..-3].each { |v| s = s[v.to_sym] }
-                  s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
-                end
-                translations[parts[0..-2].join('.')] = klass
+      dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
+      dsl3 = +'' # To return expanded DSL that is nested from another model
+      klass = nil
+      dsl.each_char do |ch|
+        if bracket_name
+          if ch == ']' # Time to process a bracketed thing?
+            parts = bracket_name.split('.')
+            first_parts = parts[0..-2].map do |part|
+              klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
+              puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
+              part_sym
+            end
+            parts = prefix + first_parts + [parts[-1]]
+            if parts.length > 1
+              unless is_polymorphic
+                s = build_array
+                parts[0..-3].each { |v| s = s[v.to_sym] }
+                s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
               end
-              if klass.column_names.exclude?(parts.last) &&
-                 (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
-                # Expand this entry which refers to an association name
-                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
-                members += members2
-                dsl2 << dsl2a
-                dsl3 << dsl2a
-              else
-                dsl2 << "[#{bracket_name}]"
-                if emit_dsl
-                  dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
-                end
-                members << parts
+              translations[parts[0..-2].join('.')] = klass
+            end
+            if klass.column_names.exclude?(parts.last) &&
+               (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+              if prefix.empty? # Custom columns start with an empty prefix
+                prefix << parts.shift until parts.empty?
               end
-              bracket_name = nil
+              # Expand this entry which refers to an association name
+              members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
+              members += members2
+              dsl2 << dsl2a
+              dsl3 << dsl2a
             else
-              bracket_name << ch
+              dsl2 << "[#{bracket_name}]"
+              if emit_dsl
+                dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
+              end
+              members << parts
             end
-          elsif ch == '['
-            bracket_name = +''
-            klass = self
+            bracket_name = nil
           else
-            dsl2 << ch
-            dsl3 << ch
+            bracket_name << ch
           end
+        elsif ch == '['
+          bracket_name = +''
+          klass = self
+        else
+          dsl2 << ch
+          dsl3 << ch
         end
-        # Rewrite the DSL in case it's now different from having to expand it
-        # if ::Brick.config.model_descrips[name] != dsl2
-        #   puts ::Brick.config.model_descrips[name]
-        #   puts dsl2.inspect
-        #   puts dsl3.inspect
-        #   binding.pry
-        # end
-        ::Brick.config.model_descrips[name] = dsl2 unless emit_dsl
-      else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
-        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
-        x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
-      emit_dsl ? [members, dsl3] : members
+      # Rewrite the DSL in case it's now different from having to expand it
+      # if ::Brick.config.model_descrips[name] != dsl2
+      #   puts ::Brick.config.model_descrips[name]
+      #   puts dsl2.inspect
+      #   puts dsl3.inspect
+      #   binding.pry
+      # end
+      if emit_dsl
+        # Had been:  [members, dsl2, dsl3]
+        [members, dsl3]
+      else
+        ::Brick.config.model_descrips[name] = dsl2
+        members
+      end
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -177,7 +190,8 @@ module ActiveRecord
     end
 
     def self.brick_descrip(obj, data = nil, pk_alias = nil)
-      if (dsl = ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
+      dsl = obj if obj.is_a?(String)
+      if (dsl ||= ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
         idx = -1
         caches = {}
         output = +''
@@ -272,18 +286,28 @@ module ActiveRecord
       def _br_associatives
         @_br_associatives ||= {}
       end
+      # Custom columns
+      def _br_cust_cols
+        @_br_cust_cols ||= {}
+      end
     end
 
-    # Search for BT, HM, and HMT DSL stuff
+    # Search for custom column, BT, HM, and HMT DSL stuff
     def self._brick_calculate_bts_hms(translations, join_array)
+      # Add any custom columns
+      ::Brick.config.custom_columns&.fetch(table_name, nil)&.each do |k, cc|
+        # false = not polymorphic, and true = yes -- please emit_dsl
+        pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, cc, true)
+        _br_cust_cols[k] = [pieces, my_dsl]
+      end
       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)
-                                     # Last two params here:  "false" is for don't emit DSL, and "true" is for yes, we are polymorphic
-                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, false, true) }
+                                     # Last params here:  "true" is for yes, we are polymorphic
+                                     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
@@ -314,7 +338,7 @@ module ActiveRecord
                    else # Expecting only Symbol
                      if _br_hm_counts.key?(ord_part)
                        ord_part = "\"b_r_#{ord_part}_ct\""
-                     elsif !_br_bt_descrip.key?(ord_part) && !column_names.include?(ord_part.to_s)
+                     elsif !_br_bt_descrip.key?(ord_part) && !_br_cust_cols.key?(ord_part) && !column_names.include?(ord_part.to_s)
                        # Disallow ordering by a bogus column
                        # %%% Note this bogus entry so that Javascript can remove any bogus _brick_order
                        # parameter from the querystring, pushing it into the browser history.
@@ -331,6 +355,11 @@ module ActiveRecord
       [order_by, order_by_txt]
     end
 
+    def self.brick_select(params = {}, selects = [], *args)
+      (relation = all).brick_select(params, selects, *args)
+      relation.select(selects)
+    end
+
   private
 
     def self._brick_get_fks
@@ -421,7 +450,13 @@ module ActiveRecord
       end
     end
 
-    def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+    def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+      is_add_bts = is_add_hms = true
+
+      # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
+      # model early in case the user wants to do an ORDER BY based on any of that.
+      model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
       is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
@@ -446,7 +481,7 @@ module ActiveRecord
       end
 
       # %%% Skip the metadata columns
-      if selects&.empty? # Default to all columns
+      if selects.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
         #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
@@ -481,7 +516,36 @@ module ActiveRecord
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
         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|
+
+        # CUSTOM COLUMNS
+        # ==============
+        klass._br_cust_cols.each do |k, cc|
+          if respond_to?(k) # Name already taken?
+            # %%% Use ensure_unique here in this kind of fashion:
+            # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+            # binding.pry
+            next
+          end
+
+          cc.first.each do |cc_part|
+            dest_klass = cc_part[0..-2].inject(klass) { |kl, cc_part_term| kl.reflect_on_association(cc_part_term).klass }
+            tbl_name = (field_tbl_names[k][cc_part.last] ||= shift_or_first(chains[dest_klass])).split('.').last
+            # Deal with the conflict if there are two parts in the custom column named the same,
+            # "category.name" and "product.name" for instance will end up with aliases of "name"
+            # and "product__name".
+            cc_part_idx = cc_part.length - 1
+            while cc_part_idx > 0 &&
+                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__')}") &&
+                  used_col_aliases.key?(col_alias)
+              cc_part_idx -= 1
+            end
+            selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
+            cc_part << col_alias
+            used_col_aliases[col_alias] = nil
+          end
+        end
+
+        klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
 
@@ -544,7 +608,13 @@ module ActiveRecord
       klass._br_hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
-                         hm.foreign_key if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
+                         if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
+                           if hm.source_reflection.macro == :belongs_to # Traditional HMT using an associative table
+                             hm.foreign_key
+                           else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
+                             hm.source_reflection.active_record.primary_key
+                           end
+                         end
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
@@ -596,7 +666,8 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
       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 b_r_model__column naming for each.
+      # or custom columns as they must be expanded to find the corresponding b_r_model__column
+      # or br_cc_column naming for each.
       if order_by.present?
         final_order_by = *order_by.each_with_object([]) do |v, s|
           if v.is_a?(Symbol)
@@ -605,6 +676,8 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
               bt_cols.values.each do |v1|
                 v1.each { |v2| s << "\"#{v2.last}\"" if v2.length > 1 }
               end
+            elsif (cc_cols = klass._br_cust_cols[v])
+              cc_cols.first.each { |v1| s << "\"#{v1.last}\"" if v1.length > 1 }
             else
               s << v
             end
@@ -1204,22 +1277,6 @@ class Object
             return
           end
 
-          # Normal (non-swagger) request
-
-          # 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
-
-          # %%% Allow params to define which columns to use for order_by
-          # Overriding the default by providing a querystring param?
-          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
-
-          ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
             exported_csv = CSV.generate(force_quotes: false) do |csv_out|
@@ -1233,7 +1290,16 @@ class Object
             return
           end
 
-          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by, translations, join_array)
+          # Normal (not swagger or CSV) request
+
+          # %%% Allow params to define which columns to use for order_by
+          # Overriding the default by providing a querystring param?
+          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
+
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), nil,
+                                                                  translations = {},
+                                                                  join_array = ::Brick::JoinArray.new)
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
           counts = model._br_hm_counts.each_with_object([]) do |v, s|
@@ -1902,9 +1968,7 @@ module Brick
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
         pri_tbl = is_class ? fk[4][:class].underscore : pri_tbl
         pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl&.singularize != bt_assoc_name
-        cnstr_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)
+        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
         missing = []
         missing << fk[1] unless relations.key?(fk[1])
         missing << primary_table unless is_class || relations.key?(primary_table)
@@ -2029,6 +2093,28 @@ module Brick
       ::Brick.relations.keys.map { |v| [(r = v.pluralize), (model = models[r])&.last&.table_name || v, migrations&.fetch(r, nil), model&.first] }
     end
 
+    def ensure_unique(name, *sources)
+      base = name
+      if (added_num = name.slice!(/_(\d+)$/))
+        added_num = added_num[1..-1].to_i
+      else
+        added_num = 1
+      end
+      while (
+        name = "#{base}_#{added_num += 1}"
+        sources.each_with_object(nil) do |v, s|
+          s || case v
+               when Hash
+                 v.key?(name)
+               when Array
+                 v.include?(name)
+               end
+        end
+      )
+      end
+      name
+    end
+
     # Locate orphaned records
     def find_orphans(multi_schema)
       is_default_schema = multi_schema&.==(Apartment.default_schema)

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)
 
+        # Custom columns to add to a table, minimally defined with a name and DSL string
+        ::Brick.custom_columns = app.config.brick.fetch(:custom_columns, 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, {})
 
@@ -249,8 +252,8 @@ tr th {
   right: 0;
   cursor: pointer;
 }
-#headerTop tr th:hover {
-  background-color: #18B090;
+#headerTop tr th:hover, #headerTop tr th.highlight {
+  background-color: #28B898;
 }
 #exclusions {
   font-size: 0.7em;
@@ -273,6 +276,10 @@ tr th, tr td {
   padding: 0.2em 0.5em;
 }
 
+tr td.highlight {
+  background-color: #B0B0FF;
+}
+
 .show-field {
   background-color: #004998;
 }
@@ -500,6 +507,34 @@ function changeout(href, param, value, trimAfter) {
 var grid = document.getElementById(\"#{table_name}\");
 #{table_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
 var headerTop = document.getElementById(\"headerTop\");
+var headerCols;
+if (grid) {
+  // COLUMN HEADER AND TABLE CELL HIGHLIGHTING
+  var gridHighHeader = null,
+      gridHighCell = null;
+  grid.addEventListener(\"mouseenter\", gridMove);
+  grid.addEventListener(\"mousemove\", gridMove);
+  grid.addEventListener(\"mouseleave\", function (evt) {
+    if (gridHighCell) gridHighCell.classList.remove(\"highlight\");
+    gridHighCell = null;
+    if (gridHighHeader) gridHighHeader.classList.remove(\"highlight\");
+    gridHighHeader = null;
+  });
+  function gridMove(evt) {
+    var lastHighCell = gridHighCell;
+    gridHighCell = document.elementFromPoint(evt.x, evt.y);
+    if (lastHighCell !== gridHighCell) {
+      gridHighCell.classList.add(\"highlight\");
+      if (lastHighCell) lastHighCell.classList.remove(\"highlight\");
+    }
+    var lastHighHeader = gridHighHeader;
+    gridHighHeader = headerCols[gridHighCell.cellIndex];
+    if (lastHighHeader !== gridHighHeader) {
+      if (gridHighHeader) gridHighHeader.classList.add(\"highlight\");
+      if (lastHighHeader) lastHighHeader.classList.remove(\"highlight\");
+    }
+  }
+}
 function setHeaderSizes() {
   // console.log(\"start\");
   // See if the headerTop is already populated
@@ -531,6 +566,7 @@ function setHeaderSizes() {
         }
       }
     }
+    headerCols = tr.childNodes;
     if (isEmpty) headerTop.appendChild(tr);
   }
   grid.style.marginTop = \"-\" + getComputedStyle(headerTop).height;
@@ -779,7 +815,8 @@ erDiagram
        cols[col_name] = col
      end
      unless @_brick_sequence # If no sequence is defined, start with all inclusions
-       @_brick_sequence = col_keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
+       cust_cols = #{model_name}._br_cust_cols
+       @_brick_sequence = col_keys + cust_cols.keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
      end
      @_brick_sequence.reject! { |nm| @_brick_excl.include?(nm) } if @_brick_excl # Reject exclusions
      @_brick_sequence.each_with_object(+'') do |col_name, s|
@@ -796,6 +833,8 @@ erDiagram
        elsif col # HM column
          s << \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col[2]} \"
          s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1]._brick_index}_path\"))}\")
+       elsif (cc = cust_cols.key?(col_name)) # Custom column
+         s << \"<th x-order=\\\"#\{col_name}\\\">#\{col_name}\"
        else # Bad column name!
          s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
        end
@@ -813,7 +852,7 @@ erDiagram
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% @_brick_sequence.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
-      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name)%>><%
+      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name) || (cust_col = cust_cols[col_name])%>><%
          if (bt = bts[col_name])
            if bt[2] # Polymorphic?
              bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
@@ -847,6 +886,9 @@ erDiagram
          elsif (col = cols[col_name])
            col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
     %><%=  display_value(col_type || col&.sql_type, val) %><%
+         elsif cust_col
+           data = cust_col.first.map { |cc_part| #{obj_name}.send(cc_part.last) }
+    %><%=  #{model_name}.brick_descrip(cust_col.last, data) %><%
          else # Bad column name!
       %>?<%
          end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -329,6 +329,15 @@ module Brick
       end
     end
 
+    # Custom columns to add to a table, minimally defined with a name and DSL string.
+    # @api public
+    def custom_columns=(cust_cols)
+      if cust_cols
+        cust_cols = cust_cols.call if cust_cols.is_a?(Proc)
+        Brick.config.custom_columns = cust_cols
+      end
+    end
+
     # @api public
     def order=(value)
       Brick.config.order = value

data/lib/generators/brick/install_generator.rb

@@ -207,6 +207,12 @@ module Brick
 # # to be the primary key.)
 #{bar}
 
+# # Custom columns to add to a table, minimally defined with a name and DSL string.
+# Brick.custom_columns = { 'users' =>  { messages:    ['[COUNT(messages)] messages', 'messages'] },
+#                          'orders' => { salesperson:  '[salesperson.first] [salesperson.last]',
+#                                        products:    ['[COUNT(order_items.product)] products', 'order_items.product' ] }
+#                        }
+
 # # Skip creating a has_many association for these (only retain the belongs_to built from this additional_reference).
 # # (Uses the same exact three-part format as would define an additional_reference)
 # # Say for instance that we didn't care to display the favourite colours that users have:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.75
+  version: 1.0.76
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-30 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord