brick 1.0.146 → 1.0.147

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a3f6fe9aa20dd0fe9ae7058874432a5966dea3b36f79d1e84702728fb010071
-  data.tar.gz: fc6fa3766a3413f9ba4df5cd1d8361bea351a180f6a7950a3ef1f9427145884b
+  metadata.gz: dd317a5512ce3e16edf252482ace8bfbc481b7c47abec2ef6b760ef6100d0f60
+  data.tar.gz: 804edb51a7b6d88794bd573a0af046dfc51fffedec85238ac2c88d010be648fb
 SHA512:
-  metadata.gz: 64f5575cfba4fa0a7983ae4621941a3da6622ed70f606c7c418814d1041a10fec4b522cc0f4741faa6677681a1453b92f0cce31ad36edba9cb0f0c4ca9e812e2
-  data.tar.gz: e5aa7fa963d0756a9fa8946daef90f03e1d6e38210811a58c7f901895d44132785222095ea1b3f56223ef663328ecc3536d35a9b8bed6e97fde94edb5f4d5250
+  metadata.gz: 46b3b122f5a7ff7edfc41b24748e980dc9bea92241d934a5fc9de7a34fe1182058ab7c8d7b90d65329d1d183eec6fd6bf195764aa90f9e32602c46fa2f219d31
+  data.tar.gz: 41cdd93b08c7cc4f26bceb2a1864a7233f54ce070576738433870185ed4c23b9803f82edc3ba9b4c63eb4ed3888853adeeeba64b2772f86939715d0b4977e5bb

data/lib/brick/config.rb

@@ -299,6 +299,14 @@ module Brick
       @mutex.synchronize { @models_inherit_from = value }
     end
 
+    def controllers_inherit_from
+      @mutex.synchronize { @controllers_inherit_from }
+    end
+
+    def controllers_inherit_from=(value)
+      @mutex.synchronize { @controllers_inherit_from = value }
+    end
+
     def table_name_prefixes
       @mutex.synchronize { @table_name_prefixes }
     end

data/lib/brick/extensions.rb

@@ -85,6 +85,10 @@ module ActiveRecord
         (respond_to?(:attribute_types) && (attr_types = attribute_types[col.name]).respond_to?(:coder) &&
          (attr_types.coder.is_a?(Class) ? attr_types.coder : attr_types.coder&.class)&.name&.end_with?('JSON'))
       end
+
+      def brick_foreign_type(assoc)
+        reflect_on_association(assoc).foreign_type || "#{assoc}_type"
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -895,15 +899,15 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
             # Add the ordered series of columns derived from the BT based on its DSL
             if (bt_cols = klass._br_bt_descrip[v])
               bt_cols.values.each do |v1|
-                v1.each { |v2| s << "\"#{v2.last}\"" if v2.length > 1 }
+                v1.each { |v2| s << _br_quoted_name(v2.last) if v2.length > 1 }
               end
             elsif (cc_cols = klass._br_cust_cols[v])
-              cc_cols.first.each { |v1| s << "\"#{v1.last}\"" if v1.length > 1 }
+              cc_cols.first.each { |v1| s << _br_quoted_name(v1.last) if v1.length > 1 }
             else
               s << v
             end
           else # String stuff (which defines a custom ORDER BY) just comes straight through
-            v = v.split('.').map { |x| "\"#{x}\"" }.join('.')
+            v = v.split('.').map { |x| _br_quoted_name(x) }.join('.')
             s << v
             # Avoid "PG::InvalidColumnReference: ERROR: for SELECT DISTINCT, ORDER BY expressions must appear in select list" in Postgres
             selects << v if is_distinct
@@ -959,7 +963,7 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
       begin
         send(method, *args, **kwargs, &block) # method will be something like :uniq or :each
       rescue ActiveModel::MissingAttributeError => e
-        if (err_msg = e.message).start_with?('missing attribute: ') &&
+        if e.message.start_with?('missing attribute: ') &&
            klass.column_names.include?(col_name = e.message[19..-1])
           (dup_rel = dup).select_values << col_name
           ret = dup_rel.brick_(method, *args, brick_orig_relation: (brick_orig_relation ||= self), **kwargs, &block)
