brick 1.0.210 → 1.0.212

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 803d4790408a0b789ff8086b5b81346581071b260cbc528039fd8cfa8894b7ac
-  data.tar.gz: 4503e1b9feba62d33e83f3fadc25a34b70bf9c661dc750187a3c391e3b24d5e8
+  metadata.gz: 3e954e525ea7a17eea2b33a125283f8af47a7bad1e457780815a8f53e06ed8fc
+  data.tar.gz: 9ded8bfa75d407294eb3e34895d1fc36ffa17767b9cbdeee0c961d6d9e821653
 SHA512:
-  metadata.gz: 1fe28c2a9ca30ef663f28fe79e65e1b2787686c6fce6d5738d9b6addd6070437411d5210e1ba641b28eae5215fb37756f3faa80f246d823d5d553c9db990a427
-  data.tar.gz: daa9bb88c21467075717062c1ede0ab38af4207bf96d9a2495ce84f99850a4d0cb09f4c1c95017cb3862ef915fab85036397375d43518f7bee2d7bd6f1255aed
+  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

@@ -92,11 +92,49 @@ module ActiveRecord
         reflect_on_association(assoc).foreign_type || "#{assoc}_type"
       end
 
-      def _brick_all_fields
-        rtans = if respond_to?(:rich_text_association_names)
-                  rich_text_association_names&.map { |rtan| rtan.to_s.start_with?('rich_text_') ? rtan[10..-1] : rtan }
-                end
-        columns_hash.keys.map(&:to_sym) + (rtans || [])
+      def _brick_all_fields(skip_id = nil)
+        col_names = columns_hash.keys
+        # If it's a composite primary key then allow all the values through
+        # TODO: Should disallow any autoincrement / SERIAL columns
+        if skip_id && (pk_as_array = _pk_as_array).length == 1
+          col_names -= _pk_as_array
+        end
+        hoa, hma, rtans = _activestorage_actiontext_fields
+        col_names.map(&:to_sym) + hoa + hma.map { |as| { as => [] } } + rtans.values
+      end
+
+      # Return three lists of fields for this model --
+      # has_one_attached, has_many_attached, and has_rich_text
+      def _activestorage_actiontext_fields
+        fields = [[], [], {}]
+        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
+            fields[1] << method_str[0..-14].to_sym if method_str.end_with?('_attachments=') # has_many_attached
+          end
+        end
+        if respond_to?(:rich_text_association_names) # ActionText
+          rich_text_association_names&.each do |rtan| # has_rich_text
+            rtan_str = rtan.to_s
+            fields[2][rtan] = rtan_str.start_with?('rich_text_') ? rtan_str[10..-1].to_sym : rtan
+          end
+        end
+        fields
+      end
+
+      def _active_storage_name(col_name)
+        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')
+            col_str[0..-7]
+          end
+        end
+      end
+
+      def _pk_as_array
+        self.primary_key.is_a?(Array) ? self.primary_key : [self.primary_key]
       end
 
       def _br_quoted_name(name)
@@ -147,8 +185,8 @@ module ActiveRecord
           skip_columns = _brick_get_fks + (::Brick.config.metadata_columns || []) + [primary_key]
           dsl = if (descrip_col = columns.find { |c| [:boolean, :binary, :xml].exclude?(c.type) && skip_columns.exclude?(c.name) })
                   "[#{descrip_col.name}]"
-                elsif (pk_parts = self.primary_key.is_a?(Array) ? self.primary_key : [self.primary_key])
-                  "#{name} ##{pk_parts.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
+                else
+                  "#{name} ##{_pk_as_array.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
                 end
           ::Brick.config.model_descrips[name] = dsl
         end
@@ -841,6 +879,8 @@ module ActiveRecord
                          end
                          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
                          fk_col = through_sources.shift.foreign_key
 
                          idx = 0
@@ -934,10 +974,14 @@ module ActiveRecord
           tbl_nm = hm.macro == :has_and_belongs_to_many ? hm.join_table : hm.table_name
           hm_table_name = _br_quoted_name(tbl_nm)
         end
+        # ActiveStorage has_many_attached needs a bit more filtering
+        if (k_str = hm.klass._active_storage_name(k))
+          where_ct_clause = "WHERE #{_br_quoted_name("#{tbl_nm}.name")} = '#{k_str}' "
+        end
         group_bys = ::Brick.is_oracle || is_mssql ? hm_selects : (1..hm_selects.length).to_a
         join_clause = "LEFT OUTER
 JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#{s}") }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{_br_quoted_name(count_column)
-          }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{_br_quoted_name(tbl_alias)}"
+          }) AS c_t_ FROM #{from_clause || hm_table_name} #{where_ct_clause}GROUP BY #{group_bys.join(', ')}) #{_br_quoted_name(tbl_alias)}"
         self.joins_values |= ["#{join_clause} ON #{on_clause.join(' AND ')}"] # Same as:  joins!(...)
       end unless cust_col_override
       while (n = nix.pop)
@@ -1025,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')
@@ -2034,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
@@ -2369,6 +2430,8 @@ class Object
             end
           end
 
+          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
+
           # By default, views get marked as read-only
           # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
           code << "  def new\n"
@@ -2376,7 +2439,11 @@ class Object
           code << "  end\n"
           self.define_method :new do
             _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
-            new_params = model.attribute_names.each_with_object({}) do |a, s|
+            new_params = begin
+                           send(params_name_sym)
+                         rescue
+                         end
+            new_params ||= model.attribute_names.each_with_object({}) do |a, s|
               if (val = params["__#{a}"])
                 # val = case new_obj.class.column_for_attribute(a).type
                 #       when :datetime, :date, :time, :timestamp
