brick 1.0.211 → 1.0.212

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7950119f788fe1cac3fde68806f2b4a1145da0cf17ff0d47363b102be9c69933
-  data.tar.gz: 33bb7d89a0744890d4450afde332dbd0f0635a8d3acd0beb4107cf4e44ff9718
+  metadata.gz: 3e954e525ea7a17eea2b33a125283f8af47a7bad1e457780815a8f53e06ed8fc
+  data.tar.gz: 9ded8bfa75d407294eb3e34895d1fc36ffa17767b9cbdeee0c961d6d9e821653
 SHA512:
-  metadata.gz: 959c6ada7e03de34f566ad6059a4431ea66d2be9f12764de3edb3760074a70f3e91354e9052bc3c1a74eed4d5d7a274a78cf490195815b736b02f282ffe03d47
-  data.tar.gz: a87abaf8c878fecda93fc6751bae171e5194b6b63d933f83ba331191aee701859d3022754f68af3d730c25add0cc0a8174246fd18913040bed75ec700ba2b543
+  metadata.gz: 6c2d33f2a6247cc001071929731d2b2543d2b91ba0e8c22afeda7d9fa40e37ae9c3957d4046f8157a34b1549dca8e542de97a58f22b25a312532eed775d3989c
+  data.tar.gz: 4e63b7986eb7b683421ef92d00fe61a3970ed0d24fb57403a89d05c114760ad00310e6c635d66bc0388e5ca26b6c6fd2061574c83e1f70b60f90baa22babcb92

data/lib/brick/config.rb

@@ -238,7 +238,24 @@ module Brick
     end
 
     def treat_as_associative=(tables)
-      @mutex.synchronize { @treat_as_associative = tables }
+      @mutex.synchronize do
+        @treat_as_associative = if tables.is_a?(Hash)
+                                  tables.each_with_object({}) do |v, s|
+                                    # If it's :constellation, or anything else in a hash, we'll take its value
+                                    # (and hopefully in this case that would be either a string or nil)
+                                    dsl = ((v.last.is_a?(Symbol) && v.last) || v.last&.values&.last)
+                                    unless (dsl ||= '').is_a?(String) || dsl.is_a?(Symbol)
+                                      puts "Was really expecting #{v.first} / #{v.last.first&.first} / #{dsl} to be a string, " +
+                                           "so will disregard #{dsl} and just turn on simple constellation view for #{v.first}."
+                                    end
+                                    s[v.first] = v.last.is_a?(Hash) ? dsl : v.last
+                                  end
+                                elsif tables.is_a?(String) # comma-separated list?
+                                  tables.split(',').each_with_object({}) { |v, s| s[v.trim] = nil }
+                                else # Expecting an Array, and have no special presentation
+                                  tables&.each_with_object({}) { |v, s| s[v] = nil }
+                                end
+      end
     end
 
     # Polymorphic associations
@@ -286,6 +303,14 @@ module Brick
       @mutex.synchronize { @model_descrips = descrips }
     end
 
+    def erd_show_columns
+      @mutex.synchronize { @erd_show_columns ||= [] }
+    end
+
+    def erd_show_columns=(descrips)
+      @mutex.synchronize { @erd_show_columns = descrips }
+    end
+
     def sti_namespace_prefixes
       @mutex.synchronize { @sti_namespace_prefixes ||= {} }
     end

data/lib/brick/extensions.rb

@@ -107,7 +107,7 @@ module ActiveRecord
       # has_one_attached, has_many_attached, and has_rich_text
       def _activestorage_actiontext_fields
         fields = [[], [], {}]
-        if !(self <= ActiveStorage::Blob) && respond_to?(:generated_association_methods) # ActiveStorage
+        if Object.const_defined?('ActiveStorage') && respond_to?(:generated_association_methods) && !(self <= ::ActiveStorage::Blob) # ActiveStorage
           generated_association_methods.instance_methods.each do |method_sym|
             method_str = method_sym.to_s
             fields[0] << method_str[0..-13].to_sym if method_str.end_with?('_attachment=') # has_one_attached
