brick 1.0.15 → 1.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dbd4fef7ab5c2796e75a0bce86316be00ebceb02aa5a0b8053f75b27d433c57
-  data.tar.gz: daa2802b2fec6533ccfed8fa9178129c6633f92b83fb092fefa48a657cb36e9b
+  metadata.gz: add7e232024e140e2fb089ef158600e2a2a955efd787dc986769b43b4b1f6d24
+  data.tar.gz: a45d187a7b739f90b1fede46dfc9f63a2057a3410d052e0ad57322f4741ebfee
 SHA512:
-  metadata.gz: 33f97461748561fb21900ccb1b4b39c13803e68e04fea807851b467587907577a10bd5b5a2470cde5f50bca019d3cc986b512545bf700477028f68751bb95e6a
-  data.tar.gz: 97605afbe32e2509800f510ca2984651cc196c048a6267fa31d65363815bc6f4484955aacd45fae1553fe70453f1bee283766812a2f92678bc35e516ec594738
+  metadata.gz: '0897e041c617f0e1e695d0402784184ce2f7ec575d9b0e7a7b1b59b2efbcb40a4de28bcbe2eb124f576dddb8e7371f572c67ee3b19120cd281bf3358249b4508'
+  data.tar.gz: fc7a4a93a7d2409f4aa82fb3dbf23710aaad45a1dca1193c8cbcefa86d5d9061a773214c8fe0dd02375660bfb6e5a9856df3a202f57a73990e79d23850918f9b

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

@@ -176,25 +176,27 @@ module ActiveRecord
   end
 end
 
-module ActiveSupport::Dependencies
-  class << self
-    # %%% Probably a little more targeted than other approaches we've taken thusfar
-    # This happens before the whole parent check
-    alias _brick_autoload_module! autoload_module!
-    def autoload_module!(*args)
-      into, const_name, qualified_name, path_suffix = args
-      if (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)&.constantize)
-        ::Brick.sti_models[qualified_name] = { base: base_class }
-        # Build subclass and place it into the specially STI-namespaced module
-        into.const_set(const_name.to_sym, klass = Class.new(base_class))
-        # %%% used to also have:  autoload_once_paths.include?(base_path) || 
-        autoloaded_constants << qualified_name unless autoloaded_constants.include?(qualified_name)
-        klass
-      elsif (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{const_name}", nil)&.constantize)
-        # Build subclass and place it into Object
-        Object.const_set(const_name.to_sym, klass = Class.new(base_class))
-      else
-        _brick_autoload_module!(*args)
+if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works with previous non-zeitwerk auto-loading
+  module ActiveSupport::Dependencies
+    class << self
+      # %%% Probably a little more targeted than other approaches we've taken thusfar
+      # This happens before the whole parent check
+      alias _brick_autoload_module! autoload_module!
+      def autoload_module!(*args)
+        into, const_name, qualified_name, path_suffix = args
+        if (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)&.constantize)
+          ::Brick.sti_models[qualified_name] = { base: base_class }
+          # Build subclass and place it into the specially STI-namespaced module
+          into.const_set(const_name.to_sym, klass = Class.new(base_class))
+          # %%% used to also have:  autoload_once_paths.include?(base_path) || 
+          autoloaded_constants << qualified_name unless autoloaded_constants.include?(qualified_name)
+          klass
+        elsif (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{const_name}", nil)&.constantize)
+          # Build subclass and place it into Object
+          Object.const_set(const_name.to_sym, klass = Class.new(base_class))
+        else
+          _brick_autoload_module!(*args)
+        end
       end
     end
   end
@@ -333,7 +335,6 @@ class Object
             singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
             macro = if assoc[:is_bt]
                       # Try to take care of screwy names if this is a belongs_to going to an STI subclass
-                      # binding.pry if assoc[:fk] == 'issue_severity_id'
                       if (primary_class = assoc.fetch(:primary_class, nil)) &&
                          (sti_inverse_assoc = primary_class.reflect_on_all_associations.find { |a| a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key })
                         assoc_name = sti_inverse_assoc.options[:inverse_of].to_s || assoc_name
@@ -403,12 +404,13 @@ class Object
             fks.each do |fk|
               source = nil
               this_hmt_fk = if fks.length > 1
-                              singular_assoc_name = ActiveSupport::Inflector.singularize(fk.first[:inverse][:assoc_name])
+                              singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
                               source = fk.last
-                              through = ActiveSupport::Inflector.pluralize(fk.first[:alternate_name])
+                              through = fk.first[:alternate_name].pluralize
                               "#{singular_assoc_name}_#{hmt_fk}"
                             else
-                              through = fk.first[:assoc_name]
+                              source = fk.last unless hmt_fk.singularize == fk.last
+                              through = fk.first[:assoc_name].pluralize
                               hmt_fk
                             end
               code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
@@ -452,7 +454,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)
@@ -461,9 +463,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
@@ -627,10 +656,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
 
@@ -706,7 +737,7 @@ 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] }
+      unless 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])

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)
@@ -76,34 +76,35 @@ 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
+                table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
+                                .each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
                 hms_columns = +'' # Used for 'index'
-                # puts skip_hms.inspect
                 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>
@@ -111,7 +112,7 @@ 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
 
                 css = "<style>
@@ -156,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); });
   }
@@ -174,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];
@@ -189,6 +249,7 @@ 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}\">
@@ -210,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>
@@ -219,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 %>
@@ -234,47 +295,78 @@ 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, :date, :datetime, :decimal %>
+        <%= val %>
+      <% 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}| %>
-        <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
@@ -296,12 +388,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
+        # 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
 
         # Find associative tables that can be set up for has_many :through
         ::Brick.relations.each do |_key, tbl|

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 15
+    TINY = 18
 
     # 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,18 @@ 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
+    end
+
 
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.

data/lib/generators/brick/install_generator.rb

@@ -94,7 +94,7 @@ module Brick
 # # Any tables or views you'd like to skip when auto-creating models
 # Brick.exclude_tables = ['custom_metadata', 'version_info']
 
-# # Class for auto-generated models to inherit from
+# # Class that auto-generated models should inherit from
 # Brick.models_inherit_from = ApplicationRecord
 
 # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
@@ -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.15
+  version: 1.0.18
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-26 00:00:00.000000000 Z
+date: 2022-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord