brick 1.0.50 → 1.0.53

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5f5d009df0d4a7ce06a5dec8986d2664671e8b151f7493e5ce3f8f690ec7028
-  data.tar.gz: 974e86906775728e0ff0c7022cfbd87578b7c3013a8f9a5fe0db2243dcad9bf1
+  metadata.gz: 737256fad5c987fa2ac603cf3708da959127a33ab9b27d164ceff858b71987b9
+  data.tar.gz: 144352db7686d19d9c330887069287da88de456276cc17aaeeaeb3c1de7a3281
 SHA512:
-  metadata.gz: 0f652cf44f9d18eca35304d1660ed3967d39c60dff42bcc05043607fada17d427308b7052a4b474c71d8a65462f86970838771471b6f1dd7a89accabc31ddd27
-  data.tar.gz: 386030a8bd3c603264ed9f534e1188eb5710fe67777ffc9634a9c318e8bac4153d2716bffbf9c34a7ff63999c3af39b2fa6db3b324abc5093467a33b144b41b8
+  metadata.gz: 83ec370e06c18bf9d62ec3ed445daf78dc5cbff825a85ff017cc7b814efb62f86e68022f7577734dd01ddf7e2f74b4b59de4b40b9c07656e83d0859ba6a4333d
+  data.tar.gz: 9106373ca7878dcc75c596f1fa44d420980c50cb09f5b63a1110d4e02dc63f02dafe3d1bc0d4de38a75d5678d964e3b8f12a720a722d2f593934e2f6be97f818

data/lib/brick/extensions.rb

@@ -547,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
@@ -603,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
@@ -610,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
@@ -636,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,
@@ -644,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
@@ -654,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,
@@ -668,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.
@@ -693,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
@@ -842,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
@@ -1100,6 +1116,11 @@ class Object
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
+          @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
+                           if (excl_parts = excl.split('.')).first == table_name
+                             s << excl_parts.last
+                           end
+                         end
           @_brick_bt_descrip = model._br_bt_descrip
           @_brick_hm_counts = model._br_hm_counts
           @_brick_join_array = join_array
@@ -1108,9 +1129,7 @@ class Object
         is_pk_string = nil
         if (pk_col = model&.primary_key)
           code << "  def show\n"
-          code << (find_by_id = "    id = params[:id]&.split(/[\\/,_]/)
-    id = id.first if id.is_a?(Array) && id.length == 1
-    @#{singular_table_name} = #{model.name}.find(id)\n")
+          code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
@@ -1121,25 +1140,59 @@ class Object
                    params[:id]&.split(/[\/,_]/)
                  end
             id = id.first if id.is_a?(Array) && id.length == 1
-            instance_variable_set("@#{singular_table_name}".to_sym, model.find(id))
+            instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
           end
         end
 
         # By default, views get marked as read-only
-        unless is_swagger # model.readonly # (relation = relations[model.table_name]).key?(:isView)
-          code << "  # (Define :new, :create)\n"
+        # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          code << "  def new\n"
+          code << "    @#{singular_table_name} = #{model.name}.new\n"
+          code << "  end\n"
+          self.define_method :new do
+            ::Brick.set_db_schema(params)
+            instance_variable_set("@#{singular_table_name}".to_sym, model.new)
+          end
+
+          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
+
+          code << "  def create\n"
+          code << "    @#{singular_table_name} = #{model.name}.create(#{params_name})\n"
+          code << "  end\n"
+          self.define_method :create do
+            ::Brick.set_db_schema(params)
+            if (is_json = request.content_type == 'application/json') && (col = params['_brick_exclude'])
+              session[:_brick_exclude] = ((session[:_brick_exclude]&.split(',') || []) + ["#{table_name}.#{col}"]).join(',')
+              render json: { result: ::Brick.exclude_column(table_name, col) }
+            elsif is_json && (col = params['_brick_unexclude'])
+              if (excls = ((session[:_brick_exclude]&.split(',') || []) - ["#{table_name}.#{col}"]).join(',')).empty?
+                session.delete(:_brick_exclude)
+              else
+                session[:_brick_exclude] = excls
+              end
+              render json: { result: ::Brick.unexclude_column(table_name, col) }
+            else
+              instance_variable_set("@#{singular_table_name}".to_sym,
+                                    model.send(:create, send(params_name_sym)))
+            end
+          end
 
-          if model.primary_key
+          if pk_col
             # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
             # end
 
             is_need_params = true
-            # code << "  # (Define :edit, and :destroy)\n"
+            code << "  def edit\n"
+            code << "    #{find_by_name}\n"
+            code << "  end\n"
+            self.define_method :edit do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+            end
+
             code << "  def update\n"
-            code << find_by_id
-            params_name = "#{singular_table_name}_params"
-            code << "    @#{singular_table_name}.update(#{params_name})\n"
+            code << "    #{find_by_name}.update(#{params_name})\n"
             code << "  end\n"
             self.define_method :update do
               ::Brick.set_db_schema(params)
@@ -1158,27 +1211,50 @@ class Object
               #   return
               end
 
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = find_obj))
+              obj.send(:update, send(params_name_sym))
+            end
+
+            code << "  def destroy\n"
+            code << "    #{find_by_name}.destroy\n"
+            code << "  end\n"
+            self.define_method :destroy do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj.send(:destroy))
+            end
+          end
+
+          code << "private\n" if pk_col || is_need_params
+
+          if pk_col
+            code << "  def find_#{singular_table_name}
+    id = params[:id]&.split(/[\\/,_]/)
+    @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+  end\n"
+            self.define_method :find_obj do
               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, (obj = model.find(id)))
