brick 1.0.40 → 1.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf29d4af64b65c01ae68df45762b816403a1ebc0035e1221552f249ff3ba2ce9
-  data.tar.gz: 076cdb672d7c2137cc74421467d72491e9ea89751fab32015f427158fc367b45
+  metadata.gz: 8387796a98b0bcf24586c6b31f091cfdc4cca1b45b73d02de3bdba17430625f7
+  data.tar.gz: 1c7509e21a1a9a6c8c52f3015b0a7e34222ff944433e028be314f8525ee948b8
 SHA512:
-  metadata.gz: ce17038567ddd9d6d9d9dce6eb71fd50612d167b56351898ef9b3f9441d1a7ef3ee4ec3a57f3f24e613829e6c8a2f59517fc0d4e9266f11166b92821310b0c06
-  data.tar.gz: 6a7bb38b009853594a8bf1ab28489bbc92d6300fcd0f8497c7950e81c6a62a4c6da2bd65840f93bd7afea40153727cb93914529120ecf9b0dceca39b21fef880
+  metadata.gz: 75222971d2407d8ffb3b8412694da3fe6ad0d3f27f147159f6d75aa712d1dfe8a9d54627cb2c816fdfc8cb7c44de4407f180fbc559b9c811719c22a016c913f5
+  data.tar.gz: 44e03a9d2ddec85969d5b1aca67a9426a4b3dd33f196c058d57b380fa77e78424768dd3e97a40227b2372bec4ccd81dfd1b7760b65e2c5b292c8b47c0d27e2c7

data/lib/brick/config.rb

@@ -205,5 +205,10 @@ module Brick
     def not_nullables=(columns)
       @mutex.synchronize { @not_nullables = columns }
     end
+
+    # Add a special page to show references to non-existent records ("orphans")
+    def add_orphans
+      true
+    end
   end
 end

data/lib/brick/extensions.rb

@@ -415,14 +415,16 @@ module ActiveRecord
       hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
-                         fk_col = (associative = associatives[hm.name]).foreign_key
-                         hm.foreign_key
+                         fk_col = (associative = associatives[hm.name])&.foreign_key
+                         hm.foreign_key if fk_col
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
                          pk = hm.klass.primary_key
                          (pk.is_a?(Array) ? pk.first : pk) || '*'
                        end
+        next unless count_column # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+
         tbl_alias = "_br_#{hm.name}"
         pri_tbl = hm.active_record
         on_clause = []
@@ -565,7 +567,9 @@ Module.class_exec do
                full_class_name = +''
                full_class_name << "::#{self.name}" unless self == Object
                full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
-               if (plural_class_name == 'BrickSwagger' || model = self.const_get(full_class_name))
+               if (plural_class_name == 'BrickSwagger' ||
+                  (::Brick.config.add_orphans && plural_class_name == 'BrickGem') ||
+                  model = self.const_get(full_class_name))
                  # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
@@ -897,6 +901,14 @@ class Object
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
+        # Brick-specific pages
+        if plural_class_name == 'BrickGem'
+          self.define_method :orphans do
+            instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params)))
+          end
+          return [new_controller_class, code + ' # BrickGem controller']
+        end
+
         unless (is_swagger = plural_class_name == 'BrickSwagger') # && request.format == :json)
           code << "  def index\n"
           code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
@@ -1047,10 +1059,11 @@ class Object
           if is_need_params
             code << "private\n"
             code << "  def #{params_name}\n"