@@ -124,7 +124,7 @@ module ActiveRecord
       end
 
       def _active_storage_name(col_name)
-        if Object.const_defined?('ActiveStorage') && (self <= ActiveStorage::Attachment || self <= ActiveStorage::Blob)
+        if Object.const_defined?('ActiveStorage') && (self <= ::ActiveStorage::Attachment || self <= ::ActiveStorage::Blob)
           if (col_str = col_name.to_s).end_with?('_attachments')
             col_str[0..-13]
           elsif col_str.end_with?('_blobs')
@@ -880,7 +880,7 @@ module ActiveRecord
                          through_sources.push(src_ref) unless src_ref.belongs_to?
                          from_clause = +"#{_br_quoted_name(through_sources.first.table_name)} br_t0"
                          # ActiveStorage will not get the correct count unless we do some extra filtering later
-                         tbl_nm = 'br_t0' if Object.const_defined?('ActiveStorage') && through_sources.first.klass <= ActiveStorage::Attachment
+                         tbl_nm = 'br_t0' if Object.const_defined?('ActiveStorage') && through_sources.first.klass <= ::ActiveStorage::Attachment
                          fk_col = through_sources.shift.foreign_key
 
                          idx = 0
@@ -1069,8 +1069,8 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
       end
 
       # ActiveStorage compatibility
-      selects << 'service_name' if klass.name == 'ActiveStorage::Blob' && ActiveStorage::Blob.columns_hash.key?('service_name')
-      selects << 'blob_id' if klass.name == 'ActiveStorage::Attachment' && ActiveStorage::Attachment.columns_hash.key?('blob_id')
+      selects << 'service_name' if klass.name == 'ActiveStorage::Blob' && ::ActiveStorage::Blob.columns_hash.key?('service_name')
+      selects << 'blob_id' if klass.name == 'ActiveStorage::Attachment' && ::ActiveStorage::Attachment.columns_hash.key?('blob_id')
       # Pay gem compatibility
       selects << 'processor' if klass.name == 'Pay::Customer' && Pay::Customer.columns_hash.key?('processor')
       selects << 'customer_id' if klass.name == 'Pay::Subscription' && Pay::Subscription.columns_hash.key?('customer_id')
@@ -2078,6 +2078,23 @@ class Object
           #     add_csp_hash
           #   end
           # end
+
+          # Associate and unassociate in an N:M relation
+          self.define_method :associate do
+            if (base_class = (model = params['modelName']&.constantize).base_class)
+              args = params['args']
+              record = base_class.create(args[0] => args[1], args[2] => args[3])
+              add_csp_hash
+              render json: { data: record.id }
+            end
+          end
+          self.define_method :unassociate do
+            if (base_class = (model = params['modelName']&.constantize).base_class)
+              base_class.find_by(base_class._pk_as_array&.first => params['id']).delete
+              add_csp_hash
+            end
+          end
+
           self.define_method :orphans do
             instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params).first))
             add_csp_hash
@@ -2440,7 +2457,7 @@ class Object
             if (new_obj = model.new(new_params)).respond_to?(:serializable_hash)
               # Convert any Filename objects with nil into an empty string so that #encode can be called on them
               new_obj.serializable_hash.each do |k, v|
-                new_obj.send("#{k}=", ActiveStorage::Filename.new('')) if v.is_a?(ActiveStorage::Filename) && !v.instance_variable_get(:@filename)
+                new_obj.send("#{k}=", ::ActiveStorage::Filename.new('')) if v.is_a?(::ActiveStorage::Filename) && !v.instance_variable_get(:@filename)
               end if Object.const_defined?('ActiveStorage')
             end
             instance_variable_set("@#{singular_table_name}".to_sym, new_obj)
@@ -3087,7 +3104,7 @@ module Brick
       else
         res_name = (tbl_name_parts = tbl_name.split('.'))[0..-2].first
         res_name << '.' if res_name
-        (res_name ||= +'') << relation&.fetch(:resource, nil) || tbl_name_parts.last
+        (res_name ||= +'') << (relation&.fetch(:resource, nil) || tbl_name_parts.last)
       end
 
       res_parts = ((mode == :singular) ? res_name.singularize : res_name).split('.')

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