-              obj = obj.first if obj.is_a?(Array)
-              obj.send(:update, send(params_name = params_name.to_sym))
+              model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
             end
           end
 
           if is_need_params
-            code << "private\n"
             code << "  def #{params_name}\n"
+            permits = model.columns_hash.keys.map(&:to_sym)
+            permits_txt = permits.map(&:inspect) +
+                          model.reflect_on_all_associations.select { |assoc| assoc.macro == :has_many && assoc.options[:through] }.map do |assoc|
+                            permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
+                            "#{assoc.name.to_s.singularize}_ids: []"
+                          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_txt.join(', ')})\n"
             code << "  end\n"
             self.define_method(params_name) do
-              params.require(require_name.to_sym).permit(model.columns_hash.keys)
+              params.require(require_name.to_sym).permit(permits)
             end
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
           end
-        end
+        # end
         code << "end # #{namespace_name}#{class_name}\n\n"
       end # class definition
       [built_controller, code]

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

@@ -58,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)
@@ -130,27 +132,24 @@ module Brick
                                end
                   case args.first
                   when 'index'
-                    hms_columns << if hm_assoc.macro == :has_many
+                    hm_entry = +"'#{hm_assoc.name}' => [#{assoc_name.inspect}"
+                    hm_entry << if hm_assoc.macro == :has_many
+                                   if hm_fk_name # %%% Can remove this check when multiple foreign keys to same destination becomes bulletproof
                                      set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
-                                                'nil'
-                                              else
-                                                # Postgres column names are limited to 63 characters
-                                                attrib_name = "_br_#{assoc_name}_ct"[0..62]
-                                                "#{obj_name}.#{attrib_name} || 0"
-                                              end
-                                     if hm_fk_name
-"<%= ct = #{set_ct}
-     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
-                                     else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-"#{assoc_name}\n"
-                                     end
-                                   else # has_one
-                                     # 0..62 because Postgres column names are limited to 63 characters
-"<%= descrips = @_brick_bt_descrip[#{hm.first.inspect}][ho_class = #{hm[1].klass.name}]
-     ho_txt = ho_class.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
-     ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
-     ho_id&.first ? link_to(ho_txt, send(\"#\{ho_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt %>\n"
+                                                 'nil'
+                                               else
+                                                 # Postgres column names are limited to 63 characters
+                                                 "#{obj_name}.#{"_br_#{assoc_name}_ct"[0..62]} || 0"
+                                               end
+                                     ", #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
                                    end
+                                 else # has_one
+                                   # 0..62 because Postgres column names are limited to 63 characters
+                                   ", nil, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
+                                 end
+                    hm_entry << ']'
+                    puts hm_entry
+                    hms_columns << hm_entry
                   when 'show', 'update'
                     hm_stuff << if hm_fk_name
                                   "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
@@ -176,6 +175,9 @@ module Brick
                               end.html_safe
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
               css = +"<style>
+h1, h3 {
+  margin-bottom: 0;
+}
 #dropper {
   background-color: #eee;
 }
@@ -197,19 +199,41 @@ table {
   box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
 }
 
-table thead tr th, table tr th {
+tr th {
   background-color: #009879;
   color: #fff;
   text-align: left;
 }
-#headerTop th:hover, #headerTop th:hover {
+#headerTop tr th {
+  position: relative;
+}
+#headerTop tr th .exclude {
+  position: absolute;
+  display: none;
+  top: 0;
+  right: 0;
+}
+#headerTop tr th:hover {
   background-color: #18B090;
 }