-            code << "    params.require(:#{singular_table_name}).permit(#{model.columns_hash.keys.map { |c| c.to_sym.inspect }.join(', ')})\n"
+            code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
+                             }).permit(#{model.columns_hash.keys.map { |c| c.to_sym.inspect }.join(', ')})\n"
             code << "  end\n"
             self.define_method(params_name) do
-              params.require(singular_table_name.to_sym).permit(model.columns_hash.keys)
+              params.require(require_name.to_sym).permit(model.columns_hash.keys)
             end
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
@@ -1475,5 +1488,72 @@ module Brick
       end
       assoc_bt[:inverse] = assoc_hm
     end
+
+    # Locate orphaned records
+    def find_orphans(multi_schema)
+      is_default_schema = multi_schema&.==(Apartment.default_schema)
+      relations.each_with_object([]) do |v, s|
+        frn_tbl = v.first
+        next if (relation = v.last).key?(:isView) || config.exclude_tables.include?(frn_tbl) ||
+                !(for_pk = (relation[:pkey].values.first&.first))
+
+        is_default_frn_schema = !is_default_schema && multi_schema &&
+                                ((frn_parts = frn_tbl.split('.')).length > 1 && frn_parts.first)&.==(Apartment.default_schema)
+        relation[:fks].select { |_k, assoc| assoc[:is_bt] }.each do |_k, bt|
+          begin
+            if bt.key?(:polymorphic)
+              pri_pk = for_pk
+              pri_tables = Brick.config.polymorphics["#{frn_tbl}.#{bt[:fk]}"]
+                                .each_with_object(Hash.new { |h, k| h[k] = [] }) do |pri_class, s|
+                s[Object.const_get(pri_class).table_name] << pri_class
+              end
+              fk_id_col = "#{bt[:fk]}_id"
+              fk_type_col = "#{bt[:fk]}_type"
+              selects = []
+              pri_tables.each do |pri_tbl, pri_types|
+                # Skip if database is multitenant, we're not focused on "public", and the foreign and primary tables
+                # are both in the "public" schema
+                next if is_default_frn_schema &&
+                        ((pri_parts = pri_tbl&.split('.'))&.length > 1 && pri_parts.first)&.==(Apartment.default_schema)
+
+                selects << "SELECT '#{pri_tbl}' AS pri_tbl, frn.#{fk_type_col} AS pri_type, frn.#{fk_id_col} AS pri_id, frn.#{for_pk} AS frn_id
+                FROM #{frn_tbl} AS frn
+                  LEFT OUTER JOIN #{pri_tbl} AS pri ON pri.#{pri_pk} = frn.#{fk_id_col}
+                WHERE frn.#{fk_type_col} IN (#{
+                  pri_types.map { |pri_type| "'#{pri_type}'" }.join(', ')
+                }) AND frn.#{bt[:fk]}_id IS NOT NULL AND pri.#{pri_pk} IS NULL\n"
+              end
+              ActiveRecord::Base.execute_sql(selects.join("UNION ALL\n")).each do |o|
+                entry = [frn_tbl, o['frn_id'], o['pri_type'], o['pri_id'], fk_id_col]
+                entry << o['pri_tbl'] if (pri_class = Object.const_get(o['pri_type'])) != pri_class.base_class
+                s << entry
+              end
+            else
+              # Skip if database is multitenant, we're not focused on "public", and the foreign and primary tables
+              # are both in the "public" schema
+              pri_tbl = bt.key?(:inverse_table) && bt[:inverse_table]
+              next if is_default_frn_schema &&
+                      ((pri_parts = pri_tbl&.split('.'))&.length > 1 && pri_parts.first)&.==(Apartment.default_schema)
+
+              pri_pk = relations[pri_tbl].fetch(:pkey, nil)&.values&.first&.first ||
+                       _class_pk(pri_tbl, multi_schema)
+              ActiveRecord::Base.execute_sql(
+                "SELECT frn.#{bt[:fk]} AS pri_id, frn.#{for_pk} AS frn_id
+                FROM #{frn_tbl} AS frn
+                  LEFT OUTER JOIN #{pri_tbl} AS pri ON pri.#{pri_pk} = frn.#{bt[:fk]}
+                WHERE frn.#{bt[:fk]} IS NOT NULL AND pri.#{pri_pk} IS NULL
+                ORDER BY 1, 2"
+              ).each { |o| s << [frn_tbl, o['frn_id'], pri_tbl, o['pri_id'], bt[:fk]] }
+            end
+          rescue StandardError => err
+            puts "Strange -- #{err.inspect}"
+          end
+        end
+      end
+    end
+
+    def _class_pk(dotted_name, multitenant)
+      Object.const_get((multitenant ? [dotted_name.split('.').last] : dotted_name.split('.')).map { |nm| "::#{nm.singularize.camelize}" }.join).primary_key
+    end
   end
 end

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