@@ -997,8 +1001,10 @@ Might want to add this in your brick.rb:
     end
 
     def _br_quoted_name(name)
-      if is_mysql
-        "`#{name}`"
+      if name == '*'
+        name
+      elsif is_mysql
+        "`#{name.gsub('.', '`.`')}`"
       elsif is_postgres || is_mssql
         "\"#{(name).gsub('.', '"."')}\""
       else
@@ -1258,7 +1264,7 @@ end
                # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
 
              # AVO Resource
-             elsif base_module == Object && Object.const_defined?('Avo') && requested.end_with?('Resource') &&
+             elsif base_module == Object && Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) && requested.end_with?('Resource') &&
                    # Expect that anything called MotorResource or SpinaResource could be from those administrative gems
                    requested.length > 8 && ['MotorResource', 'SpinaResource'].exclude?(requested)
                if (model = Object.const_get(requested[0..-9])) && model < ActiveRecord::Base
@@ -1310,7 +1316,7 @@ end
       built_class, code = result
       puts "\n#{code}\n"
       built_class
-    elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}") && !schema_name
+    elsif !schema_name && ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}")
 #         module_prefixes = type_name.split('::')
 #         path = base_module.name.split('::')[0..-2] + []
 #         module_prefixes.unshift('') unless module_prefixes.first.blank?
@@ -1384,7 +1390,12 @@ class Object
         relation = relations["#{schema_name}.#{matching}"]
       end
       full_name = if relation || schema_name.blank?
-                    inheritable_name || model_name
+                    if singular_table_name != table_name.singularize && # %%% Try this with http://localhost:3000/brick/spree/property_translations
+                       (schema_module = ::Brick.config.table_name_prefixes.find { |k, v| table_name.start_with?(k) }&.last&.constantize)
+                      "#{schema_module&.name}::#{inheritable_name || model_name}"
+                    else
+                      inheritable_name || model_name
+                    end
                   else # Prefix the schema to the table name + prefix the schema namespace to the class name
                     schema_module = if schema_name.is_a?(Module) # from an auto-STI namespace?
                                       schema_name
@@ -1423,7 +1434,7 @@ class Object
       hmts = nil
       code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
-        (schema_module || Object).const_set((inheritable_name || model_name).to_sym, new_model_class)
+        (schema_module || Object).const_set((chosen_name = (inheritable_name || model_name)).to_sym, new_model_class)
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
             super(subclass)
@@ -1493,7 +1504,7 @@ class Object
         unless is_sti
           fks = relation[:fks] || {}
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
-          hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
+          fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
             # The key in each hash entry (fk.first) is the constraint name
             inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
             if (invs = assoc[:inverse_table]).is_a?(Array)
@@ -1516,6 +1527,13 @@ class Object
           #   end
           # end
         end
+
+        # Enable Turbo Stream if possible -- equivalent of:  broadcasts_to ->(comment) { :comments }
+        if Object.const_defined?(:ApplicationCable) && Object.const_defined?(:Turbo) && Turbo.const_defined?(:Broadcastable) && respond_to?(:broadcasts_to)
+          relation[:broadcasts] = true
+          self.broadcasts_to ->(model) { (model&.class&.name || chosen_name).underscore.pluralize.to_sym }
+          code << "  broadcasts_to ->(#{chosen_name}) { #{chosen_name}&.class&.name&.underscore&.pluralize&.to_sym }\n"
+        end
       end # class definition
       # Having this separate -- will this now work out better?
         built_model.class_exec do
@@ -1588,7 +1606,8 @@ class Object
                 if assoc.key?(:polymorphic) ||
                    # If a polymorphic association is missing but could be established then go ahead and put it into place.
                    relations[assoc[:inverse_table]][:class_name].constantize.reflect_on_all_associations.find { |inv_assoc| !inv_assoc.belongs_to? && inv_assoc.options[:as].to_s == assoc[:assoc_name] }
-                  assoc[:polymorphic] ||= (options[:polymorphic] = true)
+                  assoc[:polymorphic] ||= true
+                  options[:polymorphic] = true
                 else
                   need_class_name = singular_table_name.underscore != assoc_name
                   need_fk = "#{assoc_name}_id" != assoc[:fk]
