brick 1.0.96 → 1.0.98

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

@@ -0,0 +1,219 @@
+module Brick::Rails::FormTags
+  # Our super speedy grid
+  def brick_grid(relation, bt_descrip, sequence = nil, inclusions, exclusions,
+                 cols, poly_cols, bts, hms_keys, hms_cols)
+    out = "<table id=\"headerTop\"></table>
+<table id=\"#{relation.table_name}\" class=\"shadow\">
+  <thead><tr>"
+    pk = (klass = relation.klass).primary_key || []
+    pk = [pk] unless pk.is_a?(Array)
+    if pk.present?
+      out << "<th x-order=\"#{pk.join(',')}\"></th>"
+    end
+
+    col_keys = relation.columns.each_with_object([]) do |col, s|
+      col_name = col.name
+      next if inclusions&.exclude?(col_name) ||
+              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts.key?(col_name)) ||
+              ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
+
+      s << col_name
+      cols[col_name] = col
+    end
+    unless sequence # If no sequence is defined, start with all inclusions
+      cust_cols = klass._br_cust_cols
+      # HOT columns, kept as symbols
+      hots = klass._br_bt_descrip.keys.select { |k| bts.key?(k) }
+      sequence = col_keys + cust_cols.keys + hots + hms_keys.reject { |assoc_name| inclusions&.exclude?(assoc_name) }
+    end
+    sequence.reject! { |nm| exclusions.include?(nm) } if exclusions
+    out << sequence.each_with_object(+'') do |col_name, s|
+           if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
+             s << '<th'
+             s << " title=\"#{col.comment}\"" if col.respond_to?(:comment) && !col.comment.blank?
+             s << if (bt = bts[col_name])
+                    # Allow sorting for any BT except polymorphics
+                    "#{' x-order="' + bt.first.to_s + '"' unless bt[2]}>BT " +
+                    bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
+                  else # Normal column
+                    "#{' x-order="' + col_name + '"' if true}>#{col_name}"
+                  end
+           elsif col # HM column
+             s << "<th#{' x-order="' + col_name + '"' if true}>#{col[2]} "
+             s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path"))}")
+           elsif cust_cols.key?(col_name) # Custom column
+             s << "<th x-order=\"#{col_name}\">#{col_name}"
+           elsif col_name.is_a?(Symbol) && (hot = bts[col_name]) # has_one :through
+             s << "<th x-order=\"#{hot.first.to_s}\">HOT " +
+                  hot[1].map { |hot_pair| hot_pair.first.bt_link(col_name) }.join(' ')
+             hot[1].first
+           else # Bad column name!
+             s << "<th title=\"<< Unknown column >>\">#{col_name}"
+           end
+           s << '</th>'
+         end
+    out << "</tr></thead>
+  <tbody>"
+  # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
+  #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
+  #     TinyTds::Error: Adaptive Server connection timed out
+  #     (After restarting the server it worked fine again.)
+  relation.each do |obj|
+    out << "<tr>\n"
+    out << "<td>#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym,
+                                    pk.map { |pk_part| obj.send(pk_part.to_sym) }), { class: 'big-arrow' })}</td>\n" if pk.present?
+    sequence.each do |col_name|
+      val = obj.attributes[col_name]
+      out << '<td'
+      out << ' class=\"dimmed\"' unless cols.key?(col_name) || (cust_col = cust_cols[col_name]) || 
+                                                 (col_name.is_a?(Symbol) && bts.key?(col_name)) # HOT
+      out << '>'
+      if (bt = bts[col_name])
+        if bt[2] # Polymorphic?
+          bt_class = obj.send("#{bt.first}_type")
+          base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
+          poly_id = obj.send("#{bt.first}_id")
+          out << link_to("#{bt_class} ##{poly_id}", send("#{base_class_underscored}_path".to_sym, poly_id)) if poly_id
+        else # BT or HOT
+          bt_class = bt[1].first.first
+          descrips = bt_descrip[bt.first][bt_class]
+          bt_id_col = if descrips.nil?
+                        puts "Caught it in the act for obj / #{col_name}!"
+                      elsif descrips.length == 1
+                        [obj.class.reflect_on_association(bt.first)&.foreign_key]
+                      else
+                        descrips.last
+                      end
+          bt_txt = bt_class.brick_descrip(
+            # 0..62 because Postgres column names are limited to 63 characters
+            obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, bt_id_col
+          )
+          bt_txt ||= "<span class=\"orphan\">&lt;&lt; Orphaned ID: #{val} >></span>" if val
+          bt_id = bt_id_col&.map { |id_col| obj.respond_to?(id_sym = id_col.to_sym) ? obj.send(id_sym) : id_col }
+          out << (bt_id&.first ? link_to(bt_txt, send("#{bt_class.base_class._brick_index(:singular)}_path".to_sym, bt_id)) : bt_txt || '')
+        end
+      elsif (hms_col = hms_cols[col_name])
+        if hms_col.length == 1
+          out << hms_col.first
+        else
+          klass = (col = cols[col_name])[1]
+          if col[2] == 'HO'
+            descrips = bt_descrip[col_name.to_sym][klass]
+            if (ho_id = (ho_id_col = descrips.last).map { |id_col| obj.send(id_col.to_sym) })&.first
+              ho_txt = klass.brick_descrip(obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, ho_id_col)
+              out << link_to(ho_txt, send("#{klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
+            end
+          else
+            if (ct = obj.send(hms_col[1].to_sym)&.to_i)&.positive?
+              out << "#{link_to("#{ct || 'View'} #{hms_col.first}",
+                                   send("#{klass._brick_index}_path".to_sym,
+                                        hms_col[2].each_with_object({}) { |v, s| s[v.first] = v.last.is_a?(String) ? v.last : obj.send(v.last) })
+                               )}\n"
+            end
+          end
+        end
+      elsif (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
+        binding.pry if col.is_a?(Array)
+        col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
+        out << display_value(col_type || col&.sql_type, val).to_s
+      elsif cust_col
+        data = cust_col.first.map { |cc_part| obj.send(cc_part.last) }
+        cust_txt = klass.brick_descrip(cust_col[-2], data)
+        if (link_id = obj.send(cust_col.last[1]) if cust_col.last)
+          out << link_to(cust_txt, send("#{cust_col.last.first._brick_index(:singular)}_path", link_id))
+        else
+          out << cust_txt
+        end
+      else # Bad column name!
+        out << '?'
+      end
+      out << '</td>'
+    end
+  out << '</tr>'
+  end
+  out << "  </tbody>
+</table>
+"
+    out.html_safe
+  end # brick_grid
+
+  def link_to_brick(*args, **kwargs)
+    return unless ::Brick.config.mode == :on
+
+    text = ((args.first.is_a?(String) || args.first.is_a?(Proc)) && args.shift) || args[1]
+    text = text.call if text.is_a?(Proc)
+    klass_or_obj = ((args.first.is_a?(ActiveRecord::Relation) ||
+                     args.first.is_a?(ActiveRecord::Base) ||
+                     args.first.is_a?(Class)) &&
+                    args.first) ||
+                   @_brick_model
+    # If not provided, do a best-effort to automatically determine the resource class or object
+    filter_parts = []
+    klass_or_obj ||= begin
+                       klass, sti_type = ::Brick.ctrl_to_klass(controller_path)
+                       if klass
+                         type_col = klass.inheritance_column # Usually 'type'
+                         filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
+                         path_params = request.path_parameters.dup
+                         path_params.delete(:controller)
+                         path_params.delete(:action)
+                         pk = (klass.primary_key || ActiveRecord::Base.primary_key).to_sym
+                         # Used to also have this but it's a bit too permissive to identify a primary key:  (path_params.length == 1 && path_params.values.first) ||
+                         if ((id = (path_params[pk] || path_params[:id] || path_params["#{klass.name.underscore}_id".to_sym])) && (obj = klass.find_by(pk => id))) ||
+                            (['show', 'edit', 'update', 'destroy'].include?(action_name) && (obj = klass.first))
+                           obj
+                         else
+                           # %%% If there is a HMT that refers to some ___id then try to identify an appropriate filter
+                           # %%% If there is a polymorphic association that might relate to stuff in the path_params,
+                           # try to identify an appropriate ___able_id and ___able_type filter
+                           ((klass.column_names - [pk.to_s]) & path_params.keys.map(&:to_s)).each do |path_param|
+                             filter_parts << "#{path_param}=#{path_params[path_param.to_sym]}"
+                           end
+                           klass
+                         end
+                       end
+                     rescue
+                     end
+    if klass_or_obj
+      if klass_or_obj.is_a?(ActiveRecord::Relation)
+        klass_or_obj.where_values_hash.each do |whr|
+          filter_parts << "#{whr.first}=#{whr.last}" if whr.last && !whr.last.is_a?(Array)
+        end
+        klass_or_obj = klass_or_obj.klass
+        type_col = klass_or_obj.inheritance_column
+        if klass_or_obj.column_names.include?(type_col) && klass_or_obj.name != klass_or_obj.base_class.name
+          filter_parts << "#{type_col}=#{klass_or_obj.name}"
+        end
+      end
+      filter = "?#{filter_parts.join('&')}" if filter_parts.present?
+      if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
+         (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
+        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj) : "#{send("#{klass_or_obj.base_class._brick_index}_path")}#{filter}"
+        lt_args = [text || "Index for #{klass_or_obj.name.pluralize}", path]
+      else
+        # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
+        path = (proc = kwargs[:show_proc]) ? proc.call(klass_or_obj) : "#{send("#{klass_or_obj.class.base_class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"
+        lt_args = [text || "Show this #{klass_or_obj.class.name}", path]
+      end
+      link_to(*lt_args, **kwargs)
+    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?
+      links = instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
+                iv_name = name.to_s[1..-1]
+                case (val = instance_variable_get(name))
+                when ActiveRecord::Relation
+                  s[val.klass] << iv_name
+                when ActiveRecord::Base
+                  s[val] << iv_name
+                end
+              end
+      if links.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.map { |k, v| link_to_brick(v.join('/'), v, **kwargs) }.join(' &nbsp; ').html_safe
+      end
+    end
+  end # link_to_brick
+
+end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -138,15 +138,16 @@ module Brick
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
       # a different tenant.  If so then don't allow schema navigation.
-      chosen = if (is_show_schema_list = (apartment_multitenant && Apartment::Tenant.current == ::Brick.default_schema)) &&
+      chosen = if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' &&
+                  (current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2]
+                                                       .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first) &&
+                  (is_show_schema_list = (apartment_multitenant && current_schema == ::Brick.default_schema)) &&
                   (schema = (params ? params['_brick_schema'] : ::Brick.default_schema)) &&
                   ::Brick.db_schemas&.key?(schema)
                  Apartment::Tenant.switch!(schema)
                  schema
-               elsif ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-                 # Just return the current schema
-                 current_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-                 (current_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first
+               else
+                 current_schema # Just return the current schema
                end
       [chosen == ::Brick.default_schema ? nil : chosen, is_show_schema_list]
     end
@@ -1257,35 +1258,33 @@ module ActiveRecord
     # For AR >= 4.2
     if self.const_defined?('JoinDependency')
       class JoinDependency
-        if ActiveRecord.version >= ::Gem::Version.new('6.0')
-          # An intelligent .eager_load() and .includes() that creates t0_r0 style aliases only for the columns
-          # used in .select().  To enable this behaviour, include the flag :_brick_eager_load as the first
-          # entry in your .select().
-          # More information:  https://discuss.rubyonrails.org/t/includes-and-select-for-joined-data/81640
-          def apply_column_aliases(relation)
+        # An intelligent .eager_load() and .includes() that creates t0_r0 style aliases only for the columns
+        # used in .select().  To enable this behaviour, include the flag :_brick_eager_load as the first
+        # entry in your .select().
+        # More information:  https://discuss.rubyonrails.org/t/includes-and-select-for-joined-data/81640
+        def apply_column_aliases(relation)
+          if (sel_vals = relation.select_values.map(&:to_s)).first == '_brick_eager_load'
             used_cols = {}
-            if (sel_vals = relation.select_values.map(&:to_s)).first == '_brick_eager_load'
-              # Find and expand out all column names being used in select(...)
-              new_select_values = sel_vals.each_with_object([]) do |col, s|
-                next if col == '_brick_eager_load'
+            # Find and expand out all column names being used in select(...)
+            new_select_values = sel_vals.each_with_object([]) do |col, s|
+              next if col == '_brick_eager_load'
 
-                if col.include?(' ') # Some expression? (No chance for a simple column reference)
-                  s << col # Just pass it through
-                else
-                  col = if (col_parts = col.split('.')).length == 1
-                          [col]
-                        else
-                          [col_parts[0..-2].join('.'), col_parts.last]
-                        end
-                  used_cols[col] = nil
-                end
-              end
-              if new_select_values.present?
-                relation.select_values = new_select_values
+              if col.include?(' ') # Some expression? (No chance for a simple column reference)
+                s << col # Just pass it through
               else
-                relation.select_values.clear
+                col = if (col_parts = col.split('.')).length == 1
+                        [col]
+                      else
+                        [col_parts[0..-2].join('.'), col_parts.last]
+                      end
+                used_cols[col] = nil
               end
             end
+            if new_select_values.present?
+              relation.select_values = new_select_values
+            else
+              relation.select_values.clear
+            end
 
             @aliases ||= Aliases.new(join_root.each_with_index.map do |join_part, i|
               join_alias = join_part.table&.table_alias || join_part.table_name
@@ -1315,9 +1314,9 @@ module ActiveRecord
               end
               Aliases::Table.new(join_part, columns)
             end)
-
-            relation._select!(-> { @aliases.columns })
           end
+
+          relation._select!(-> { aliases.columns })
         end
 
       private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.96
+  version: 1.0.98
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-25 00:00:00.000000000 Z
+date: 2022-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -216,6 +216,7 @@ files:
 - lib/brick/frameworks/rails/controller.rb
 - lib/brick/frameworks/rails/crosstab.brk
 - lib/brick/frameworks/rails/engine.rb
+- lib/brick/frameworks/rails/form_tags.rb
 - lib/brick/frameworks/rspec.rb
 - lib/brick/join_array.rb
 - lib/brick/serializers/json.rb