@@ -53,7 +53,9 @@ module Brick
             # Used by Rails 5.0 and above
             alias :_brick_template_exists? :template_exists?
             def template_exists?(*args, **options)
-              _brick_template_exists?(*args, **options) || set_brick_model(args)
+              (::Brick.config.add_orphans && args.first == 'orphans') ||
+              _brick_template_exists?(*args, **options) ||
+              set_brick_model(args)
             end
 
             def set_brick_model(find_args)
@@ -88,44 +90,56 @@ module Brick
               unless (model_name = (
                        @_brick_model ||
                        (ActionView.version < ::Gem::Version.new('5.0') && args[1].is_a?(Array) ? set_brick_model(args) : nil)
-                     )&.name)
+                     )&.name) ||
+                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']])
                 return _brick_find_template(*args, **options)
               end
 
-              pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
-              obj_name = model_name.split('::').last.underscore
-              path_obj_name = model_name.underscore.tr('/', '_')
-              table_name = obj_name.pluralize
-              template_link = nil
-              bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
-              hms_columns = [] # Used for 'index'
-              skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
-              hms_headers = hms.each_with_object([]) do |hm, s|
-                hm_stuff = [(hm_assoc = hm.last), "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}", (assoc_name = hm.first)]
-                hm_fk_name = if hm_assoc.options[:through]
-                               associative = associatives[hm_assoc.name]
-                               "'#{associative.name}.#{associative.foreign_key}'"
-                             else
-                               hm_assoc.foreign_key
-                             end
-                if args.first == 'index'
-                  hms_columns << if hm_assoc.macro == :has_many
-                                   set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
-                                              'nil'
-                                            else
-                                              # Postgres column names are limited to 63 characters
-                                              attrib_name = "_br_#{assoc_name}_ct"[0..62]
-                                              "#{obj_name}.#{attrib_name} || 0"
-                                            end
+              unless is_orphans
+                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
+                obj_name = model_name.split('::').last.underscore
+                path_obj_name = model_name.underscore.tr('/', '_')
+                table_name = obj_name.pluralize
+                template_link = nil
+                bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
+                hms_columns = [] # Used for 'index'
+                skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
+                hms_headers = hms.each_with_object([]) do |hm, s|
+                  hm_stuff = [(hm_assoc = hm.last), "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}", (assoc_name = hm.first)]
+                  hm_fk_name = if hm_assoc.options[:through]
+                                associative = associatives[hm_assoc.name]
+                                associative && "'#{associative.name}.#{associative.foreign_key}'"
+                              else
+                                hm_assoc.foreign_key
+                              end
+                  case args.first
+                  when 'index'
+                    hms_columns << if hm_assoc.macro == :has_many
+                                     set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
+                                                'nil'
+                                              else
+                                                # Postgres column names are limited to 63 characters
+                                                attrib_name = "_br_#{assoc_name}_ct"[0..62]
+                                                "#{obj_name}.#{attrib_name} || 0"
+                                              end
+                                     if hm_fk_name
 "<%= ct = #{set_ct}
      link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
-                                 else # has_one
+                                     else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+"#{assoc_name}\n"
+                                     end
+                                   else # has_one
 "<%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>\n"
-                                 end
-                elsif args.first == 'show'
-                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                   end
+                  when 'show', 'update'
+                    hm_stuff << if hm_fk_name
+                                  "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+                                  assoc_name
+                                end
+                  end
+                  s << hm_stuff
                 end
-                s << hm_stuff
               end
 
               schema_options = ::Brick.db_schemas.keys.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
@@ -140,6 +154,7 @@ module Brick
                               end.sort.each_with_object(+'') do |v, s|
                                 s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
                               end.html_safe
+              table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
               css = +"<style>
 #dropper {
   background-color: #eee;
@@ -199,6 +214,9 @@ table tbody tr.active-row {
   color: #009879;
 }
 
+td.val {
+  display: block;
+}
 a.show-arrow {
   font-size: 1.5em;
   text-decoration: none;
@@ -212,11 +230,27 @@ a.big-arrow {
   overflow: hidden;
 }
 .wide-input input[type=text] {
-  width: 100%;
+  display: inline-block;
+  width: 90%;
 }
 .dimmed {
   background-color: #C0C0C0;
 }
+
+#revertTemplate {
+  display: none;
+}
+svg.revert {
+  display: none;
+  margin-left: 0.25em;
+}
+.wide-input > svg.revert {
+  float: right;
+}
+input+svg.revert {
+  top: 0.5em;
+}
+
 input[type=submit] {
   background-color: #004998;
   color: #FFF;
@@ -225,7 +259,9 @@ input[type=submit] {
   text-align: right;
 }
 </style>
-<% def is_bcrypt?(val)
+<% is_includes_dates = nil
+
+def is_bcrypt?(val)
   val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
 end
 def hide_bcrypt(val, max_len = 200)
@@ -297,7 +333,13 @@ window.addEventListener(\"pageshow\", function() {
   });
 
   if (tblSelect) { // Always present
-    tblSelect.value = changeout(location.href)[schemaSelect ? 1 : 0];
+    var i = schemaSelect ? 1 : 0,
+        changeoutList = changeout(location.href);
+    for (; i < changeoutList.length; ++i) {
+      tblSelect.value = changeoutList[i];
+      if (tblSelect.value !== \"\") break;
+    }
+
     tblSelect.addEventListener(\"change\", function () {
       var lhr = changeout(location.href, null, this.value);
       if (brickSchema)
@@ -314,13 +356,13 @@ function changeout(href, param, value, trimAfter) {
     var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
     if (value === undefined)
       // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
-      return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)];
+      return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)[0]];
     else
       return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
   }
   if (trimAfter) {
     var pathParts = hrefParts[0].split(\"/\");
-    while (pathParts.lastIndexOf(trimAfter) != pathParts.length - 1) pathParts.pop();
+    while (pathParts.lastIndexOf(trimAfter) !== pathParts.length - 1) pathParts.pop();
     hrefParts[0] = pathParts.join(\"/\");
   }
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
@@ -464,7 +506,7 @@ if (headerTop) {
                          end
 # %%% Instead of our current "for Janet Leverling (Employee)" kind of link we previously had this code that did a "where x = 123" thing:
 #   (where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %>)
-"#{css}
++"#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
@@ -490,8 +532,7 @@ if (headerTop) {
   <thead><tr>#{'<th></th>' if pk.present?}<%
      col_order = []
      @#{table_name}.columns.each do |col|
-       col_name = col.name
-       next if (#{(pk || []).inspect}.include?(col_name) && col.type == :integer && !bts.key?(col_name)) ||
+       next if (#{(pk || []).inspect}.include?(col_name = col.name) && col.type == :integer && !bts.key?(col_name)) ||
                ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
 
        col_order << col_name
@@ -504,10 +545,16 @@ if (headerTop) {
        else %><%=
          col_name %><%
        end
-  %></th><%
+    %></th><%
      end
      # Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name
-  %>#{hms_headers.map { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>" }.join
+  %>#{hms_headers.map do |h|
+        if h.first.options[:through] && !h.first.through_reflection
+    "<th>#{h[1]} #{h[2]} %></th>" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+        else
+    "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
+        end
+      end.join
   }</tr></thead>
 
   <tbody>
@@ -547,8 +594,31 @@ if (headerTop) {
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{path_obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
+                       when 'orphans'
+                         if is_orphans
++"#{css}
+<p style=\"color: green\"><%= notice %></p>#{"
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
+<select id=\"tbl\">#{table_options}</select>
+<h1>Orphans<%= \" for #\{}\" if false %></h1>
+<% @orphans.each do |o|
+  via = \" (via #\{o[4]})\" unless \"#\{o[2].split('.').last.underscore.singularize}_id\" == o[4] %>
+  <a href=\"/<%= o[0].split('.').last %>/<%= o[1] %>\">
+    <%= \"#\{o[0]} #\{o[1]} refers#\{via} to non-existent #\{o[2]} #\{o[3]}#\{\" (in table \\\"#\{o[5]}\\\")\" if o[5]}\" %>
+  </a><br>
+<% end %>
+#{script}"
+                         end
+
                        when 'show', 'update'
-"#{css}
++"#{css}
+
+<svg id=\"revertTemplate\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"
+  width=\"32px\" height=\"32px\" viewBox=\"0 0 512 512\" xml:space=\"preserve\">
+<path id=\"revertPath\" fill=\"#2020A0\" d=\"M271.844,119.641c-78.531,0-148.031,37.875-191.813,96.188l-80.172-80.188v256h256l-87.094-87.094
+  c23.141-70.188,89.141-120.906,167.063-120.906c97.25,0,176,78.813,176,176C511.828,227.078,404.391,119.641,271.844,119.641z\" />
+</svg>
+
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
@@ -606,31 +676,39 @@ end
       <%= k %>
     <% end %>
     </th>
-    <td>
-    <% if bt
+    <td class=\"val\">
+    <% dt_pickers = { datetime: 'datetimepicker', timestamp: 'datetimepicker', time: 'timepicker', date: 'datepicker' }
+    if bt
       html_options = { prompt: \"Select #\{bt_name\}\" }
       html_options[:class] = 'dimmed' unless val %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
       <%= if (bt_obj = bt_class&.find_by(bt_pair[1] => val))
             link_to('⇛', send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' })
           elsif val
-            \"Orphaned ID: #\{val}\"
-          end %>
-    <% else case #{model_name}.column_for_attribute(k).type
+            \"<span>Orphaned ID: #\{val}</span>\".html_safe
+          end %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
+    <% else case (col_type = #{model_name}.column_for_attribute(k).type)
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
           <%= hide_bcrypt(val, 1000) %>
         <% else %>
-          <div class=\"wide-input\"><%= f.text_field k.to_sym %></div>
+          <div class=\"wide-input\"><%= f.text_field k.to_sym %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg></div>
         <% end %>
       <% when :boolean %>
-        <%= f.check_box k.to_sym %>
-      <% when :integer, :decimal, :float, :date, :datetime, :time, :timestamp
+        <%= f.check_box k.to_sym %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
+      <% when :integer, :decimal, :float
          # What happens when keys are UUID?
          # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
          # If it's not yet enabled then:  enable_extension 'uuid-ossp'
          # ActiveUUID gem created a new :uuid type %>
-        <%= val %>
+        <%= if col_type == :integer
+              f.text_field k.to_sym, { pattern: '\\d*', class: 'check-validity' }
+            else
+              f.number_field k.to_sym
+            end %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
+      <% when *dt_pickers.keys
+           is_includes_dates = true %>
+        <%= f.text_field k.to_sym, { class: dt_pickers[col_type] } %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
       <% when :binary, :primary_key %>
       <% end %>
     <% end %>
@@ -646,6 +724,9 @@ end
   <% end %>
 
   #{hms_headers.each_with_object(+'') do |hm, s|
+    # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+    next if hm.first.options[:through] && !hm.first.through_reflection
+
     if (pk = hm.first.klass.primary_key)
       hm_singular_name = (hm_name = hm.first.name.to_s).singularize.underscore
       obj_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "#{hm_singular_name}.#{pk_part}" }.join(', ')
@@ -669,6 +750,66 @@ end
 #{script}"
 
                        end
+              inline << "
+<% if is_includes_dates %>
+<link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/flatpickr/dist/flatpickr.min.css\">
+<style>
+.flatpickr-calendar {
+  background: #A0FFA0;
+}
+</style>
+<script src=\"https://cdn.jsdelivr.net/npm/flatpickr\"></script>
+<script>
+flatpickr(\".datepicker\");
+flatpickr(\".datetimepicker\", {enableTime: true});
+flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
+</script>
+<% end %>
+<script>
+document.querySelectorAll(\"input, select\").forEach(function (inp) {
+  var origVal = getInpVal(),
+      prevVal = origVal;
+  var revert;
+  if ((revert = ((inp.tagName === \"SELECT\" && inp.nextElementSibling.nextElementSibling) ||
+       inp.nextElementSibling ||
+       inp.parentElement.nextElementSibling)) && revert.tagName.toLowerCase() === \"svg\")
+    revert.addEventListener(\"click\", function (e) {
+      if (inp.type === \"checkbox\")
+        inp.checked = origVal;
+      else
+        inp.value = origVal;
+      revert.style.display = \"none\";
+      if (inp._flatpickr)
+        inp._flatpickr.setDate(origVal);
+      else
+        inp.focus();
+    });
+  inp.addEventListener(inp.type === \"checkbox\" ? \"change\" : \"input\", function (e) {
+    if(inp.className.split(\" \").indexOf(\"check-validity\") > 0) {
+      if (inp.checkValidity()) {
+        prevVal = getInpVal();
+      } else {
+        inp.value = prevVal;
+      }
+    } else {
+      // If this is the result of changing an hour or minute, keep the calendar open.
+      // And if it was the result of selecting a date, the calendar can now close.
+      if (inp._flatpickr &&
+           // Test only for changes in the date portion of a date or datetime
+           ((giv = getInpVal()) && (giv1 = giv.split(' ')[0])) !== (prevVal && prevVal.split(' ')[0]) &&
+           giv1.indexOf(\":\") < 0 // (definitely not any part of a time thing)
+         )
+        inp._flatpickr.close();
+      prevVal = getInpVal();
+    }
+    // Show or hide the revert button
+    if (revert) revert.style.display = getInpVal() === origVal ? \"none\" : \"inline-block\";
+  });
+  function getInpVal() {
+    return inp.type === \"checkbox\" ? inp.checked : inp.value;
+  }
+});
+</script>"
               # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
               keys = options.has_key?(:locals) ? options[:locals].keys : []
               handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')

data/lib/brick/tasks/orphans.rake

@@ -4,53 +4,25 @@ if Object.const_defined?('::Rake::TaskManager')
   namespace :brick do
     desc 'Find any seemingly-orphaned records'
     task orphans: :environment do
-      def class_pk(dotted_name, multitenant)
-        Object.const_get((multitenant ? [dotted_name.split('.').last] : dotted_name.split('.')).map { |nm| "::#{nm.singularize.camelize}" }.join).primary_key
-      end
-
       schema_list = ((multi = ::Brick.config.schema_behavior[:multitenant]) && ::Brick.db_schemas.keys.sort) || []
-      if schema_list.length > 1
-        require 'fancy_gets'
-        include FancyGets
-        schema = gets_list(
-          list: schema_list,
-          chosen: multi[:schema_to_analyse]
-        )
-      elsif schema_list.length.positive?
-        schema = schema_list.first
-      end
+      schema = if schema_list.length == 1
+                 schema_list.first
+               elsif schema_list.length.positive?
+                 require 'fancy_gets'
+                 include FancyGets
+                 gets_list(list: schema_list, chosen: multi[:schema_to_analyse])
+               end
       ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema) if schema
-      orphans = +''
-      ::Brick.relations.each do |k, v|
-        next if v.key?(:isView) || ::Brick.config.exclude_tables.include?(k) ||
-                !(pri_pk = v[:pkey].values.first&.first) ||
-                !(pri_pk = class_pk(k, multi))
-        v[:fks].each do |k1, v1|
-          next if v1[:is_bt] ||
-                  !(for_rel = ::Brick.relations.fetch(v1[:inverse_table], nil)) ||
-                  v1[:inverse]&.key?(:polymorphic) ||
-                  !(for_pk = for_rel.fetch(:pkey, nil)&.values&.first&.first) ||
-                  !(for_pk = class_pk(v1[:inverse_table], multi))
-          begin
-            ActiveRecord::Base.execute_sql(
-              "SELECT DISTINCT frn.#{v1[:fk]} AS pri_id, frn.#{for_pk} AS fk_id
-              FROM #{v1[:inverse_table]} AS frn
-                LEFT OUTER JOIN #{k} AS pri ON pri.#{pri_pk} = frn.#{v1[:fk]}
-              WHERE frn.#{v1[:fk]} IS NOT NULL AND pri.#{pri_pk} IS NULL
-              ORDER BY 1, 2"
-            ).each do |o|
-              orphans << "#{v1[:inverse_table]} #{o['fk_id']} refers to non-existant #{k} #{o['pri_id']}\n"
-            end
-          rescue StandardError => err
-            puts "Strange -- #{err.inspect}"
-          end
-        end
-      end
-      puts "For #{schema}:\n#{'=' * (schema.length + 5)}" if schema
-      if orphans.blank?
+      orphans = ::Brick.find_orphans(schema)
+      puts "Orphans in #{schema}:\n#{'=' * (schema.length + 12)}" if schema
+      if orphans.empty?
         puts "No orphans!"
       else
-        print orphans
+        orphans.each do |o|
+          via = " (via #{o[4]})" unless "#{o[2].split('.').last.underscore.singularize}_id" == o[4]
+          puts "#{o[0]} #{o[1]} refers#{via} to non-existent #{o[2]} #{o[3]}#{" (in table \"#{o[5]}\")" if o[5]}"
+        end
+        puts
       end
     end
   end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -128,7 +128,10 @@ module Brick
 
     def set_db_schema(params)
       schema = params['_brick_schema'] || 'public'
-      ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema) if schema && ::Brick.db_schemas&.include?(schema)
+      if schema && ::Brick.db_schemas&.include?(schema)
+        ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
+        schema
+      end
     end
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
@@ -457,6 +460,9 @@ In config/initializers/brick.rb appropriate entries would look something like:
               send(:resources, controller_name.to_sym, **options)
             end
           end
+          if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
+            get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
+          end
         end
         send(:get, '/api-docs/v1/swagger.json', { to: 'brick_swagger#index' }) if Object.const_defined?('Rswag::Ui')
       end

data/lib/generators/brick/install_generator.rb

@@ -209,7 +209,7 @@ module Brick
 # # Specify STI subclasses either directly by name or as a general module prefix that should always relate to a specific
 # # parent STI class.  The prefixed :: here for these examples is mandatory.  Also having a suffixed :: means instead of
 # # a class reference, this is for a general namespace reference.  So in this case requests for, say, either of the
-# # non-existant classes Animals::Cat or Animals::Goat (or anything else with the module prefix of \"Animals::\" would
+# # non-existent classes Animals::Cat or Animals::Goat (or anything else with the module prefix of \"Animals::\" would
 # # build a model that inherits from Animal.  And a request specifically for the class Snake would build a new model
 # # that inherits from Reptile, and no other request would do this -- only specifically for Snake.  The ending ::
 # # indicates that it's a module prefix instead of a specific class name.
@@ -225,7 +225,7 @@ module Brick
 # # it wasn't originally specified.
 # Brick.schema_behavior = :namespaced
 #{Brick.config.schema_behavior ? "Brick.schema_behavior = { multitenant: { schema_to_analyse: #{
-  Brick.config.schema_behavior[:multitenant][:schema_to_analyse].inspect}" :
+  Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil).inspect}" :
 "# Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering'"
 } } }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.40
+  version: 1.0.43
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord