brick 1.0.16 → 1.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30eeeb5fb81003f790234885589b29f227b7f4f2d498accb07da5cd8ea425084
-  data.tar.gz: 1841386c2750c2aef744a7ee555b649e2fc0298367684d261faf64297b8430c0
+  metadata.gz: 57a1d4e3774c90984cfc435d9ed87e42b74c364b01fd7ced7df740f5005b935e
+  data.tar.gz: 8222088ef88ca48cd90144c8503638644195f2d593ff95d7b2e3530304ac6fb2
 SHA512:
-  metadata.gz: 64c5747800aaa5469f2ff2b0be3ae5056fa383c6d246e7aff15b19eb4a588e15e72f5d1ecb384879b3b7f175cab28961fb4984e11d5994085b215f442d722389
-  data.tar.gz: ec3418092244d97b3006086aaf0484ee1ab4342cf2c16716239f7127c8e23056dc25e1714e51523bdb8f87fb6b88c322dabefb096fe7bf0b1f695568b636d4b8
+  metadata.gz: 2b785c34e1a21563232ae54f6af25989fe02b73f92eb1327b27d6f21e80b7e353a5995305c4c1188dda885465a196f87fb5979a13c3e6a0219d4895dc59593dd
+  data.tar.gz: bd2018d48dad15f51d7a87e39d2710bde9a5becbe969e741004bf730f57faecbd84a81a2f75cfdd60c2ff48f239fe6c5c8d3f47b4b2f79e355b7f100f9bb7943

data/lib/brick/config.rb

@@ -66,12 +66,12 @@ module Brick
     end
 
     # Skip creating a has_many association for these
-    def skip_hms
-      @mutex.synchronize { @skip_hms }
+    def exclude_hms
+      @mutex.synchronize { @exclude_hms }
     end
 
-    def skip_hms=(skips)
-      @mutex.synchronize { @skip_hms = skips }
+    def exclude_hms=(skips)
+      @mutex.synchronize { @exclude_hms = skips }
     end
 
     # Associations to treat as a has_one
@@ -108,7 +108,7 @@ module Brick
     end
 
     def exclude_tables
-      @mutex.synchronize { @exclude_tables }
+      @mutex.synchronize { @exclude_tables || [] }
     end
 
     def exclude_tables=(value)

data/lib/brick/extensions.rb

@@ -137,7 +137,6 @@ module ActiveRecord
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
         if ::Brick.sti_models.key?(type_name)
-          # puts ['X', self.name, type_name].inspect
           _brick_find_sti_class(type_name)
         else
           # This auto-STI is more of a brute-force approach, building modules where needed
@@ -149,7 +148,7 @@ module ActiveRecord
           if ::Brick.config.sti_namespace_prefixes&.key?("::#{module_name}::") ||
              ::Brick.config.sti_namespace_prefixes&.key?("#{module_name}::")
             _brick_find_sti_class(type_name)
-          elsif File.exists?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
+          elsif File.exist?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
             _brick_find_sti_class(type_name) # Find this STI class normally
           else
             # Build missing prefix modules if they don't yet exist
@@ -243,10 +242,10 @@ class Object
  
                  # Adjust for STI if we know of a base model for the requested model name
                  table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
-                               base_model.table_name
-                             else
-                               ActiveSupport::Inflector.pluralize(singular_table_name)
-                             end
+                                base_model.table_name
+                              else
+                                ActiveSupport::Inflector.pluralize(singular_table_name)
+                              end
  
                  # Maybe, just maybe there's a database table that will satisfy this need
                  if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
@@ -454,7 +453,7 @@ class Object
 
         if model.primary_key
           code << "  def show\n"
-          code << "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n"
+          code << (find_by_id = "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n")
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
@@ -463,9 +462,36 @@ class Object
         end
 
         # By default, views get marked as read-only
-        unless (relation = relations[model.table_name]).key?(:isView)
-          code << "  # (Define :new, :create, :edit, :update, and :destroy)\n"
-          # Get column names for params from relations[model.table_name][:cols].keys
+        unless false # model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          code << "  # (Define :new, :create)\n"
+
+          if model.primary_key
+            is_need_params = true
+            # code << "  # (Define :edit, and :destroy)\n"
+            code << "  def update\n"
+            code << find_by_id
+            params_name = "#{singular_table_name}_params"
+            code << "    @#{singular_table_name}.update(#{params_name})\n"
+            code << "  end\n"
+            self.define_method :update do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(params[:id].split(','))))
+              obj = obj.first if obj.is_a?(Array)
+              obj.send(:update, send(params_name = params_name.to_sym))
+            end
+          end
+
+          if is_need_params
+            code << "private\n"
+            code << "  def params\n"
+            code << "    params.require(:#{singular_table_name}).permit(#{model.columns_hash.keys.map { |c| c.to_sym.inspect }.join(', ')})\n"
+            code << "  end\n"
+            self.define_method(params_name) do
+              params.require(singular_table_name.to_sym).permit(model.columns_hash.keys)
+            end
+            private params_name
+            # Get column names for params from relations[model.table_name][:cols].keys
+          end
         end
         code << "end # #{class_name}\n\n"
       end # class definition