@@ -2390,15 +2457,13 @@ 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)
             add_csp_hash
           end
 
-          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
-
           code << "  def create\n"
           code << "    @#{singular_table_name} = #{model.name}.create(#{params_name})\n"
           code << "  end\n"
@@ -2415,8 +2480,7 @@ class Object
               end
               render json: { result: ::Brick.unexclude_column(table_name, col) }
             else
-              @_lookup_context.instance_variable_set("@#{singular_table_name}".to_sym,
-                                                     (created_obj = model.send(:create, send(params_name_sym))))
+              created_obj = model.send(:create, send(params_name_sym))
               @_lookup_context.instance_variable_set(:@_brick_model, model)
               if created_obj.errors.empty?
                 index
@@ -2493,7 +2557,16 @@ class Object
               if (upd_hash ||= upd_params).fetch(model.inheritance_column, nil)&.strip == ''
                 upd_hash[model.inheritance_column] = nil
               end
-              obj.send(:update, upd_hash || upd_params)
+              # Do not clear out a has_many_attached field if it already has an entry and nothing is supplied
+              hoa, hma, rtans = model._activestorage_actiontext_fields
+              all_params = params[singular_table_name]
+              hma.each do |hma_field|
+                if upd_hash.fetch(hma_field) == [''] && # No new attachments...
+                   all_params&.fetch("_brick_attached_#{hma_field}", nil) # ...and there is something existing
+                  upd_hash.delete(hma_field)
+                end
+              end
+              obj.send(:update, upd_hash)
               if obj.errors.any? # Surface errors to the user in a flash message
                 flash.now.alert = (obj.errors.errors.map { |err| "<b>#{err.attribute}</b> #{err.message}" }.join(', '))
               end
@@ -2543,7 +2616,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields)
+            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields(true))
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
             code << "  end\n"
@@ -3031,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
@@ -641,6 +641,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                 type_col = hm_assoc.inverse_of&.foreign_type || hm_assoc.type
                 keys << [type_col, poly_type]
               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
+                keys << ["#{prefix}name", as_name]
+              end
               keys.to_h
             end
 
@@ -1310,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?}
@@ -1506,7 +1528,7 @@ end
 
     if (pk = hm.first.klass.primary_key)
       hm_singular_name = (hm_name = hm.first.name.to_s).singularize.underscore
-      obj_br_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "br_#{hm_singular_name}.#{pk_part}" }.join(', ')
+      obj_br_pk = hm.first.klass._pk_as_array.map { |pk_part| "br_#{hm_singular_name}.#{pk_part}" }.join(', ')
       poly_fix = if (poly_type = (hm.first.options[:as] && hm.first.type))
                    "
                      # Let's fix an unexpected \"feature\" of AR -- when going through a polymorphic has_many
@@ -1722,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
@@ -110,6 +110,41 @@ module Brick::Rails::FormBuilder
                    ::Brick::Rails.display_binary(val)
                  end
         end
+      when :file, :files
+        if attached = begin
+                        self.object.send(method)
+                      rescue
+                      end
+          # Show any existing image(s)
+          existing = []
+          got_one = nil
+          (attached.respond_to?(:attachments) ? attached.attachments : [attached]).each do |attachment|
+            next unless (blob = attachment.blob)
+
+            existing << blob.key
+            out << "#{blob.filename}<br>"
+            url = begin
+                    self.object.send(method)&.url
+                  rescue StandardError => e
+                    # Another possible option:
+                    # Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+                    Rails.application.routes.url_helpers.rails_storage_proxy_path(attachment, only_path: true)
+                  end
+            out << if url
+                     "<img src=\"#{url}\" title=\"#{val}\">"
+                   else # Convert the raw binary to a Base64 image
+                     ::Brick::Rails.display_binary(attachment.download, 500_000)
+                   end
+            got_one = true
+            out << '<br>'
+          end
+          out << 'Update: ' if got_one
+        end
+        out << self.hidden_field("_brick_attached_#{method}", value: existing.join(',')) unless existing.blank?
+        # Render a "Choose File(s)" input element
+        args = [method.to_sym]
+        args << { multiple: true } if col&.type == :files
+        out << self.file_field(*args)
       when :primary_key
         is_revert = false
       when :json, :jsonb

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) ||
@@ -445,19 +427,25 @@ function onImagesLoaded(event) {
           obj.send("#{model.brick_foreign_type(v.first)}=", v[1].first&.first&.name)
         end
       end if obj.new_record?
-      rtans = model.rich_text_association_names if model.respond_to?(:rich_text_association_names)
-      (model.column_names + (rtans || [])).each do |k|
+      hoa, hma, rtans = model._activestorage_actiontext_fields
+      (model.column_names + hoa + hma + rtans.keys).each do |k|
         pk_pos = (pk.index(k)&.+ 1)
         next if (pk_pos && pk.length == 1 && !bts.key?(k)) ||
                 ::Brick.config.metadata_columns.include?(k)
 
         col = model.columns_hash[k]
-        if !col && rtans&.include?(k)
-          k = k[10..-1] if k.start_with?('rich_text_')
-          col = (rt_col ||= ActiveRecord::ConnectionAdapters::Column.new(
-                              '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: 'varchar', type: :text)
-                            )
-                )
+        if !col
+          kwargs = if hoa.include?(k) # has_one_attached
+                     { sql_type: 'binary', type: :file }
+                   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 }
+                   end
+          col = (ActiveRecord::ConnectionAdapters::Column.new(
+                  '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(**kwargs)
+                )) if kwargs
         end
         val = obj.attributes[k]
         out << "
@@ -535,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
@@ -621,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|
@@ -671,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))
@@ -682,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 = 210
+    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.210
+  version: 1.0.212
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-22 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