@@ -1686,15 +1705,33 @@ class Object
         # (More information on https://docs.avohq.io/2.0/controllers.html)
         controller_base = Avo::ResourcesController
       end
+      if !model&.table_exists? && (tn = model&.table_name)
+        msg = +"Can't find table \"#{tn}\" for model #{model.name}."
+        puts
+        # Potential bad inflection?
+        if (dym = DidYouMean::SpellChecker.new(dictionary: ::Brick.relations.keys).correct(tn)).present?
+          msg << "\nIf you meant \"#{found_dym = dym.first}\" then to avoid this message add this entry into inflections.rb:\n"
+          msg << "  inflect.irregular '#{model.name}', '#{found_dym.camelize}'"
+          model.table_name = found_dym
+          puts "WARNING:  #{msg}"
+        else
+          puts "ERROR:  #{msg}"
+        end
+        puts
+      end
       table_name = model&.table_name || ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(ActiveSupport::Inflector.underscore(plural_class_name))
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ['Mysql2', 'Trilogy'].include?(ActiveRecord::Base.connection.adapter_name)
 
-      code = +"class #{namespace}::#{class_name} < #{controller_base&.name || 'ApplicationController'}\n"
-      built_controller = Class.new(controller_base || ActionController::Base) do |new_controller_class|
-        (namespace || Object).const_set(class_name.to_sym, new_controller_class)
+      namespace = nil if namespace == ::Object
+      controller_base ||= ::Brick.config.controllers_inherit_from if ::Brick.config.controllers_inherit_from
+      controller_base = controller_base.constantize if controller_base.is_a?(String)
+      controller_base ||= ActionController::Base
+      code = +"class #{namespace&.name}::#{class_name} < #{controller_base&.name}\n"
+      built_controller = Class.new(controller_base) do |new_controller_class|
+        (namespace || ::Object).const_set(class_name.to_sym, new_controller_class)
 
         # Add a hash for the inline style to the content-security-policy if one is present
         self.define_method(:add_csp_hash) do |style_value = nil|
@@ -2014,7 +2051,15 @@ class Object
           end
         end
 
-        unless is_openapi || is_avo
+        unless is_openapi || is_avo # Normal controller (non-API)
+          if controller_base == ActionController::Base && ::Brick.relations[model.table_name].fetch(:broadcasts, nil)
+            puts "WARNING:  If you intend to use the #{model.name} model with Turbo Stream broadcasts,
+          you will want to have its controller inherit from ApplicationController instead of
+          ActionController::Base (which as you can see below is what it currently does).  To enact
+          this for every auto-generated controller, you can uncomment this line in brick.rb:
+            ::Brick.controllers_inherit_from = 'ApplicationController'"
+          end
+
           # Skip showing Bullet gem optimisation messages
           if Object.const_defined?('Bullet') && Bullet.respond_to?(:enable?)
             around_action :skip_bullet
@@ -2316,6 +2361,7 @@ end.class_exec do
 
     orig_schema = nil
     if (relations = ::Brick.relations).empty?
+      ::Brick.remove_instance_variable(:@_additional_references_loaded) if ::Brick.instance_variable_defined?(:@_additional_references_loaded)
       # Very first thing, load inflections since we'll be using .pluralize and .singularize on table and model names
       if File.exist?(inflections = ::Rails.root.join('config/initializers/inflections.rb'))
         load inflections

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

@@ -996,7 +996,7 @@ callbacks = {} %>
                 css << "<% bts = { #{
                   bt_items = bts.each_with_object([]) do |v, s|
                     foreign_models = if v.last[2] # Polymorphic?
-                                       poly_cols << @_brick_model.reflect_on_association(v[1].first).foreign_type
+                                       poly_cols << @_brick_model.brick_foreign_type(v[1].first)
                                        v.last[1].each_with_object([]) { |x, s| s << "[#{x.name}, #{x.primary_key.inspect}]" }.join(', ')
                                      else
                                        "[#{v.last[1].name}, #{v.last[1].primary_key.inspect}]"
@@ -1443,11 +1443,11 @@ end
                              entry.to_s.start_with?('@_') ||
                              ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
                            end).present?