@@ -495,9 +521,9 @@ module ActiveRecord::ConnectionHandling
   end
 
   def _brick_reflect_tables
-      if (relations = ::Brick.relations).empty?
-      # Only for Postgres?  (Doesn't work in sqlite3)
-      # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
+    if (relations = ::Brick.relations).empty?
+    # Only for Postgres?  (Doesn't work in sqlite3)
+    # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
     schema_sql = 'SELECT NULL AS table_schema;'
     case ActiveRecord::Base.connection.adapter_name
@@ -587,6 +613,25 @@ module ActiveRecord::ConnectionHandling
         end
       end
 
+      # # Add unique OIDs
+      # if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      #   ActiveRecord::Base.execute_sql(
+      #     "SELECT c.oid, n.nspname, c.relname
+      #     FROM pg_catalog.pg_namespace AS n
+      #       INNER JOIN pg_catalog.pg_class AS c ON n.oid = c.relnamespace
+      #     WHERE c.relkind IN ('r', 'v')"
+      #   ).each do |r|
+      #     next if ['pg_catalog', 'information_schema', ''].include?(r['nspname']) ||
+      #       ['ar_internal_metadata', 'schema_migrations'].include?(r['relname'])
+      #     relation = relations.fetch(r['relname'], nil)
+      #     if relation
+      #       (relation[:oid] ||= {})[r['nspname']] = r['oid']
+      #     else
+      #       puts "Where is #{r['nspname']} #{r['relname']} ?"
+      #     end
+      #   end
+      # end
+
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2'
         sql = ActiveRecord::Base.send(:sanitize_sql_array, [
@@ -629,10 +674,12 @@ module ActiveRecord::ConnectionHandling
       puts "\nClasses that can be built from views:"
       views.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
     end
-    # pp relations; nil
 
-    # relations.keys.each { |k| ActiveSupport::Inflector.singularize(k).camelize.constantize }
-    # Layout table describes permissioned hierarchy throughout
+    # Try to load the initializer pretty danged early
+    if File.exist?(brick_initialiser = Rails.root.join('config/initializers/brick.rb'))
+      load brick_initialiser
+      ::Brick.load_additional_references
+    end
   end
 end
 
@@ -677,7 +724,7 @@ module Brick
         missing << fk[0] unless relations.key?(fk[0])
         missing << primary_table unless is_class || relations.key?(primary_table)
         unless missing.empty?
-          tables = relations.reject { |k, v| v.fetch(:isView, nil) }.keys.sort
+          tables = relations.reject { |_k, v| v.fetch(:isView, nil) }.keys.sort
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
           return
         end
@@ -686,7 +733,7 @@ module Brick
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
           return
         end
-        if (redundant = bts.find { |k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == primary_table })
+        if (redundant = bts.find { |_k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == primary_table })
           if is_class && !redundant.last.key?(:class)
             redundant.last[:primary_class] = primary_class # Round out this BT so it can find the proper :source for a HMT association that references an STI subclass
           else
@@ -708,19 +755,19 @@ module Brick
         # assoc_bt[:inverse_of] = primary_class.reflect_on_all_associations.find { |a| a.foreign_key == bt[1] }
       end
 
-      unless is_class || ::Brick.config.skip_hms&.any? { |skip| fk[0] == skip[0] && fk[1] == skip[1] && primary_table == skip[2] }
-        cnstr_name = "hm_#{cnstr_name}"
-        if (assoc_hm = hms.fetch(cnstr_name, nil))
-          assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
-          assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
-          assoc_hm[:inverse] = assoc_bt
-        else
-          assoc_hm = hms[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
-          hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-          hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
-        end
-        assoc_bt[:inverse] = assoc_hm
+      return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
+
+      cnstr_name = "hm_#{cnstr_name}"
+      if (assoc_hm = hms.fetch(cnstr_name, nil))
+        assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
+        assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
+        assoc_hm[:inverse] = assoc_bt
+      else
+        assoc_hm = hms[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+        hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
+        hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
       end
+      assoc_bt[:inverse] = assoc_hm
       # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
     end
   end

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

@@ -32,7 +32,7 @@ module Brick
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
         # Skip creating a has_many association for these
-        ::Brick.skip_hms = app.config.brick.fetch(:skip_hms, nil)
+        ::Brick.exclude_hms = app.config.brick.fetch(:exclude_hms, nil)
 
         # Has one relationships
         ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
@@ -51,14 +51,11 @@ module Brick
                 # Need to return true if we can fill in the blanks for a missing one
                 # args will be something like:  ["index", ["categories"]]
                 model = args[1].map(&:camelize).join('::').singularize.constantize
-                if (
-                      is_template_exists = model && (
-                        ['index', 'show'].include?(args.first) || # Everything has index and show
-                        # Only CRU stuff has create / update / destroy
-                        (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
-                      )
-                    )
-                  instance_variable_set(:@_brick_model, model)
+                if is_template_exists = model && (
+                    ['index', 'show'].include?(args.first) || # Everything has index and show
+                    # Only CRU stuff has create / update / destroy
+                    (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
+                  ) && instance_variable_set(:@_brick_model, model)
                 end
               end
               is_template_exists
@@ -76,33 +73,32 @@ module Brick
                 bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
                 # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
                 # as well as any possible polymorphic associations
-                skip_hms = {}
+                exclude_hms = {}
                 associatives = hms.each_with_object({}) do |hmt, s|
                   if (through = hmt.last.options[:through])
-                    skip_hms[through] = nil
+                    exclude_hms[through] = nil
                     s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
                   elsif hmt.last.inverse_of.nil?
                     puts "SKIPPING #{hmt.last.name.inspect}"
                     # %%% If we don't do this then below associative.name will find that associative is nil
-                    skip_hms[hmt.last.name] = nil
+                    exclude_hms[hmt.last.name] = nil
                   end
                 end
 
-                schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
                 hms_columns = +'' # Used for 'index'
                 hms_headers = hms.each_with_object([]) do |hm, s|
-                  next if skip_hms.key?(hm.last.name)
+                  next if exclude_hms.key?((hm_assoc = hm.last).name)
 
                   if args.first == 'index'
-                    hm_fk_name = if hm.last.options[:through]
-                                   associative = associatives[hm.last.name]
+                    hm_fk_name = if hm_assoc.options[:through]
+                                   associative = associatives[hm_assoc.name]
                                    "'#{associative.name}.#{associative.foreign_key}'"
                                  else
-                                   hm.last.foreign_key
+                                   hm_assoc.foreign_key
                                  end
-                    hms_columns << if hm.last.macro == :has_many
+                    hms_columns << if hm_assoc.macro == :has_many
 "<td>
-  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
+  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
 </td>\n"
                                    else # has_one
 "<td>
@@ -110,9 +106,15 @@ module Brick
 </td>\n"
                                    end
                   end
-                  s << [hm.last, "H#{hm.last.macro == :has_one ? 'O' : 'M'}#{'T' if hm.last.options[:through]} #{hm.first}"]
+                  s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
                 end
-
+              end
+              if @_brick_model
+                schema_options = ::Brick.db_schemas.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
+                table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
+                                .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
                 css = "<style>
 table {
   border-collapse: collapse;
@@ -155,15 +157,43 @@ table tbody tr.active-row {
 }
 
 a.show-arrow {
+  font-size: 1.5em;
+  text-decoration: none;
+}
+a.big-arrow {
   font-size: 2.5em;
   text-decoration: none;
 }
-</style>"
+.wide-input {
+  display: block;
+  overflow: hidden;
+}
+.wide-input input[type=text] {
+  width: 100%;
+}
+.dimmed {
+  background-color: #C0C0C0;
+}
+input[type=submit] {
+  background-color: #004998;
+  color: #FFF;
+}
+.right {
+  text-align: right;
+}
+</style>
+<% def is_bcrypt?(val)
+  val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
+end
+def hide_bcrypt(val)
+  is_bcrypt?(val) ? '(hidden)' : val
+end %>"
 
                 script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
+var brickSchema;
 if (schemaSelect) {
-  var brickSchema = changeout(location.href, \"_brick_schema\");
+  brickSchema = changeout(location.href, \"_brick_schema\");
   if (brickSchema) {
     [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
   }
@@ -173,8 +203,39 @@ if (schemaSelect) {
     location.href = changeout(location.href, \"_brick_schema\", this.value);
   });
 }
+[... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
+  if (brickSchema)
+    form.action = changeout(form.action, \"_brick_schema\", brickSchema);
+  form.addEventListener('submit', function (ev) {
+    [... ev.target.getElementsByTagName(\"SELECT\")].forEach(function (select) {
+      if (select.value === \"^^^brick_NULL^^^\")
+        select.value = null;
+    });
+    return true;
+  });
+});
+
+var tblSelect = document.getElementById(\"tbl\");
+if (tblSelect) {
+  tblSelect.value = changeout(location.href);
+  tblSelect.addEventListener(\"change\", function () {
+    var lhr = changeout(location.href, null, this.value);
+    if (brickSchema)
+      lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
+    location.href = lhr;
+  });
+}
+
 function changeout(href, param, value) {
   var hrefParts = href.split(\"?\");
+  if (param === undefined || param === null) {
+    hrefParts = hrefParts[0].split(\"://\");
+    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
+    if (value === undefined)
+      return pathParts[1];
+    else
+      return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
+  }
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
   params = params.reduce(function (s, v) { var parts = v.split(\"=\"); s[parts[0]] = parts[1]; return s; }, {});
   if (value === undefined) return params[param];
@@ -188,10 +249,11 @@ function changeout(href, param, value) {
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"tbl\">#{table_options}</select>
 <h1>#{model_name.pluralize}</h1>
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
 <table id=\"#{table_name}\">
-  <thead><tr>#{"<th></th>" if pk }
+  <thead><tr>#{"<th></th>" if pk}
   <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
      @#{table_name}.columns.map(&:name).each do |col| %>
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
@@ -209,7 +271,7 @@ function changeout(href, param, value) {
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'show-arrow' } %></td>" if pk }
+    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk}
     <% #{obj_name}.attributes.each do |k, val| %>
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
       <td>
@@ -218,9 +280,9 @@ function changeout(href, param, value) {
         # send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))
         # Otherwise we get stuff like:
         # ActionView::Template::Error (undefined method `vehicle_path' for #<ActionView::Base:0x0000000033a888>) %>
-        <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
+        <%= bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
       <% else %>
-        <%= val %>
+        <%= hide_bcrypt(val) %>
       <% end %>
       </td>
     <% end %>
@@ -233,47 +295,83 @@ function changeout(href, param, value) {
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
-                when 'show'
-  "#{css}
-    <p style=\"color: green\"><%= notice %></p>#{"
-    <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
-    <h1>#{model_name}: <%= (obj = @#{obj_name}.first).brick_descrip %></h1>
-    <%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
+                when 'show', 'update'
+"#{css}
+<p style=\"color: green\"><%= notice %></p>#{"
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"tbl\">#{table_options}</select>
+<h1>#{model_name}: <%= (obj = @#{obj_name}&.first)&.brick_descrip || controller_name %></h1>
+<%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
+<% if obj %>
+  <%= # path_options = [obj.#{pk}]
+   # path_options << { '_brick_schema':  } if 
+   # url = send(:#{model_name.underscore}_path, obj.#{pk})
+   form_for(obj) do |f| %>
   <table>
   <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
       @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
     <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
-    <% if (bt = bts[k]) %>
-      BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
+    <% if (bt = bts[k])
+      # Add a final member in this array with descriptive options to be used in <select> drop-downs
+      bt_name = bt[1].name
+      # %%% Only do this if the user has permissions to edit this bt field
+      if bt.length < 4
+        bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
+        bt[1].order(:#{pk}).each { |obj| option_detail << [obj.brick_descrip, obj.#{pk}] }
+      end %>
+      BT <%= \"#\{bt.first\}-\" unless bt_name.underscore == bt.first.to_s %><%= bt_name %>
     <% else %>
       <%= k %>
     <% end %>
     </th>
     <td>
-    <% if (bt = bts[k]) %>
-      <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
-    <% else %>
-      <%= val %>
+    <% if (bt = bts[k]) # bt_obj.brick_descrip
+      html_options = { prompt: \"Select #\{bt_name\}\" }
+      html_options[:class] = 'dimmed' unless val %>
+      <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
+      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_class = bt_name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+    <% else case #{model_name}.column_for_attribute(k).type
+      when :string, :text %>
+        <% if is_bcrypt?(val) # || .readonly? %>
+          <%= hide_bcrypt(val) %>
+        <% else %>
+          <div class=\"wide-input\"><%= f.text_field k.to_sym %></div>
+        <% end %>
+      <% when :boolean %>
+        <%= f.check_box k.to_sym %>
+      <% when :integer, :decimal, :float, :date, :datetime, :time, :timestamp
+          # What happens when keys are 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'
+          # ActiveUUID gem created a new :uuid type %>
+        <%= val %>
+      <% when :binary, :primary_key %>
+      <% end %>
     <% end %>
     </td>
     </tr>
-  <% end %>
+    <% end %>
+    <tr><td colspan=\"2\" class=\"right\"><%= f.submit %></td></tr>
   </table>
+  <% end %>
 
   #{hms_headers.map do |hm|
     next unless (pk = hm.first.klass.primary_key)
   "<table id=\"#{hm_name = hm.first.name.to_s}\">
     <tr><th>#{hm.last}</th></tr>
-    <% if (collection = @#{obj_name}.first.#{hm_name}).empty? %>
+    <% collection = @#{obj_name}.first.#{hm_name}
+    collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
+    if collection.empty? %>
       <tr><td>(none)</td></tr>
     <% else %>
-      <% collection.order(#{pk.inspect}).uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
-        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm_singular_name}_path(#{hm_singular_name}.#{pk})) %></td></tr>
+      <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
+        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
       <% end %>
     <% end %>
   </table>" end.join}
+<% end %>
 #{script}"
 
                 end
@@ -295,23 +393,9 @@ function changeout(href, param, value) {
           end
         end
 
-        # Additional references (virtual foreign keys)
-        if (ars = ::Brick.config.additional_references)
-          ars.each do |fk|
-            ::Brick._add_bt_and_hm(fk[0..2])
-          end
-        end
-
-        # Find associative tables that can be set up for has_many :through
-        ::Brick.relations.each do |_key, tbl|
-          tbl_cols = tbl[:cols].keys
-          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
-          # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
-          # foreign keys then it can act as an associative table and thus be used with has_many :through.
-          if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?
-            fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
-          end
-        end
+        # Just in case it hadn't been done previously when we tried to load the brick initialiser,
+        # go make sure we've loaded additional references (virtual foreign keys).
+        ::Brick.load_additional_references
       end
     end
   end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -208,12 +208,12 @@ module Brick
     # Skip creating a has_many association for these
     # (Uses the same exact three-part format as would define an additional_reference)
     # @api public
-    def skip_hms=(skips)
+    def exclude_hms=(skips)
       if skips
         skips = skips.call if skips.is_a?(Proc)
         skips = skips.to_a unless skips.is_a?(Array)
         skips = [skips] unless skips.empty? || skips.first.is_a?(Array)
-        Brick.config.skip_hms = skips
+        Brick.config.exclude_hms = skips
       end
     end
 
@@ -244,6 +244,29 @@ module Brick
       Brick.config.sti_namespace_prefixes = snp
     end
 
+    # Load additional references (virtual foreign keys)
+    # This is attempted early if a brick initialiser file is found, and then again as a failsafe at the end of our engine's initialisation
+    # %%% Maybe look for differences the second time 'round and just add new stuff instead of entirely deferring
+    def load_additional_references
+      return if @_additional_references_loaded
+
+      if (ars = ::Brick.config.additional_references)
+        ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2]) }
+        @_additional_references_loaded = true
+      end
+
+      # Find associative tables that can be set up for has_many :through
+      ::Brick.relations.each do |_key, tbl|
+        tbl_cols = tbl[:cols].keys
+        fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
+        # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
+        # foreign keys then it can act as an associative table and thus be used with has_many :through.
+        if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?
+          fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
+        end
+      end
+    end
+
 
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.

data/lib/generators/brick/install_generator.rb

@@ -18,7 +18,7 @@ module Brick
     desc 'Generates an initializer file for configuring Brick'
 
     def create_initializer_file
-      unless File.exists?(filename = 'config/initializers/brick.rb')
+      unless File.exist?(filename = 'config/initializers/brick.rb')
         # See if we can make suggestions for additional_references
         resembles_fks = []
         possible_additional_references = (relations = ::Brick.relations).each_with_object([]) do |v, s|
@@ -47,7 +47,7 @@ module Brick
               if (relations.fetch(f_table = col_down, nil) ||
                  relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
                  # Looks pretty promising ... just make sure a model file isn't present
-                 !File.exists?("app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb")
+                 !File.exist?("app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb")
                 s << "['#{v.first}', '#{col}', '#{f_table}']"
               else
                 resembles_fks << "#{v.first}.#{col}"
@@ -114,7 +114,7 @@ module Brick
 # # Skip creating a has_many association for these
 # # (Uses the same exact three-part format as would define an additional_reference)
 # # Say for instance that we didn't care to display the favourite colours that users have:
-# Brick.skip_hms = [['users', 'favourite_colour_id', 'colours']]
+# Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
 
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
 # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided

metadata

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