@@ -198,7 +198,7 @@ function linkSchemas() {
 
         # Treat ActiveStorage::Blob metadata as JSON
         if ::Brick.config.table_name_prefixes.fetch('active_storage_', nil) == 'ActiveStorage' &&
-           ActiveStorage.const_defined?('Blob')
+           ::ActiveStorage.const_defined?('Blob')
           unless (md = (::Brick.config.model_descrips ||= {})).key?('ActiveStorage::Blob')
             md['ActiveStorage::Blob'] = '[filename]'
           end
@@ -643,7 +643,7 @@ window.addEventListener(\"popstate\", linkSchemas);
               end
               # ActiveStorage has_one_attached and has_many_attached needs additional filtering on the name
               if (as_name = hm_assoc.klass&._active_storage_name(hm_assoc.name)) # ActiveStorage HMT
-                prefix = 'attachments.' if hm_assoc.through_reflection&.klass&.<= ActiveStorage::Attachment
+                prefix = 'attachments.' if hm_assoc.through_reflection&.klass&.<= ::ActiveStorage::Attachment
                 keys << ["#{prefix}name", as_name]
               end
               keys.to_h
@@ -1315,9 +1315,26 @@ end
     # or
     # Rails.application.reloader.to_prepare do ... end
     self.class.class_exec { include ::Brick::Rails::FormTags } unless respond_to?(:brick_grid)
-    # Write out the mega-grid
+
+    #{# Determine if we should render an N:M representation or the standard "mega_grid"
+      taa = ::Brick.config.treat_as_associative&.fetch(res_name, nil)
+      options = {}
+      options[:prefix] = prefix unless prefix.blank?
+      if taa.is_a?(String) # Write out a constellation
+        representation = :constellation
+        "
+    brick_constellation(@#{res_name}, #{options.inspect}, bt_descrip: @_brick_bt_descrip, bts: bts)"
+      elsif taa.is_a?(Symbol) # Write out a bezier representation
+        "
+    brick_bezier(@#{res_name}, #{options.inspect}, bt_descrip: @_brick_bt_descrip, bts: bts)"
+      else # Write out the mega-grid
+        representation = :grid
+        "
     brick_grid(@#{res_name}, @_brick_sequence, @_brick_incl, @_brick_excl,
-               cols, bt_descrip: @_brick_bt_descrip, poly_cols: poly_cols, bts: bts, hms_keys: #{hms_keys.inspect}, hms_cols: {#{hms_columns.join(', ')}}) %>
+               cols, bt_descrip: @_brick_bt_descrip,
+               poly_cols: poly_cols, bts: bts, hms_keys: #{hms_keys.inspect}, hms_cols: {#{hms_columns.join(', ')}})"
+      end}
+ %>
 
 #{"<hr><%= link_to(\"New #{new_path_name = "new_#{path_obj_name}_path"
                            obj_name}\", #{new_path_name}, { class: '__brick' }) if respond_to?(:#{new_path_name}) %>" unless @_brick_model.is_view?}
@@ -1727,10 +1744,11 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
   }
   <%= \"  showErd();\n\" if (@_brick_erd || 0) > 0
 %></script>
-
-<% end
-
-%><script>
+<% end %>
+"
+              end
+              if representation == :grid
+                "<script>
 <% # Make column headers sort when clicked
    # %%% Create a smart javascript routine which can do this client-side %>
 [... document.getElementsByTagName(\"TH\")].forEach(function (th) {

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

@@ -84,7 +84,7 @@ module Brick::Rails::FormBuilder
           opts = enum_type.send(:mapping)&.each_with_object([]) { |v, s| s << [v.first, v.first] } || []
           out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, options)
         else
-          digit_pattern = col_type == :integer ? '\d*' : '\d*(?:\.\d*|)'
+          digit_pattern = col_type == :integer ? '(?:-|)\d*' : '(?:-|)\d*(?:\.\d*|)'
           # Used to do this for float / decimal:  self.number_field method.to_sym
           out << self.text_field(method.to_sym, { pattern: digit_pattern, class: 'check-validity' })
         end

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

@@ -3,27 +3,9 @@ module Brick::Rails::FormTags
   def brick_grid(relation = nil, sequence = nil, inclusions = nil, exclusions = nil,
                  cols = {}, bt_descrip: nil, poly_cols: nil, bts: {}, hms_keys: [], hms_cols: {},
                  show_header: nil, show_row_count: nil, show_erd_button: nil, show_in_app_button: nil, show_new_button: nil, show_avo_button: nil, show_aa_button: nil)
-    # When a relation is not provided, first see if one exists which matches the controller name
-    unless (relation ||= instance_variable_get("@#{controller_name}".to_sym))
-      # Failing that, dig through the instance variables with hopes to find something that is an ActiveRecord::Relation
-      case (collections = _brick_resource_from_iv).length
-      when 0
-        puts '#brick_grid:  Not having been provided with a collection to work from, searched through all instance variables to find an ActiveRecord::Relation.  None could be found.'
-        return
-      when 1 # If there's only one type match then simply get the first one, hoping that this is what they intended
-        relation = instance_variable_get(iv = (chosen = collections.first).last.first)
-        puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}.
-              Failing that, have searched through instance variables and found #{iv} of type #{chosen.first.name}.
-              Running with it!"
-      else
-        myriad = collections.each_with_object([]) { |c, s| c.last.each { |iv| s << "#{iv} (#{c.first.name})" } }
-        puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}, and then searched through all instance variables.
-              Found ActiveRecord::Relation objects of multiple types:
-                #{myriad.inspect}
-              Not knowing which of these to render, have erred on the side of caution and simply provided this warning message."
-        return
-      end
-    end
+    # When a relation is not provided, first see if one exists which matches the controller name or
+    # something has turned up in the instance variables.
+    relation ||= (instance_variable_get("@#{controller_name}".to_sym) || _brick_resource_from_iv)
 
     nfc = Brick.config.sidescroll.fetch(relation.table_name, nil)&.fetch(:num_frozen_columns, nil) ||
           Brick.config.sidescroll.fetch(:num_frozen_columns, nil) ||