-                         msg = \"Can't find resource \\\"#{table_name}\\\".\"
-                          # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
+                         msg = +\"Can't find resource \\\"#{table_name}\\\".\"
+                         # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
                          if (dym = DidYouMean::SpellChecker.new(dictionary: dym_list).correct('@#{table_name}')).present?
                            msg << \"\nIf you meant \\\"#\{found_dym = dym.first[1..-1]}\\\" then to avoid this message add this entry into inflections.rb:\n\"
-                           msg << \"  inflect.singular('#\{found_dym}', '#{obj_name}')\"
+                           msg << \"  inflect.irregular '#{obj_name}', '#\{found_dym}'\"
                            puts
                            puts \"WARNING:  #\{msg}\"
                            puts
@@ -1630,6 +1630,12 @@ end
 <%= form_for(obj.becomes(#{model_name}), options) do |f| %>
   <table class=\"shadow\">
   <% has_fields = false
+     # If it's a new record, set any default polymorphic types
+     bts.each do |_k, v|
+       if v[2]
+         @#{obj_name}.send(\"#\{model.brick_foreign_type(v.first)}=\", v[1].first&.first&.name)
+       end
+     end if @#{obj_name}.new_record?
      @#{obj_name}.attributes.each do |k, val|
        next if !(col = #{model_name}.columns_hash[k]) ||
                (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
@@ -1642,7 +1648,7 @@ end
         bt_name = bt[1].map { |x| x.first.name }.join('/')
         # %%% Only do this if the user has permissions to edit this bt field
         if bt[2] # Polymorphic?
-          poly_class_name = orig_poly_name = @#{obj_name}.send(\"#\{bt.first\}_type\")
+          poly_class_name = orig_poly_name = @#{obj_name}.send(model.brick_foreign_type(bt.first))
           bt_pair = nil
           loop do
             bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
@@ -1657,9 +1663,8 @@ end
           # descrips = @_brick_bt_descrip[bt.first][bt_class]
           poly_id = @#{obj_name}.send(\"#\{bt.first\}_id\")
           # bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
-        else # No polymorphism, so just get the first one
-          bt_pair = bt[1].first
         end
+        bt_pair ||= bt[1].first # If there's no polymorphism (or polymorphism status is unknown), just get the first one
         bt_class = bt_pair&.first
         if bt.length < 4
           bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
@@ -1706,7 +1711,7 @@ end
 
     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(', ')
+      obj_br_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "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
@@ -1736,21 +1741,23 @@ end
            else
              collection = @#{obj_name}.#{hm_name}
            end
+        err_msg = nil
         case collection
         when ActiveRecord::Relation # has_many (which comes in as a CollectionProxy) or a has_one#{
           poly_fix}
           collection2, descrip_cols = begin
                                         collection.brick_list
-                                      rescue
+                                      rescue => e
+                                        err_msg = '(error)'
+                                        puts \"ERROR when referencing #\{collection.klass.name}:  #\{e.message}\"
                                       end
         when ActiveRecord::Base # Object from a has_one :through
           collection2 = [collection]
         else # We get an array back when AR < 4.2
           collection2 = collection.to_a.compact
         end
-        collection2 = collection2.brick_(:uniq)
-        if collection2.empty? %>
-          <tr><td>(none)</td></tr>
+        if (collection2 = collection2&.brick_(:uniq)).blank? %>
+          <tr><td<%= ' class=\"orphan\"'.html_safe if err_msg %>><%= err_msg || '(none)' %></td></tr>
      <% else
           collection2.each do |br_#{hm_singular_name}| %>
             <tr><td><%= br_descrip = if br_#{hm_singular_name}.respond_to?(descrip_cols&.first&.first&.last)
@@ -1763,7 +1770,7 @@ end
                                        pks.map! { |pk| br_#{hm_singular_name}.send(pk).to_s }
                                        \"#\{klass.name} ##\{pks.join(', ')}\"
                                      end
-                        link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(br_#{obj_pk}))) %></td></tr>
+                        link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_br_pk}))) %></td></tr>
           <% end %>
         <% end %>
       </table>"

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

@@ -86,8 +86,7 @@ module Brick::Rails::FormTags
         if (bt || composite_bt_names[col_name])
           if bt[2] # Polymorphic?
             if (poly_id = obj.send("#{bt.first}_id"))
-              # Was:  obj.send("#{bt.first}_type")
-              bt_class = obj.send(obj.class.reflect_on_association(bt.first).foreign_type)
+              bt_class = obj.send(klass.brick_foreign_type(bt.first))
               base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
               out << link_to("#{bt_class} ##{poly_id}", send("#{base_class_underscored}_path".to_sym, poly_id))
             end
@@ -98,7 +97,7 @@ module Brick::Rails::FormTags
               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]
+                            [klass.reflect_on_association(bt.first)&.foreign_key]
                           else
                             descrips.last
                           end
@@ -132,7 +131,7 @@ module Brick::Rails::FormTags
               end
             elsif obj.respond_to?(ct_col = hms_col[1].to_sym) && (ct = obj.send(ct_col)&.to_i)&.positive?
               predicates = hms_col[2].each_with_object({}) { |v, s| s[v.first] = v.last.is_a?(String) ? v.last : obj.send(v.last) }
-              predicates.each { |k, v| predicates[k] = obj.class.name if v == '[sti_type]' }
+              predicates.each { |k, v| predicates[k] = klass.name if v == '[sti_type]' }
               out << "#{link_to("#{ct || 'View'} #{hms_col.first}",
                                 send("#{hm_klass._brick_index}_path".to_sym, predicates))}\n"
             end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -188,6 +188,10 @@ module Brick
       bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
         # %%% The time will come when we will support type checking of composite foreign keys!
         # binding.pry if a.foreign_key.is_a?(Array)
+        if a.belongs_to? && !a.polymorphic? && ::Brick.config.polymorphics.fetch(full_assoc_name = "#{model.table_name}.#{a.name}", nil)
+          puts "Based on inclusion in ::Brick.polymorphics, marking association #{full_assoc_name} as being polymorphic."
+          a.options[:polymorphic] = true
+        end
         next unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
                     (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
                      (!a.belongs_to? || model_cols[a.foreign_key]&.type == pk_type)
@@ -395,6 +399,11 @@ module Brick
       Brick.config.models_inherit_from = value
     end
 
+    # @api public
+    def controllers_inherit_from=(value)
+      Brick.config.controllers_inherit_from = value
+    end
+
     # @api public
     def table_name_prefixes=(value)
       Brick.config.table_name_prefixes = value
@@ -1388,13 +1397,13 @@ ActiveSupport.on_load(:active_record) do
     end
   end
 
-  if ActiveRecord.version < ::Gem::Version.new('6.1') &&
+  if ActiveRecord.version < ::Gem::Version.new('6.1.4') &&
      Psych.method(:load).parameters.any? { |param| param.first == :key && param.last == :aliases }
     Psych.class_exec do
       class << self
         alias _original_load load
         def load(yaml, *args, **kwargs)
-          if caller.first.end_with?("`database_configuration'") && kwargs[:aliases].nil?
+          if kwargs[:aliases].nil? && caller[0..4].any? { |line| line.end_with?("`database_configuration'") }
             kwargs[:aliases] = true
           end
           _original_load(yaml, *args, **kwargs)
@@ -1600,7 +1609,7 @@ if Gem::Specification.all_names.find { |g| g.start_with?('awesome_nested_set-')
   ::CollectiveIdea::Acts::NestedSet::Columns.class_exec do
     alias _brick_order_column_name order_column_name
     def order_column_name
-      unless (ord_col = _brick_order_column_name).start_with?(tbl_prefix = "#{table_name}.")
+      unless (ord_col = _brick_order_column_name).start_with?(tbl_prefix = +"#{table_name}.")
         ord_col = tbl_prefix << ord_col
       end
       ord_col

data/lib/generators/brick/install_generator.rb

@@ -176,6 +176,12 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # # Class that auto-generated models should inherit from
   # Brick.models_inherit_from = ApplicationRecord
 
+  # # Class that auto-generated controllers should inherit from
+  # # (Would generally want to un-comment this line if you want to enforce any authentication which is
+  # # established in your ApplicationController, or for auto-created controllers to support
+  # # Turbo Stream broadcasts.)
+  # ::Brick.controllers_inherit_from = 'ApplicationController'
+
   # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
   # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.146
+  version: 1.0.147
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-25 00:00:00.000000000 Z
+date: 2023-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord