brick 1.0.48 → 1.0.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9c3989f395bc81df36b3f295c72029e92911bd24f8d146db5627fb29c1875f4
-  data.tar.gz: 97ae12a1562f9f9bae5f401016e219a5ad58218068f80d7fc0e732d61c4f3f90
+  metadata.gz: 8b42f1ad45e6dc942ed2e875d39318f8705f9a467c0cb31f267a71a01053bfd4
+  data.tar.gz: 1e8f0cd1c374c5d75be4e4f1a8b659dd32b46f991c85cce4d234a6949d017e4b
 SHA512:
-  metadata.gz: c64d02f90b992640698523190a920467204a2fbb40fb9e21a3e7872ae469db3506bdf7fb535e54cd33157feb93ed43c2d1c11b2bea952bc9f034ac7e7dfb6b06
-  data.tar.gz: 6c01156b2b35f387e531ed6835a7517f5249b72ec53bb23d5d965c4b298a443d9a62e5694f9c1b4587f6ab04ef30590d7d9077e13c66b651ee8ed12b76282932
+  metadata.gz: 437d415278f01a2ffced31687f77324c21416e6e7ef395d6a5d3db5a1853ccfb301c01716747ba4427417164a1200100205e7b7c75443bef83f1050f01683dda
+  data.tar.gz: d42367f291f2900876c5263aab30280f7b5b3d9f205c4199349b9e24d35326b5457e1db8fd0d39a512f59af9691bbe44e29dd05d3384d5a0013c05ffe6447d8c

data/lib/brick/config.rb

@@ -190,6 +190,30 @@ module Brick
       @mutex.synchronize { @table_name_prefixes = value }
     end
 
+    def order
+      @mutex.synchronize { @order || {} }
+    end
+
+    # Get something like:
+    # Override how code sorts with:
+    #   { 'on_call_list' => { code: "ORDER BY STRING_TO_ARRAY(code, '.')::int[]" } }
+    # Specify default thing to order_by with:
+    #   { 'on_call_list' => { _brick_default: [:last_name, :first_name] } }
+    #   { 'on_call_list' => { _brick_default: :sequence } }
+    def order=(orders)
+      @mutex.synchronize do
+        case (brick_default = orders.fetch(:_brick_default, nil))
+        when NilClass
+          orders[:_brick_default] = orders.keys.reject { |k| k == :_brick_default }.first
+        when String
+          orders[:_brick_default] = [brick_default.to_sym]
+        when Symbol
+          orders[:_brick_default] = [brick_default]
+        end
+        @order = orders
+      end
+    end
+
     def metadata_columns
       @mutex.synchronize { @metadata_columns }
     end

data/lib/brick/extensions.rb

@@ -221,6 +221,62 @@ module ActiveRecord
       template
     end
 
+    # belongs_to DSL descriptions
+    def self._br_bt_descrip
+      @_br_bt_descrip ||= {}
+    end
+    # has_many count definitions
+    def self._br_hm_counts
+      @_br_hm_counts ||= {}
+    end
+
+    # Search for BT, HM, and HMT DSL stuff
+    def self._brick_calculate_bts_hms(translations, join_array)
+      bts, hms, associatives = ::Brick.get_bts_and_hms(self)
+      bts.each do |_k, bt|
+        next if bt[2] # Polymorphic?
+
+        # join_array will receive this relation name when calling #brick_parse_dsl
+        _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
+                                   else
+                                     { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
+                                   end
+      end
+      skip_klass_hms = ::Brick.config.skip_index_hms[self.name] || {}
+      hms.each do |k, hm|
+        next if skip_klass_hms.key?(k)
+
+        if hm.macro == :has_one
+          # For our purposes a :has_one is similar enough to a :belongs_to that we can just join forces
+          _br_bt_descrip[k] = { hm.klass => hm.klass.brick_parse_dsl(join_array, k, translations) }
+        else # Standard :has_many
+          _br_hm_counts[k] = hm
+        end
+      end
+    end
+
+    def self._brick_calculate_ordering(ordering, is_do_txt = true)
+      quoted_table_name = table_name.split('.').map { |x| "\"#{x}\"" }.join('.')
+      order_by_txt = [] if is_do_txt
+      ordering = [ordering] if ordering && !ordering.is_a?(Array)
+      order_by = ordering&.map do |ord_part| # %%% If a term is also used as an eqi-condition in the WHERE clause, it can be omitted from ORDER BY
+                   case ord_part
+                   when String
+                     ord_expr = ord_part.gsub('^^^', quoted_table_name)
+                     order_by_txt&.<<("Arel.sql(#{ord_expr})")
+                     Arel.sql(ord_expr)
+                   else # Expecting only Symbol
+                     ord_part = "_br_#{ord_part}_ct" if _br_hm_counts.key?(ord_part)
+                     # Retain any reference to a bt_descrip as being a symbol
+                     # Was:  "#{quoted_table_name}.\"#{ord_part}\""
+                     order_by_txt&.<<(_br_bt_descrip.key?(ord_part) ? ord_part : ord_part.inspect)
+                     ord_part
+                   end
+                 end
+      [order_by, order_by_txt]
+    end
+
   private
 
     def self._brick_get_fks
@@ -310,13 +366,12 @@ module ActiveRecord
       end
     end
 
-    def brick_select(params, selects = nil, bt_descrip = {}, hm_counts = {}, join_array = ::Brick::JoinArray.new
-      # , is_add_bts, is_add_hms
-    )
-      is_add_bts = is_add_hms = true
+    def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
+        next if ['_brick_schema', '_brick_order'].include?(k)
+
         case (ks = k.split('.')).length
         when 1
           next unless klass._brick_get_fks.include?(k)
@@ -345,33 +400,6 @@ module ActiveRecord
         end
       end
 
-      # Search for BT, HM, and HMT DSL stuff
-      translations = {}
-      if is_add_bts || is_add_hms
-        bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
-        bts.each do |_k, bt|
-          next if bt[2] # Polymorphic?
-
-          # join_array will receive this relation name when calling #brick_parse_dsl
-          bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                   bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
-                                 else
-                                   { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
-                                 end
-        end
-        skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
-        hms.each do |k, hm|
-          next if skip_klass_hms.key?(k)
-
-          if hm.macro == :has_one
-            # For our purposes a :has_one is similar enough to a :belongs_to that we can just join forces
-            bt_descrip[k] = { hm.klass => hm.klass.brick_parse_dsl(join_array, k, translations) }
-          else # Standard :has_many
-            hm_counts[k] = hm
-          end
-        end
-      end
-
       if join_array.present?
         left_outer_joins!(join_array)
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
@@ -380,7 +408,7 @@ module ActiveRecord
         chains = rel_dupe._brick_chains
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
-        bt_columns = bt_descrip.each_with_object([]) do |v, s|
+        bt_columns = klass._br_bt_descrip.each_with_object([]) do |v, s|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
 
@@ -416,7 +444,7 @@ module ActiveRecord
         end
       end
       # Add derived table JOIN for the has_many counts
-      hm_counts.each do |k, hm|
+      klass._br_hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
                          fk_col = (associative = associatives[hm.name])&.foreign_key
@@ -450,12 +478,31 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
       where!(wheres) unless wheres.empty?
+      # Must parse the order_by and see if there are any symbols which refer to BT associations
+      # as they must be expanded to find the corresponding _br_model__column naming for each.
+      if order_by.present?
+        final_order_by = *order_by.each_with_object([]) do |v, s|
+          if v.is_a?(Symbol)
+            # 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 }
+              end
+            else
+              s << v
+            end
+          else # String stuff just comes straight through
+            s << v
+          end
+        end
+        order!(*final_order_by)
+      end
       limit!(1000) # Don't want to get too carried away just yet
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
   private
-
+  
     def shift_or_first(ary)
       ary.length > 1 ? ary.shift : ary.first
     end
@@ -926,21 +973,26 @@ class Object
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
         # Brick-specific pages
-        if plural_class_name == 'BrickGem'
+        case plural_class_name
+        when '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']
+        when 'BrickSwagger'
+          is_swagger = true # if request.format == :json)
         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"
-          code << "    @#{table_name}.brick_select(params)\n"
-          code << "  end\n"
-        end
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
+          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
+          # wants to do an ORDER BY based on any of that
+          translations = {}
+          join_array = ::Brick::JoinArray.new
+          is_add_bts = is_add_hms = true
+          # This builds out bt_descrip and hm_counts on the model
+          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+
           if is_swagger
             json = { 'openapi': '3.0.1', 'info': { 'title': 'API V1', 'version': 'v1' },
                      'servers': [
@@ -990,6 +1042,32 @@ class Object
             render inline: json.to_json, content_type: request.format
             return
           end
+
+          # Normal (non-swagger) request
+
+          # %%% Allow params to define which columns to use for order_by
+          ordering = if (order_tbl = ::Brick.config.order[table_name])
+                       case (order_default = order_tbl[:_brick_default])
+                       when Array
+                         order_default.map { |od_part| order_tbl[od_part] || od_part }
+                       when Symbol
+                         order_tbl[order_default] || order_default
+                       else
+                         pk
+                       end
+                     else
+                       pk # If it's not a custom ORDER BY, just use the key
+                     end
+          order_by, order_by_txt = model._brick_calculate_ordering(ordering)
+          if (order_params = params['_brick_order']&.split(',')&.map(&:to_sym)) # Overriding the default by providing a querystring param?
+            order_by, _ = model._brick_calculate_ordering(order_params, true) # Don't do the txt part
+          end
+
+          code << "  def index\n"
+          code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
+          code << "    @#{table_name}.brick_select(params)\n"
+          code << "  end\n"
+
           ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
@@ -1003,19 +1081,16 @@ class Object
             return
           end
 
-          quoted_table_name = model.table_name.split('.').map { |x| "\"#{x}\"" }.join('.')
-          order = pk.each_with_object([]) { |pk_part, s| s << "#{quoted_table_name}.\"#{pk_part}\"" }
-          ar_relation = order.present? ? model.order("#{order.join(', ')}") : model.all
-          @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by, translations, join_array)
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
-          counts = hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
+          counts = model._br_hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
           instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
-          @_brick_bt_descrip = bt_descrip
-          @_brick_hm_counts = hm_counts
+          @_brick_bt_descrip = model._br_bt_descrip
+          @_brick_hm_counts = model._br_hm_counts
           @_brick_join_array = join_array
         end
 

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

@@ -33,6 +33,9 @@ module Brick
         # Additional references (virtual foreign keys)
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
+        # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
+        ::Brick.order = app.config.brick.fetch(:order, {})
+
         # Skip creating a has_many association for these
         ::Brick.exclude_hms = app.config.brick.fetch(:exclude_hms, nil)
 
@@ -199,6 +202,9 @@ table thead tr th, table tr th {
   color: #fff;
   text-align: left;
 }
+#headerTop th:hover, #headerTop th:hover {
+  background-color: #18B090;
+}
 table thead tr th a, table tr th a {
   color: #80FFB8;
 }
@@ -547,30 +553,33 @@ if (headerTop) {
 <br>
 <table id=\"headerTop\">
 <table id=\"#{table_name}\">
-  <thead><tr>#{'<th></th>' if pk.present?}<%
+  <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%
      col_order = []
      @#{table_name}.columns.each do |col|
        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
-    %><th<%= \" title = \\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>><%
+    %><th<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %><%
        if (bt = bts[col_name]) %>
-         BT <%
+         <%= \" x-order=\\\"#\{bt.first}\\\"\".html_safe if true # Currently we always allow click to sort
+         %>>BT <%
          bt[1].each do |bt_pair| %><%=
            bt_pair.first.bt_link(bt.first) %> <%
          end %><%
-       else %><%=
-         col_name %><%
+       else %><%= \" x-order=\\\"#\{col_name}\\\"\".html_safe if true # Currently we always allow click to sort
+         %>><%= col_name %><%
        end
     %></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 do |h|
+        # Currently we always allow click to sort
+        "<th#{" x-order=\"#{h.first.name}\"" if true}>" +
         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
+    "#{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>"
+    "#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
         end
       end.join
   }</tr></thead>
