brick 1.0.211 → 1.0.213

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7950119f788fe1cac3fde68806f2b4a1145da0cf17ff0d47363b102be9c69933
-  data.tar.gz: 33bb7d89a0744890d4450afde332dbd0f0635a8d3acd0beb4107cf4e44ff9718
+  metadata.gz: 02a0436d0c71a40e1aa3858e4fdf20822f32b02864e621964bce288b8b21ad60
+  data.tar.gz: 8257218e3c1e9c26842753590e627802842c67dec93891aec7139fd2f31d67c0
 SHA512:
-  metadata.gz: 959c6ada7e03de34f566ad6059a4431ea66d2be9f12764de3edb3760074a70f3e91354e9052bc3c1a74eed4d5d7a274a78cf490195815b736b02f282ffe03d47
-  data.tar.gz: a87abaf8c878fecda93fc6751bae171e5194b6b63d933f83ba331191aee701859d3022754f68af3d730c25add0cc0a8174246fd18913040bed75ec700ba2b543
+  metadata.gz: 222b736da74b699a1f352ffff9f087f39048fceaf995dc28733823b4d38271c0bc04ecba506fb6fd027a7f39883009baede3d9c70f81a46dc023f692d6c831e4
+  data.tar.gz: bdee88e65dad07aa66b6ce9458a44ba8d1ad069b937d5bceae65f020162107336b6d7619aee03ed4c56c25a3e38b4c17ce0352677883426802dfe28ac3c8567a

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
@@ -404,6 +429,19 @@ module Brick
       end
     end
 
+    def acts_as_list_cols
+      @mutex.synchronize { @acts_as_list || {} }
+    end
+
+    # Get something like:
+    #   { 'on_call_list' => { _brick_default: [:last_name, :first_name] } }
+    #   { 'on_call_list' => { _brick_default: :sequence } }
+    def acts_as_list_cols=(position_cols)
+      @mutex.synchronize do
+        @acts_as_list ||= position_cols
+      end
+    end
+
     def metadata_columns
       @mutex.synchronize { @metadata_columns ||= ['created_at', 'updated_at', 'deleted_at'] }
     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')
@@ -196,6 +196,33 @@ module ActiveRecord
       def _brick_monetized_attributes
         @_brick_monetized_attributes ||= respond_to?(:monetized_attributes) ? monetized_attributes.values : {}
       end