@@ -458,8 +440,8 @@ function onImagesLoaded(event) {
                    elsif hma.include?(k) # has_many_attached
                      { sql_type: 'binary', type: :files }
                    elsif rtans&.key?(k) # has_rich_text
-                    k = rtans[k]
-                    { sql_type: 'varchar', type: :text }
+                     k = rtans[k]
+                     { sql_type: 'varchar', type: :text }
                    end
           col = (ActiveRecord::ConnectionAdapters::Column.new(
                   '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(**kwargs)
@@ -541,6 +523,159 @@ function onImagesLoaded(event) {
     end
   end # brick_form_for
 
+  # ------------------------------------------
+  # Our cool N:M checkbox constellation editor
+  def brick_constellation(relation = nil, options = {}, x_axis: nil, y_axis: nil, bt_descrip: nil, bts: {})
+    x_axis, x_list, y_axis, y_list, existing = _n_m_prep(relation, x_axis, y_axis)
+
+    # HTML for constellation
+    prefix = options[:prefix]
+    out = +"<form action=\"#{"#{prefix}/" if prefix}brick_constellation\">
+<table id=\"#{table_name = relation.table_name.split('.').last}\" class=\"shadow\">
+  <thead><tr><td></td>
+"
+    # Header row with X axis values
+    x_list.each do |x_item|
+      out << "    <th>#{x_item.first}</th>
+"
+    end
+    out << "  </tr></thead>
+  <tbody>
+"
+    obj_path = "#{relation.klass._brick_index(:singular)}_path".to_sym
+    link_arrow = link_to('⇛', send(obj_path, '____'), { class: 'big-arrow' })
+    pk_as_array = relation.klass._pk_as_array
+    y_list.each do |y_item|
+      out << "  <tr><th>#{y_item.first}</th>
+"
+      x_list.each do |x_item|
+        checked = existing.find { |e| e[1] == x_item.last && e[2] == y_item.last }
+        item_id = pk_as_array.map { |pk_part| checked.first }.join('%2F') if checked
+        out << "    <td><input type=\"checkbox\" name=\"#{table_name}\" #{"x-id=\"#{item_id}\" " if checked
+                           }\" value=\"#{x_item.last}_#{y_item.last}\"#{' checked' if checked}>
+    #{link_arrow.gsub('____', item_id) if checked}</td>
+"
+      end
+      out << "  </tr>
+"
+    end
+    out << "  </tbody>
+</table>
+<script>
+  var constellation = document.getElementById(\"#{table_name}\");
+  var nextSib,
+      _this;
+  [... constellation.getElementsByTagName(\"INPUT\")].forEach(function (x) {
+    x.addEventListener(\"change\", function (y) {
+      _this = this;
+      if (this.checked) {
+        var ids = this.value.split(\"_\");
+        doFetch(\"POST\", {modelName: \"#{relation.klass.name}\",
+                           args: [#{x_axis[1].inspect}, ids[0], #{y_axis[1].inspect}, ids[1]],
+                           _brick_action: \"/#{prefix}brick_associate\"},
+          function (p) { // If it returns successfully, create an <a> element
+            p.text().then(function (response) {
+              var recordId = JSON.parse(response).data;
+              if (recordId) {
+                console.log(_this.getAttribute(\"x-id\"));
+                var tmp = document.createElement(\"DIV\");
+                tmp.innerHTML = \"#{link_arrow.gsub('"', '\"')}\".replace(\"____\", recordId);
+                _this.parentElement.append(tmp.firstChild);
+              }
+            });
+          }
+        );
+      } else if (nextSib = this.nextElementSibling) {
+        doFetch(\"DELETE\", {modelName: \"#{relation.klass.name}\",
+                id: this.getAttribute(\"x-id\"),
+                _brick_action: \"/#{prefix}brick_associate\"},
+          function (p) { // If it returns successfully, remove the an <a> element
+            _this.parentElement.removeChild(nextSib);
+          }
+        );
+      }
+    });
+  });
+</script>
+</form>
+"
+    out.html_safe
+  end # brick_constellation
+
+  # ---------------------------------
+  # Our cool N:M bezier visualisation
+  # (...... work in progress .......)
+  def brick_bezier(relation = nil, options = {}, x_axis: nil, y_axis: nil, bt_descrip: nil, bts: {})
+    x_axis, x_list, y_axis, y_list, existing = _n_m_prep(relation, x_axis, y_axis)
+    # HTML for constellation
+    # X axis (List on left side)
+    out = +"<table id=\"#{x_axis.first}\" class=\"shadow\">
+  <tbody>
+"
+    x_list.each_with_index { |x_item, idx| out << "    <tr>#{"<th rowspan=\"#{x_list.length}\">#{x_axis.first}</th>" if idx.zero?}<td>#{x_item.first}</td></tr>" }
+    out << "  </tbody>
+</table>
+"
+
+    # Y axis (List on right side)
+    out << "<table id=\"#{y_axis.first}\" class=\"shadow\">
+  <tbody>
+"
+    y_list.each_with_index { |y_item, idx| out << "    <tr><td>#{y_item.first}</td>#{"<th rowspan=\"#{y_list.length}\">#{y_axis.first}</th>" if idx.zero?}</tr>" }
+    out << "  </tbody>
+</table>
+"
+
+    out.html_safe
+  end # brick_bezier
+
+  def _n_m_prep(relation, x_axis, y_axis)
+    relation ||= (instance_variable_get("@#{controller_name}".to_sym) || _brick_resource_from_iv)
+    # Just find the first two BT things at this point
+
+    klass = relation.klass
+    rel = ::Brick.relations&.fetch(relation.table_name, nil)
+    # fk_assocs = rel[:fks].map { |k, fk| [fk[:assoc_name], fk[:fk]] }
+    fk_assocs = klass.reflect_on_all_associations.each_with_object([]) do |assoc, s|
+      s << [assoc.name.to_s, assoc.foreign_key, assoc.klass] if assoc.belongs_to?
+    end
+
+    if (x_axis = fk_assocs.find { |assoc| assoc.include?(x_axis) })
+      fk_assocs -= x_axis
+    end
+    if (y_axis = fk_assocs.find { |assoc| assoc.include?(y_axis) })
+      fk_assocs -= y_axis
+    end
+    y_axis = fk_assocs.shift unless y_axis
+    x_axis = fk_assocs.shift unless x_axis
+    puts "FK Leftovers: #{fk_assocs.join(', ')}" unless fk_assocs.empty?
+
+    existing = relation.each_with_object([]) do |row, s|
+                 row_id = row.send(klass.primary_key)
+                 if (x_id = row.send(x_axis[1])) && (y_id = row.send(y_axis[1]))
+                   s << [row_id, x_id, y_id]
+                 end
+               end
+    x_list = _expand_collection(x_axis.last.all)
+    y_list = _expand_collection(y_axis.last.all)
+    [x_axis, x_list, y_axis, y_list, existing]
+  end
+
+  def _expand_collection(relation)
+    collection, descrip_cols = relation.brick_list
+    details = []
+    obj_pk = relation.klass.primary_key
+    collection&.brick_(:each) do |obj|
+      details << [
+        obj.brick_descrip(
+          descrip_cols&.first&.map { |col2| obj.send(col2.last) },
+          obj_pk
+        ), obj.send(obj_pk)
+      ]
+    end
+    details
+  end
+
   # --------------------------------
   def link_to_brick(*args, **kwargs)
     return unless ::Brick.config.mode == :on
@@ -627,7 +762,7 @@ function onImagesLoaded(event) {
     else
       # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
       # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
-      if (links = _brick_resource_from_iv(true)).length == 1 # If there's only one match then use any text that was supplied
+      if (links = _brick_relation_from_iv(true)).length == 1 # If there's only one match then use any text that was supplied
         link_to_brick(text || links.first.last.join('/'), links.first.first, **kwargs)
       else
         links.each_with_object([]) do |v, s|
@@ -677,7 +812,7 @@ btnAddCol.addEventListener(\"click\", function () {
 private
 
   # Dig through all instance variables with hopes to find any that appear related to ActiveRecord
-  def _brick_resource_from_iv(trim_ampersand = false)
+  def _brick_relation_from_iv(trim_ampersand = false)
     instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
       iv_name = trim_ampersand ? name.to_s[1..-1] : name
       case (val = instance_variable_get(name))
@@ -688,4 +823,26 @@ private
       end
     end
   end
+
+  def _brick_resource_from_iv
+    # Failing that, dig through the instance variables with hopes to find something that is an ActiveRecord::Relation
+    case (collections = _brick_relation_from_iv).length
+    when 0
+      puts '#brick_grid:  Not having been provided with a collection to work from, searched through all instance variables to find an ActiveRecord::Relation.  None could be found.'
+      return
+    when 1 # If there's only one type match then simply get the first one, hoping that this is what they intended
+      relation = instance_variable_get(iv = (chosen = collections.first).last.first)
+      puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}.
+            Failing that, have searched through instance variables and found #{iv} of type #{chosen.first.name}.
+            Running with it!"
+      relation
+    else
+      myriad = collections.each_with_object([]) { |c, s| c.last.each { |iv| s << "#{iv} (#{c.first.name})" } }
+      puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}, and then searched through all instance variables.
+            Found ActiveRecord::Relation objects of multiple types:
+              #{myriad.inspect}
+            Not knowing which of these to render, have erred on the side of caution and simply provided this warning message."
+      return
+    end
+  end
 end

data/lib/brick/frameworks/rails.rb

@@ -173,7 +173,12 @@ erDiagram
 <%=  erd_sidelinks(shown_classes, hm_class).html_safe %>
 <% end
    def dt_lookup(dt)
-     { 'integer' => 'int', }[dt] || dt&.tr(' ', '_') || 'int'
+     puts dt.inspect
+     { 'integer' => 'int', 'character varying' => 'varchar', 'double precision' => 'float',
+       'timestamp without time zone' => 'timestamp',
+       'timestamp with time zone' => 'timestamp',
+       'time without time zone' => 'time',
+       'time with time zone' => 'time' }[dt] || dt&.tr(' ', '_') || 'int'
    end
    callbacks.merge({#{model_short_name.inspect} => #{model.name}}).each do |cb_k, cb_class|
      cb_relation = ::Brick.relations[cb_class.table_name]
@@ -193,6 +198,12 @@ erDiagram
     %>
     <%= \"#\{dt_lookup(cols[fk]&.first)} #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk) %><%
        end
+     end %><%
+     if (erd_sc = Brick.config.erd_show_columns) == true || erd_sc&.include?(cb_class.name)
+       cols&.each do |col|
+         next if pkeys.include?(col.first) || fkeys.include?(col.first) %>
+    <%= \"#\{dt_lookup(col[1]&.first&.to_s)} #\{col.first}\".html_safe %><%
+       end
      end %>
   }
 <% end

data/lib/brick/route_mapper.rb

@@ -287,6 +287,15 @@ module Brick
         #   post("/#{controller_prefix}brick_schema", to: 'brick_gem#schema_create', as: schema_as.to_s)
         # end
 
+        if (associate_as = "#{controller_prefix.tr('/', '_')}brick_associate".to_sym)
+          (
+            !(associate_route = instance_variable_get(:@set).named_routes.find { |route| route.first == associate_as }&.last) ||
+            !associate_route.ast.to_s.include?("/#{controller_prefix}brick_associate/")
+          )
+          post("/#{controller_prefix}brick_associate", to: 'brick_gem#associate', as: associate_as.to_s)
+          delete("/#{controller_prefix}brick_associate", to: 'brick_gem#unassociate')
+        end
+
         if ::Brick.config.add_orphans && (orphans_as = "#{controller_prefix.tr('/', '_')}brick_orphans".to_sym)
           (
             !(orphans_route = instance_variable_get(:@set).named_routes.find { |route| route.first == orphans_as }&.last) ||

data/lib/brick/version_number.rb

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

data/lib/generators/brick/install_generator.rb

@@ -310,6 +310,14 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # # have a table to still be treated as associative, causing HMTs to be auto-generated.)
   # Brick.treat_as_associative = ['flights']
 
+  # # Further, if you want to present a given associative table in various ways then you can choose a 2D
+  # # constellation map of checkboxes, or bezier curves showing the association between a list at the left and at
+  # # the right.  Indicating just :bezier is the same as :bezier_full, which shows the full list of all possible
+  # # things that can be associated.  :bezier_union shows just the ones that are currently wired up, and
+  # # :bezier_excluded, :bezier_excluded_left, or :bezier_excluded_right shows the ones not yet wired up.
+  # Brick.treat_as_associative = { 'flights' => [:bezier, 'departure.code', 'arrival.code'],
+  #                                'crew' => [:constellation, 'flight', 'personnel', '[used ? [used it!] : []]'] }
+
   # # We normally don't show the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\", and also do
   # # not consider them when finding associative tables to support an N:M association.  (That is, ones that can be a
   # # part of a has_many :through association.)  If you want to use different exclusion columns than our defaults
@@ -334,6 +342,14 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
   # Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
 
+  # # ERD SETTINGS
+
+  # # By default the Entity Relationship Diagram fragment which is available to be shown on the Grid page includes
+  # # primary and foreign keys.  In order for it to show all columns in all cases, set this value to +true+:
+  # Brick.config.erd_show_columns = true
+  # # or to show all columns for specific tables, supply an array of model names:
+  # Brick.config.erd_show_columns = ['User', 'OrderDetail']
+
   # # SINGLE TABLE INHERITANCE
 
   # # Specify STI subclasses either directly by name or as a general module prefix that should always relate to a specific

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.211
+  version: 1.0.212
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-24 00:00:00.000000000 Z
+date: 2024-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -285,7 +285,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Create a Rails app from data alone