@@ -658,7 +667,7 @@ end
     <tr>
     <% next if (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
                ::Brick.config.metadata_columns.include?(k) %>
-    <th class=\"show-field\"<%= \" title = \\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
+    <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
     <% has_fields = true
       if (bt = bts[k])
         # Add a final member in this array with descriptive options to be used in <select> drop-downs
@@ -729,9 +738,14 @@ end
       <% when :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'
+          # If it's not yet enabled then:  create extension \"uuid-ossp\";
           # ActiveUUID gem created a new :uuid type
           val %>
+      <% when :ltree %>
+        <%=
+          # In Postgres labels of data stored in a hierarchical tree-like structure
+          # If it's not yet enabled then:  create extension ltree;
+          val %>
       <% when :binary, :primary_key %>
       <% end %>
     <% end %>
@@ -789,6 +803,13 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
 </script>
 <% end %>
 <script>
+<% # Make column headers sort when clicked
+   # %%% Create a smart javascript routine which can do this client-side %>
+[... document.getElementsByTagName(\"TH\")].forEach(function (th) {
+  th.addEventListener(\"click\", function (e) {
+    location.href = changeout(location.href, \"_brick_order\", this.getAttribute(\"x-order\"));
+  });
+});
 document.querySelectorAll(\"input, select\").forEach(function (inp) {
   var origVal = getInpVal(),
       prevVal = origVal;

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -283,6 +283,11 @@ module Brick
       end
     end
 
+    # @api public
+    def order=(value)
+      Brick.config.order = value
+    end
+
     # Skip creating a has_many association for these
     # (Uses the same exact three-part format as would define an additional_reference)
     # @api public

data/lib/generators/brick/install_generator.rb

@@ -159,6 +159,41 @@ module Brick
 # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
 # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
 
+# # COLUMN SEQUENCING AND INCLUSION / EXCLUSION
+
+# # By default if there is a primary key present then rows in an index view are ordered by this primary key.  To
+# # use a different rule for doing ORDER BY, you can override this default ordering done by The Brick, for instance
+# # to have the rows in a contact list sorted by email:
+# Brick.order = { 'contacts' => { _brick_default: :email } }
+# # or by last name then first name:
+# Brick.order = { 'contacts' => { _brick_default: [:lastname, :firstname] } }
+# # Totally legitimate to have the default order be the name of a belongs_to or has_many association instead of an
+# # actual column name, in which case for has_many it just orders by the count of how many records are associated,
+# # and for belongs_to it's based on the primary table's DSL if any is defined (since that is what is used to
+# # calculate what is shown when a foreign table lists out related records).  If contacts relates to addresses,
+# # then this is perfectly fine:
+# Brick.order = { 'contacts' => { _brick_default: :address } }
+# # You can even have a specific custom clause used in the ORDER BY.  In this case it is recommended to include a
+# # special placeholder for the table name with the sequence \"^^^\".  Here is an example of having the default
+# # ordering happening on the \"code\" column, and also defining custom sorting to be done, in this case proper
+# # ordering if that code is stored as a dotted numeric value:
+# Brick.order = { 'document_trees' => { _brick_default: :code,
+#                                       code: \"ORDER BY STRING_TO_ARRAY(^^^.code, '.')::int[]\" } }
+
+# # Sequence of columns for each model.  This also allows you to add read-only calculated columns in the same
+# # kind of way that they can be added in the include: portion of include/exclude columns, below.
+# # Designated by { <table name> => [<column name>, <column name>] }
+# Brick.column_sequence = { 'users' => ['email', 'profile.firstname', 'profile.lastname'] }
+
+# # Specific columns to include or exclude for each model.  If there are only inclusions then only those
+# # columns show.  If there are any exclusions then all non-excluded columns are attempted to be shown,
+# # which negates the usefulness of inclusions except to add calculated column detail built from DSL.
+# # Designated by <table name>.<column name>
+# Brick.column_sequence = { 'users' =>   { include: ['email', 'profile.firstname', 'profile.lastname'] },
+#                           'profile' => { exclude: ['birthdate'] } }
+
+# # EXTRA FOREIGN KEYS AND OTHER HAS_MANY SETTINGS
+
 # # Additional table references which are used to create has_many / belongs_to associations inside auto-created
 # # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
 # # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
@@ -176,8 +211,9 @@ module Brick
 # Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
 
 # # Skip showing counts for these specific has_many associations when building auto-generated #index views.
-# # When there are related tables with a significant number of records, this can lessen the load on the database
-# # considerably, sometimes fixing what might appear to be an index page that just \"hangs\" for no apparent reason.
+# # When there are related tables with a significant number of records (generally 100,000 or more), this can lessen
+# # the load on the database considerably, sometimes fixing what might appear to be an index page that just \"hangs\"
+# # for no apparent reason.
 # Brick.skip_index_hms = ['User.litany_of_woes']
 
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
@@ -199,6 +235,8 @@ module Brick
 # # Designated by <table name>.<column name>
 # Brick.not_nullables = ['users.name']
 
+# # FRIENDLY DSL
+
 # # A simple DSL is available to allow more user-friendly display of objects.  Normally a user object might be shown
 # # as its first non-metadata column, or if that is not available then something like \"User #45\" where 45 is that
 # # object's ID.  If there is no primary key then even that is not possible, so the object's .to_s method is called.
@@ -206,6 +244,8 @@ module Brick
 # # 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]' }
 
+# # SINGLE TABLE INHERITANCE
+
 # # 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
@@ -221,6 +261,8 @@ module Brick
 # Brick.sti_type_column = 'sti_type'
 # Brick.sti_type_column = { 'rails_type' => ['sales.specialoffer'] }
 
+# # POLYMORPHIC ASSOCIATIONS
+
 # # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes in the case that
 # # it wasn't originally specified.
 # Brick.schema_behavior = :namespaced
@@ -231,6 +273,8 @@ module Brick
 
 # # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 
+# # DEFAULT ROOT ROUTE
+
 # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
 # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
 # # name and action you wish in order to override this and have that be the default route when none other has been

metadata

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