+
+      # def acts_as_list(aal_cols = nil)
+      #   if aal_cols
+      #     aal_cols = [aal_cols] unless aal_cols.is_a?(Array)
+      #     @acts_as_list_cols = aal_cols.each_with_object([]) do |aal_col, s|
+      #       if column_names.include?(aal_col = aal_col.to_s) && !s.include?(aal_col)
+      #         s << aal_col
+      #       end
+      #     end
+      #   else
+      #     if [:integer, :bigint].include?(columns_hash['position']&.type)
+      #       @acts_as_list_cols = ['position']
+      #     else
+      #       return
+      #     end
+      #   end
+      #   # Override save in order to update neighbours when necessary
+      #   alias _brick_save save
+      #   def save
+      #     # @acts_as_list_cols
+      #     # -1
+      #     @acts_as_list_cols.each do |aal_col|
+      #       binding.pry if (aal_change = changes[aal_col])
+      #     end
+      #     _brick_save
+      #   end
+      # end
     end
 
     def self.brick_parse_dsl(join_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
@@ -230,11 +257,7 @@ module ActiveRecord
             end
             if first_parts
               if (parts = prefix + first_parts + [parts[-1]]).length > 1 && klass
-                unless is_polymorphic
-                  s = join_array
-                  parts[0..-3].each { |v| s = s[v.to_sym] }
-                  s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
-                end
+                join_array.add_parts(parts) unless is_polymorphic
                 translations[parts[0..-2].join('.')] = klass
               end
               if klass&.column_names.exclude?(parts.last) &&
@@ -538,7 +561,11 @@ module ActiveRecord
     end
 
     def self.brick_where(*args)
-      (relation = all).brick_where(*args)
+      all.brick_where(*args)
+    end
+
+    def self.brick_group(*args, withhold_ids: true, **kwargs)
+      all.brick_group(*args, withhold_ids: withhold_ids, **kwargs)
     end
 
   private
@@ -612,27 +639,36 @@ module ActiveRecord
       pluck(selects)
     end
 
-    def _brick_querying(*args, withhold_ids: nil, params: {}, order_by: nil, translations: {},
+    def brick_group(*args, **kwargs)
+      grouping = args[0].is_a?(Array) ? args[0] : args
+      _brick_querying(select_values.frozen? ? select_values.dup : select_values,
+                      grouping: grouping, **kwargs)
+      self
+    end
+
+    def _brick_querying(*args, grouping: nil, withhold_ids: nil, params: {}, order_by: nil, translations: {},
                         join_array: ::Brick::JoinArray.new,
                         cust_col_override: nil,
                         brick_col_names: nil)
       selects = args[0].is_a?(Array) ? args[0] : args
-      if selects.present? && cust_col_override.nil? # See if there's any fancy ones in the select list
-        idx = 0
-        while idx < selects.length
-          v = selects[idx]
-          if v.is_a?(String) && v.index('.')
-            # No prefixes and not polymorphic
-            pieces = self.brick_parse_dsl(join_array, [], translations, false, dsl = "[#{v}]")
-            (cust_col_override ||= {})[v.tr('.', '_').to_sym] = [pieces, dsl, true]
-            selects.delete_at(idx)
-          else
-            idx += 1
+      unless cust_col_override
+        if selects.present? # See if there's any fancy ones in the select list
+          idx = 0
+          while idx < selects.length
+            v = selects[idx]
+            if v.is_a?(String) && v.index('.')
+              # No prefixes and not polymorphic
+              pieces = self.brick_parse_dsl(join_array, [], translations, false, dsl = "[#{v}]")
+              (cust_col_override ||= {})[v.tr('.', '_').to_sym] = [pieces, dsl, true]
+              selects.delete_at(idx)
+            else
+              idx += 1
+            end
           end
+        elsif selects.is_a?(Hash) && params.empty? # Make sense of things if they've passed in only params
+          params = selects
+          selects = []
         end
-      elsif selects.is_a?(Hash) && params.empty? && cust_col_override.nil? # Make sense of things if they've passed in only params
-        params = selects
-        selects = []
       end
       is_add_bts = is_add_hms = !cust_col_override
 
@@ -710,6 +746,14 @@ module ActiveRecord
         end
       end
 
+      # Establish necessary JOINs for any custom GROUP BY columns
+      grouping&.each do |group_item|
+        # JOIN in all the same ways as the pathing describes
+        if group_item.is_a?(String) && (ref_parts = group_item.split('.')).length > 1
+          join_array.add_parts(ref_parts)
+        end
+      end
+
       if join_array.present?
         if ActiveRecord.version < Gem::Version.new('4.2')
           self.joins_values += join_array # Same as:  joins!(join_array)
@@ -725,7 +769,9 @@ module ActiveRecord
 
       # CUSTOM COLUMNS
       # ==============
-      (cust_col_override || (!withhold_ids && klass._br_cust_cols))&.each do |k, cc|
+      cust_cols = cust_col_override
+      cust_cols ||= klass._br_cust_cols unless withhold_ids
+      cust_cols&.each do |k, cc|
         brick_links # Intentionally create a relation duplicate
         if @_brick_rel_dup.respond_to?(k) # Name already taken?
           # %%% Use ensure_unique here in this kind of fashion:
@@ -753,7 +799,7 @@ module ActiveRecord
             col_alias = "#{col_prefix}#{k}__#{table_name.tr('.', '_')}_#{cc_part.first}"
           elsif brick_col_names ||
                 used_col_aliases.key?(col_alias = k.to_s) # This sets a simpler custom column name if possible
-            while cc_part_idx > 0 &&
+            while cc_part_idx >= 0 &&
                   (col_alias = "#{col_prefix}#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
                   used_col_aliases.key?(col_alias)
               cc_part_idx -= 1
@@ -880,7 +926,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
@@ -988,6 +1034,20 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
         klass._br_hm_counts.delete(n)
       end
 
+      # Rewrite the group values to reference table and correlation names built out by AREL
+      if grouping
+        group2 = (gvgu = (group_values + grouping).uniq).each_with_object([]) do |v, s|
+          if v.is_a?(Symbol) || (v_parts = v.split('.')).length == 1
+            s << v
+          elsif (tbl_name = brick_links[v_parts[0..-2].join('.')]&.split('.')&.last)
+            s << "#{tbl_name}.#{v_parts.last}"
+          else
+            s << v
+          end
+        end
+        group!(*group2)
+      end
+
       unless wheres.empty?
         # Rewrite the wheres to reference table and correlation names built out by AREL
         where_nots = {}
@@ -998,7 +1058,7 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
           if (v_parts = v.first.split('.')).length == 1
             (is_not ? where_nots : s)[v.first] = v.last
           else
-            tbl_name = brick_links[v_parts.first].split('.').last
+            tbl_name = brick_links[v_parts[0..-2].join('.')].split('.').last
             (is_not ? where_nots : s)["#{tbl_name}.#{v_parts.last}"] = v.last
           end
         end
@@ -1069,8 +1129,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')
@@ -1095,13 +1155,9 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
         # && joins_values.empty? # Make sure we don't step on any toes if they've already specified JOIN things
         ja = nil
         opts.each do |k, v|
+          # JOIN in all the same ways as the pathing describes
           if k.is_a?(String) && (ref_parts = k.split('.')).length > 1
-            # JOIN in all the same ways as the pathing describes
-            linkage = (ja ||= ::Brick::JoinArray.new)
-            ref_parts[0..-3].each do |prefix_part|
-              linkage = linkage[prefix_part.to_sym]
-            end
-            linkage[ref_parts[-2].to_sym] = nil
+            (ja ||= ::Brick::JoinArray.new).add_parts(ref_parts)
           end
         end
         if ja&.present?
@@ -1846,6 +1902,12 @@ class Object
           end
         end
 
+        # Apply any acts_as_list things
+        if (aal_col = ::Brick.config.acts_as_list_cols.fetch(matching, nil))
+          new_model_class.send(:acts_as_list, aal_col.to_sym)
+          code << "  acts_as_list :#{aal_col}\n"
+        end
+
         # Auto-support Ransack if it's present
         if self.respond_to?(:ransackable_attributes)
           def self.ransackable_attributes(auth_object = nil)
@@ -2078,6 +2140,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 +2519,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 +3166,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,11 @@ erDiagram
 <%=  erd_sidelinks(shown_classes, hm_class).html_safe %>
 <% end
    def dt_lookup(dt)
-     { 'integer' => 'int', }[dt] || dt&.tr(' ', '_') || 'int'
+     { '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 +197,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/join_array.rb

@@ -165,6 +165,12 @@ module Brick
         end.tap { |member| push(member) }
       end
     end
+
+    def add_parts(parts)
+      s = self
+      parts[0..-3].each { |part| s = s[part.to_sym] }
+      s[parts[-2].to_sym] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
+    end
   end
 
   class JoinHash < Hash

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 = 213
 
     # 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

data/lib/generators/brick/seeds_generator.rb

@@ -53,7 +53,12 @@ module Brick
           s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
         end
       end
-      seeds = +"# Seeds file for #{ActiveRecord::Base.connection.current_database}:\n"
+      seeds = +'# Seeds file for '
+      if (arbc = ActiveRecord::Base.connection).respond_to?(:current_database) # SQLite3 can't do this!
+        seeds << "#{arbc.current_database}:\n"
+      elsif (filename = arbc.instance_variable_get(:@connection_parameters)&.fetch(:database, nil))
+        seeds << "#{filename}:\n"
+      end
       done = []
       fks = {}
       stuck = {}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.211
+  version: 1.0.213
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-24 00:00:00.000000000 Z
+date: 2024-04-01 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