-table thead tr th a, table tr th a {
+#exclusions {
+  font-size: 0.7em;
+}
+#exclusions div {
+  border: 1px solid blue;
+  display: inline-block;
+  cursor: copy;
+}
+#headerTop tr th:hover .exclude {
+  display: inline;
+  cursor: pointer;
+  color: red;
+}
+tr th a {
   color: #80FFB8;
 }
 
-table th, table td {
+tr th, tr td {
   padding: 0.2em 0.5em;
 }
 
@@ -255,6 +279,7 @@ a.big-arrow {
 }
 .dimmed {
   background-color: #C0C0C0;
+  text-align: center;
 }
 .orphan {
   color: red;
@@ -283,8 +308,8 @@ input+svg.revert {
   color: #FFF;
 }
 </style>
-<% is_includes_dates = nil
 
+<% is_includes_dates = nil
 def is_bcrypt?(val)
   val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
 end
@@ -416,8 +441,19 @@ function setHeaderSizes() {
     for (var i = 0; i < row.childNodes.length; ++i) {
       node = row.childNodes[i];
       if (node.nodeType === 1) {
-        var style = tr.childNodes[i].style;
-        style.minWidth = style.maxWidth = getComputedStyle(node).width;
+        var th = tr.childNodes[i];
+        th.style.minWidth = th.style.maxWidth = getComputedStyle(node).width;
+        if (#{pk&.present? ? 'i > 0' : 'true'}) {
+          // Add <span> at the end
+          var span = document.createElement(\"SPAN\");
+          span.className = \"exclude\";
+          span.innerHTML = \"X\";
+          span.addEventListener(\"click\", function (e) {
+            e.stopPropagation();
+            doFetch(\"POST\", {_brick_exclude: this.parentElement.getAttribute(\"x-order\")});
+          });
+          th.appendChild(span);
+        }
       }
     }
     if (isEmpty) headerTop.appendChild(tr);
@@ -425,6 +461,18 @@ function setHeaderSizes() {
   grid.style.marginTop = \"-\" + getComputedStyle(headerTop).height;
   // console.log(\"end\");
 }
+function doFetch(method, payload, success) {
+  payload.authenticity_token = <%= session[:_csrf_token].inspect.html_safe %>;
+  if (!success) {
+    success = function (p) {p.text().then(function (response) {
+      var result = JSON.parse(response).result;
+      if (result) location.href = location.href;
+    });};
+  }
+  var options = {method: method, headers: {\"Content-Type\": \"application/json\"}};
+  if (payload) options.body = JSON.stringify(payload);
+  return fetch(location.href, options).then(success);
+}
 if (headerTop) {
   setHeaderSizes();
   window.addEventListener('resize', function(event) {
@@ -459,8 +507,8 @@ if (headerTop) {
     });
     btnImport.addEventListener(\"click\", function () {
       fetch(changeout(<%= #{path_obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'text/tab-separated-values' },
+        method: \"PATCH\",
+        headers: { \"Content-Type\": \"text/tab-separated-values\" },
         body: droppedTSV
       }).then(function (tsvResponse) {
         btnImport.style.display = \"none\";
@@ -538,6 +586,7 @@ if (headerTop) {
    if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
      description %><br><%
    end
+   # FILTER PARAMETERS
    if @_brick_params&.present? %>
   <% if @_brick_params.length == 1 # %%% Does not yet work with composite keys
        k, id = @_brick_params.first
@@ -549,55 +598,78 @@ if (headerTop) {
        end
      end %>
   (<%= link_to 'See all #{model_plural.split('::').last}', #{path_obj_name.pluralize}_path %>)
+<% end
+   # COLUMN EXCLUSIONS
+   if @_brick_excl&.present? %>
+  <div id=\"exclusions\">Excluded columns:
+  <% @_brick_excl.each do |excl| %>
+    <div class=\"colExclusion\"><%= excl %></div>
+  <% end %>
+  </div>
+  <script>
+    [... document.getElementsByClassName(\"colExclusion\")].forEach(function (excl) {
+      excl.addEventListener(\"click\", function () {
+        doFetch(\"POST\", {_brick_unexclude: this.innerHTML});
+      });
+    });
+  </script>
 <% end %>
-<br>
 <table id=\"headerTop\">
 <table id=\"#{table_name}\">
-  <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)) ||
+  <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%=
+     # Consider getting the name from the association -- hm.first.name -- if a more \"friendly\" alias should be used for a screwy table name
+     cols = {#{hms_keys = []
+               hms_headers.map do |hm|
+                 hms_keys << (assoc_name = (assoc = hm.first).name.to_s)
+                 "#{assoc_name.inspect} => [#{(assoc.options[:through] && !assoc.through_reflection).inspect}, #{assoc.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
+               end.join(', ')}}
+     col_keys = @#{table_name}.columns.each_with_object([]) do |col, s|
+       col_name = col.name
+       next if @_brick_incl&.exclude?(col_name) ||
+               (#{(pk || []).inspect}.include?(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? %><%
-       if (bt = bts[col_name]) %>
-         <%= \" 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 %><%= \" x-order=\\\"#\{col_name}\\\"\".html_safe if true # Currently we always allow click to sort
-         %>><%= col_name %><%
-       end
-    %></th><%
+       s << col_name
+       cols[col_name] = col
      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
-    "#{h[1]} #{h[2]} %></th>" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-        else
-    "#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
-        end
-      end.join
-  }</tr></thead>
-
+     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) }
+     end
+     @_brick_sequence.reject! { |nm| @_brick_excl.include?(nm) } if @_brick_excl # Reject exclusions
+     @_brick_sequence.each_with_object(+'') do |col_name, s|
+       if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
+         s << '<th'
+         s << \" title=\\\"#\{col.comment}\\\"\" if col.respond_to?(:comment) && !col.comment.blank?
+         s << if (bt = bts[col_name])
+                # Allow sorting for any BT except polymorphics
+                \"#\{' x-order=\"' + bt.first.to_s + '\"' unless bt[2]}>BT \" +
+                bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
+              else # Normal column
+                \"#\{' x-order=\"' + col_name + '\"' if true}>#\{col_name}\"
+              end
+       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].name.underscore.tr('/', '_').pluralize}_path\"))}\")
+       else # Bad column name!
+         s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
+       end
+       s << '</th>'
+     end.html_safe
+  %></tr></thead>
   <tbody>
-  <% @#{table_name}.each do |#{obj_name}| %>
+  <% @#{table_name}.each do |#{obj_name}|
+       hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
-    <% col_order.each do |col_name|
+    <% @_brick_sequence.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
-      <td>
-      <% if (bt = bts[col_name]) %>
-        <% if bt[2] # Polymorphic?
+      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name)%>><%
+         if (bt = bts[col_name])
+           if bt[2] # Polymorphic?
              bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
              base_class = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class.name.underscore
              poly_id = #{obj_name}.send(\"#\{bt.first\}_id\")
-             %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\",
-                           send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
+             %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\", send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
            else
              bt_txt = (bt_class = bt[1].first.first).brick_descrip(
                # 0..62 because Postgres column names are limited to 63 characters
@@ -606,14 +678,29 @@ if (headerTop) {
              bt_txt ||= \"<span class=\\\"orphan\\\">&lt;&lt; Orphaned ID: #\{val} >></span>\".html_safe if val
              bt_id = bt_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) } %>
           <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
-          <%#= Previously was:  bt_obj = bt[1].first.first.find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt[1].first.first.name.underscore\}_path\".to_sym, bt_obj.send(bt[1].first.first.primary_key.to_sym))) if bt_obj %>
-        <% end %>
-      <% else %>
-        <%= hide_bcrypt(val) %>
-      <% end %>
-      </td>
+        <% end
+         elsif (hms_col = hms_cols[col_name])
+           if hms_col.length == 1 %>
+         <%= hms_col.first %>
+        <% else
+             klass = (col = cols[col_name])[1]
+             txt = if col[2] == 'HO'
+                     descrips = @_brick_bt_descrip[col_name.to_sym][klass]
+                     ho_txt = klass.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
+                     ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
+                     ho_id&.first ? link_to(ho_txt, send(\"#\{klass.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt
+                   else
+                     \"#\{hms_col[1] || 'View'\} #\{hms_col.first}\"
+                   end %>
+         <%= link_to txt, send(\"#\{klass.name.underscore.tr('/', '_').pluralize}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
+        <% end
+         elsif cols.key?(col_name)
+      %><%= hide_bcrypt(val) %><%
+         else # Bad column name!
+      %>?<%
+         end
+    %></td>
     <% end %>
-    #{hms_columns.each_with_object(+'') { |hm_col, s| s << "<td>#{hm_col}</td>" }}
   </tr>
   <% end %>
   </tbody>

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -190,6 +190,15 @@ module Brick
       [bts, hms]
     end
 
+    def exclude_column(table, col)
+      puts "Excluding #{table}.#{col}"
+      true
+    end
+    def unexclude_column(table, col)
+      puts "Unexcluding #{table}.#{col}"
+      true
+    end
+
     # Switches Brick auto-models on or off, for all threads
     # @api public
     def enable_models=(value)

metadata

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