brick 1.0.19 → 1.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57a1d4e3774c90984cfc435d9ed87e42b74c364b01fd7ced7df740f5005b935e
-  data.tar.gz: 8222088ef88ca48cd90144c8503638644195f2d593ff95d7b2e3530304ac6fb2
+  metadata.gz: 41b64e2d571540382ce5ecd497f1e1413fde20119d46f1b24e1fae5af428fb45
+  data.tar.gz: 1c26ccf7b8df54fd121546e8daeeb9508561328186af46aea8ba1bd819524532
 SHA512:
-  metadata.gz: 2b785c34e1a21563232ae54f6af25989fe02b73f92eb1327b27d6f21e80b7e353a5995305c4c1188dda885465a196f87fb5979a13c3e6a0219d4895dc59593dd
-  data.tar.gz: bd2018d48dad15f51d7a87e39d2710bde9a5becbe969e741004bf730f57faecbd84a81a2f75cfdd60c2ff48f239fe6c5c8d3f47b4b2f79e355b7f100f9bb7943
+  metadata.gz: e103d061b74402f3fe0b944d06b30c20f053166c706a54f15753afc8cb0c703ae71f83bd88191f985a37180cb9bdafdba918178174df08f58f683a723fcfb73a
+  data.tar.gz: 13a7dce7f4f5789a0d7a0c6cae4adcaf2f44d22d0f59c355d75102a7f08292d80c781f8d33be121801d375fd33fed8bcdf4ef6b56108ef8f4ab4110c1f49e296

data/lib/brick/extensions.rb

@@ -32,32 +32,101 @@
 
 # Currently quadrupling up routes
 
+
+# From the North app:
+# undefined method `built_in_role_path' when referencing show on a subclassed STI:
+#  http://localhost:3000/roles/3?_brick_schema=cust1
+
+
 # ==========================================================
 # Dynamically create model or controller classes when needed
 # ==========================================================
 
 # By default all models indicate that they are not views
+module Arel
+  class Table
+    def _arel_table_type
+      # AR < 4.2 doesn't have type_caster at all, so rely on an instance variable getting set
+      # AR 4.2 - 5.1 have buggy type_caster entries for the root node
+      instance_variable_get(:@_arel_table_type) ||
+      # 5.2-7.0 does type_caster just fine, no bugs there, but the property with the type differs:
+      # 5.2 has "types" as public, 6.0 "types" as private, and >= 6.1 "klass" as private.
+      ((tc = send(:type_caster)) && tc.instance_variable_get(:@types)) ||
+      tc.send(:klass)
+    end
+  end
+end
+
 module ActiveRecord
   class Base
+    def self._assoc_names
+      @_assoc_names ||= {}
+    end
+
     def self.is_view?
       false
     end
 
     # Used to show a little prettier name for an object
-    def brick_descrip
-      klass = self.class
-      # If available, parse simple DSL attached to a model in order to provide a friendlier name.
-      # Object property names can be referenced in square brackets like this:
-      # { 'User' => '[profile.firstname] [profile.lastname]' }
-
+    def self.brick_get_dsl
       # If there's no DSL yet specified, just try to find the first usable column on this model
-      unless ::Brick.config.model_descrips[klass.name]
-        descrip_col = (klass.columns.map(&:name) - klass._brick_get_fks -
+      unless (dsl = ::Brick.config.model_descrips[name])
+        descrip_col = (columns.map(&:name) - _brick_get_fks -
                       (::Brick.config.metadata_columns || []) -
-                      [klass.primary_key]).first
-        ::Brick.config.model_descrips[klass.name] = "[#{descrip_col}]" if descrip_col
+                      [primary_key]).first
+        dsl = ::Brick.config.model_descrips[name] = "[#{descrip_col}]" if descrip_col
       end
-      if (dsl ||= ::Brick.config.model_descrips[klass.name])
+      dsl
+    end
+
+    # Pass in true or a JoinArray
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {})
+      build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
+      build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+      members = []
+      bracket_name = nil
+      prefix = [prefix] unless prefix.is_a?(Array)
+      if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        klass = nil
+        dsl.each_char do |ch|
+          if bracket_name
+            if ch == ']' # Time to process a bracketed thing?
+              parts = bracket_name.split('.')
+              first_parts = parts[0..-2].map { |part| klass = klass.reflect_on_association(part_sym = part.to_sym).klass; part_sym }
+              parts = prefix + first_parts + [parts[-1]]
+              if parts.length > 1
+                s = build_array
+                parts[0..-3].each { |v| s = s[v.to_sym] }
+                s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
+                translations[parts[0..-2].join('.')] = klass
+              end
+              members << parts
+              bracket_name = nil
+            else
+              bracket_name << ch
+            end
+          elsif ch == '['
+            bracket_name = +''
+            klass = self
+          end
+        end
+      else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
+        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
+        x[prefix[-1]] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
+      end
+      members
+    end
+
+    # If available, parse simple DSL attached to a model in order to provide a friendlier name.
+    # Object property names can be referenced in square brackets like this:
+    # { 'User' => '[profile.firstname] [profile.lastname]' }
+    def brick_descrip
+      self.class.brick_descrip(self)
+    end
+
+    def self.brick_descrip(obj, data = nil, pk_alias = nil)
+      if (dsl = ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
+        idx = -1
         caches = {}
         output = +''
         is_brackets_have_content = false
@@ -65,18 +134,23 @@ module ActiveRecord
         dsl.each_char do |ch|
           if bracket_name
             if ch == ']' # Time to process a bracketed thing?
-              obj_name = +''
-              obj = self
-              bracket_name.split('.').each do |part|
-                obj_name += ".#{part}"
-                obj = if caches.key?(obj_name)
-                        caches[obj_name]
+              datum = if data
+                        data[idx += 1].to_s
                       else
-                        (caches[obj_name] = obj&.send(part.to_sym))
+                        obj_name = +''
+                        this_obj = obj
+                        bracket_name.split('.').each do |part|
+                          obj_name += ".#{part}"
+                          this_obj = if caches.key?(obj_name)
+                                       caches[obj_name]
+                                     else
+                                       (caches[obj_name] = this_obj&.send(part.to_sym))
+                                     end
+                        end
+                        this_obj&.to_s || ''
                       end
-              end
-              is_brackets_have_content = true unless (obj&.to_s).blank?
-              output << (obj&.to_s || '')
+              is_brackets_have_content = true unless (datum).blank?
+              output << (datum || '')
               bracket_name = nil
             else
               bracket_name << ch
@@ -91,10 +165,14 @@ module ActiveRecord
       end
       if is_brackets_have_content
         output
-      elsif klass.primary_key
-        "#{klass.name} ##{send(klass.primary_key)}"
+      elsif pk_alias
+        if (id = obj.send(pk_alias))
+          "#{klass.name} ##{id}"
+        end
+      # elsif klass.primary_key
+      #   "#{klass.name} ##{obj.send(klass.primary_key)}"
       else
-        to_s
+        obj.to_s
       end
     end
 
@@ -106,9 +184,91 @@ module ActiveRecord
   end
 
   class Relation
-    def brick_where(params)
+    attr_reader :_brick_chains
+
+    # CLASS STUFF
+    def _recurse_arel(piece, prefix = '')
+      names = []
+      # Our JOINs mashup of nested arrays and hashes
+      # binding.pry if defined?(@arel)
+      case piece
+      when Array
+        names += piece.inject([]) { |s, v| s + _recurse_arel(v, prefix) }
+      when Hash
+        names += piece.inject([]) do |s, v|
+          new_prefix = "#{prefix}#{v.first}_"
+          s << [v.last.shift, new_prefix]
+          s + _recurse_arel(v.last, new_prefix)
+        end
+
+      # ActiveRecord AREL objects
+      when Arel::Nodes::Join # INNER or OUTER JOIN
+        # rubocop:disable Style/IdenticalConditionalBranches
+        if piece.right.is_a?(Arel::Table) # Came in from AR < 3.2?
+          # Arel 2.x and older is a little curious because these JOINs work "back to front".
+          # The left side here is either another earlier JOIN, or at the end of the whole tree, it is
+          # the first table.
+          names += _recurse_arel(piece.left)
+          # The right side here at the top is the very last table, and anywhere else down the tree it is
+          # the later "JOIN" table of this pair.  (The table that comes after all the rest of the JOINs
+          # from the left side.)
+          names << [piece.right._arel_table_type, (piece.right.table_alias || piece.right.name)]
+        else # "Normal" setup, fed from a JoinSource which has an array of JOINs
+          # The left side is the "JOIN" table
+          names += _recurse_arel(piece.left)
+          # The expression on the right side is the "ON" clause
+          # on = piece.right.expr
+          # # Find the table which is not ourselves, and thus must be the "path" that led us here
+          # parent = piece.left == on.left.relation ? on.right.relation : on.left.relation
+          # binding.pry if piece.left.is_a?(Arel::Nodes::TableAlias)
+          table = piece.left
+          if table.is_a?(Arel::Nodes::TableAlias)
+            alias_name = table.right
+            table = table.left
+          end
+          (_brick_chains[table._arel_table_type] ||= []) << (alias_name || table.table_alias || table.name)
+          # puts "YES! #{self.object_id}"
+        end
+        # rubocop:enable Style/IdenticalConditionalBranches
+      when Arel::Table # Table
+        names << [piece._arel_table_type, (piece.table_alias || piece.name)]
+      when Arel::Nodes::TableAlias # Alias
+        # Can get the real table name from:  self._recurse_arel(piece.left)
+        names << [piece.left._arel_table_type, piece.right.to_s] # This is simply a string; the alias name itself
+      when Arel::Nodes::JoinSource # Leaving this until the end because AR < 3.2 doesn't know at all about JoinSource!
+        # Spin up an empty set of Brick alias name chains at the start
+        @_brick_chains = {}
+        # The left side is the "FROM" table
+        # names += _recurse_arel(piece.left)
+        names << [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)]
+        # The right side is an array of all JOINs
+        piece.right.each { |join| names << _recurse_arel(join) }
+      end
+      names
+    end
+
+    # INSTANCE STUFF
+    def _arel_alias_names
+      # %%% If with Rails 3.1 and older you get "NoMethodError: undefined method `eq' for nil:NilClass"
+      # when trying to call relation.arel, then somewhere along the line while navigating a has_many
+      # relationship it can't find the proper foreign key.
+      core = arel.ast.cores.first
+      # Accommodate AR < 3.2
+      if core.froms.is_a?(Arel::Table)
+        # All recent versions of AR have #source which brings up an Arel::Nodes::JoinSource
+        _recurse_arel(core.source)
+      else
+        # With AR < 3.2, "froms" brings up the top node, an Arel::Nodes::InnerJoin
+        _recurse_arel(core.froms)
+      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
       wheres = {}
-      rel_joins = []
+      has_hm = false
       params.each do |k, v|
         case (ks = k.split('.')).length
         when 1
@@ -116,23 +276,86 @@ module ActiveRecord
         when 2
           assoc_name = ks.first.to_sym
           # Make sure it's a good association name and that the model has that column name
-          next unless klass.reflect_on_association(assoc_name)&.klass&.columns&.map(&:name)&.include?(ks.last)
-
-          rel_joins << assoc_name unless rel_joins.include?(assoc_name)
+          next unless (assoc = klass.reflect_on_association(assoc_name))&.klass&.columns&.map(&:name)&.include?(ks.last)
+
+          # So that we can map an association name to any special alias name used in an AREL query
+          ans = (assoc.klass._assoc_names[assoc_name] ||= [])
+          ans << assoc.klass unless ans.include?(assoc.klass)
+          # There is some potential for duplicates when there is an HM-based where in play.  De-duplicate if so.
+          has_hm ||= assoc.macro == :has_many
+          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
         end
         wheres[k] = v.split(',')
       end
-      unless wheres.empty?
-        where!(wheres)
-        joins!(rel_joins) unless rel_joins.empty?
-        wheres # Return the specific parameters that we did use
+      # distinct! if has_hm
+
+      # %%% Skip the metadata columns
+      if selects&.empty? # Default to all columns
+        columns.each do |col|
+          selects << "#{table.name}.#{col.name}"
+        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|
+          # join_array[bt.first] = nil # Store this relation name in our special collection for .joins()
+          bt_descrip[bt.first] = [bt.last, bt.last.brick_parse_dsl(join_array, bt.first, translations)]
+        end
+        hms.each do |k, hm|
+          join_array[k] = nil # Store this relation name in our special collection for .joins()
+          hm_counts[k] = nil # Placeholder that will be filled in once we know the proper table alias
+        end
       end
+      where!(wheres) unless wheres.empty?
+      if join_array.present?
+        left_outer_joins!(join_array) # 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.
+        (rel_dupe = dup)._arel_alias_names
+        core_selects = selects.dup
+        groups = []
+        chains = rel_dupe._brick_chains
+        id_for_tables = {}
+        bt_columns = bt_descrip.each_with_object([]) do |v, s|
+          tbl_name = chains[v.last.first].first
+          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(tbl_name)
+            groups << (unaliased = "#{tbl_name}.#{id_col}")
+            selects << "#{unaliased} AS \"#{(id_alias = id_for_tables[tbl_name] = "_brfk_#{v.first}__#{id_col}")}\""
+            v.last << id_alias
+          end
+          if (col_name = v.last[1].last&.last)
+            v.last[1].map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
+              groups << (unaliased = "#{tbl_name = chains[sel_col.first].first}.#{sel_col.last}")
+              # col_name is weak when there are multiple, using sel_col.last instead
+              tbl_name2 = tbl_name.start_with?('public.') ? tbl_name[7..-1] : tbl_name
+              selects << "#{unaliased} AS \"#{(col_alias = "_brfk_#{tbl_name2}__#{sel_col.last}")}\""
+              v.last[1][idx] << col_alias
+            end
+          end
+        end
+        group!(core_selects + groups) if hm_counts.any? #  + bt_columns
+        join_array.each do |assoc_name|
+          # %%% Need to support {user: :profile}
+          next unless assoc_name.is_a?(Symbol)
+
+          klass = reflect_on_association(assoc_name)&.klass
+          table_alias = chains[klass].length > 1 ? chains[klass].shift : chains[klass].first
+          _assoc_names[assoc_name] = [table_alias, klass]
+        end
+        # Copy entries over
+        hm_counts.keys.each do |k|
+          hm_counts[k] = _assoc_names[k]
+        end
+      end
+      wheres unless wheres.empty? # Return the specific parameters that we did use
     end
   end
 
   module Inheritance
     module ClassMethods
-      private
+    private
 
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
@@ -145,10 +368,8 @@ module ActiveRecord
           module_prefixes = type_name.split('::')
           module_prefixes.unshift('') unless module_prefixes.first.blank?
           module_name = module_prefixes[0..-2].join('::')
-          if ::Brick.config.sti_namespace_prefixes&.key?("::#{module_name}::") ||
-             ::Brick.config.sti_namespace_prefixes&.key?("#{module_name}::")
-            _brick_find_sti_class(type_name)
-          elsif File.exist?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
+          if (snp = ::Brick.config.sti_namespace_prefixes)&.key?("::#{module_name}::") || snp&.key?("#{module_name}::") ||
+             File.exist?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
             _brick_find_sti_class(type_name) # Find this STI class normally
           else
             # Build missing prefix modules if they don't yet exist
@@ -227,10 +448,9 @@ class Object
       end
 
       relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-      is_controllers_enabled = ::Brick.enable_controllers? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
-      result = if is_controllers_enabled && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
+      result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
                  # Otherwise now it's up to us to fill in the gaps
-                 if (model = ActiveSupport::Inflector.singularize(plural_class_name).constantize)
+                 if (model = plural_class_name.singularize.constantize)
                    # 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.
                    build_controller(class_name, plural_class_name, model, relations)
                  end
@@ -281,6 +501,7 @@ class Object
         end
         return
       end
+
       if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
         is_sti = true
       else
@@ -442,13 +663,22 @@ class Object
 
         code << "  def index\n"
         code << "    @#{table_name} = #{model.name}#{model.primary_key ? ".order(#{model.primary_key.inspect})" : '.all'}\n"
-        code << "    @#{table_name}.brick_where(params)\n"
+        code << "    @#{table_name}.brick_select(params)\n"
         code << "  end\n"
         self.define_method :index do
           ::Brick.set_db_schema(params)
-          ar_relation = model.primary_key ? model.order(model.primary_key) : model.all
-          instance_variable_set(:@_brick_params, ar_relation.brick_where(params))
-          instance_variable_set("@#{table_name}".to_sym, ar_relation)
+          ar_relation = model.all # model.primary_key ? model.order(model.primary_key) : model.all
+          @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
+          # %%% Add custom HM count columns
+          # %%% What happens when the PK is composite?
+          counts = hm_counts.each_with_object([]) { |v, s| s << "COUNT(DISTINCT #{v.last.first}.#{v.last.last.primary_key}) AS _br_#{v.first}_ct" }
+          puts counts.inspect
+          # *selects, 
+          instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
+          # binding.pry
+          @_brick_bt_descrip = bt_descrip
+          @_brick_hm_counts = hm_counts
+          @_brick_join_array = join_array
         end
 
         if model.primary_key

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

@@ -7,10 +7,12 @@ module Brick
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
       config.brick = ActiveSupport::OrderedOptions.new
       ActiveSupport.on_load(:before_initialize) do |app|
+        is_development = (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
         ::Brick.enable_models = app.config.brick.fetch(:enable_models, true)
-        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, false)
-        ::Brick.enable_views = app.config.brick.fetch(:enable_views, false)
-        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, false)
+        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, is_development)
+        require 'brick/join_array' if ::Brick.enable_controllers?
+        ::Brick.enable_views = app.config.brick.fetch(:enable_views, is_development)
+        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, is_development)
         ::Brick.skip_database_views = app.config.brick.fetch(:skip_database_views, false)
 
         # Specific database tables and views to omit when auto-creating models
@@ -43,7 +45,7 @@ module Brick
         # ====================================
         # Dynamically create generic templates
         # ====================================
-        if ::Brick.enable_views? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
+        if ::Brick.enable_views?
           ActionView::LookupContext.class_exec do
             alias :_brick_template_exists? :template_exists?
             def template_exists?(*args, **options)
@@ -52,10 +54,11 @@ module Brick
                 # args will be something like:  ["index", ["categories"]]
                 model = args[1].map(&:camelize).join('::').singularize.constantize
                 if is_template_exists = model && (
-                    ['index', 'show'].include?(args.first) || # Everything has index and show
-                    # Only CRU stuff has create / update / destroy
-                    (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
-                  ) && instance_variable_set(:@_brick_model, model)
+                     ['index', 'show'].include?(args.first) || # Everything has index and show
+                     # Only CUD stuff has create / update / destroy
+                      (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
+                   )
+                  @_brick_model = model
                 end
               end
               is_template_exists
@@ -63,59 +66,43 @@ module Brick
 
             alias :_brick_find_template :find_template
             def find_template(*args, **options)
-              if @_brick_model
-                model_name = @_brick_model.name
-                pk = @_brick_model.primary_key
-                obj_name = model_name.underscore
-                table_name = model_name.pluralize.underscore
-                # This gets has_many as well as has_many :through
-                # %%% weed out ones that don't have an available model to reference
-                bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
-                # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
-                # as well as any possible polymorphic associations
-                exclude_hms = {}
-                associatives = hms.each_with_object({}) do |hmt, s|
-                  if (through = hmt.last.options[:through])
-                    exclude_hms[through] = nil
-                    s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
-                  elsif hmt.last.inverse_of.nil?
-                    puts "SKIPPING #{hmt.last.name.inspect}"
-                    # %%% If we don't do this then below associative.name will find that associative is nil
-                    exclude_hms[hmt.last.name] = nil
-                  end
-                end
-
-                hms_columns = +'' # Used for 'index'
-                hms_headers = hms.each_with_object([]) do |hm, s|
-                  next if exclude_hms.key?((hm_assoc = hm.last).name)
+              return  _brick_find_template(*args, **options) unless @_brick_model
 
-                  if args.first == 'index'
-                    hm_fk_name = if hm_assoc.options[:through]
-                                   associative = associatives[hm_assoc.name]
-                                   "'#{associative.name}.#{associative.foreign_key}'"
-                                 else
-                                   hm_assoc.foreign_key
-                                 end
-                    hms_columns << if hm_assoc.macro == :has_many
+              model_name = @_brick_model.name
+              pk = @_brick_model.primary_key
+              obj_name = model_name.underscore
+              table_name = model_name.pluralize.underscore
+              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'
+              hms_headers = hms.each_with_object([]) do |hm, s|
+                hm_assoc = hm.last
+                if args.first == 'index'
+                  hm_fk_name = if hm_assoc.options[:through]
+                                 associative = associatives[hm_assoc.name]
+                                 "'#{associative.name}.#{associative.foreign_key}'"
+                               else
+                                 hm_assoc.foreign_key
+                               end
+                  hms_columns << if hm_assoc.macro == :has_many
 "<td>
-  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
+  <%= ct = #{obj_name}._br_#{hm.first}_ct
+      link_to \"#\{ct\} #{hm.first}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless ct.zero? %>
 </td>\n"
-                                   else # has_one
+                                 else # has_one
 "<td>
   <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
 </td>\n"
-                                   end
-                  end
-                  s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
+                                 end
                 end
+                s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
               end
-              if @_brick_model
-                schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
-                # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
-                # environment or whatever, then get either the controllers or routes list instead
-                table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
-                                .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
-                css = "<style>
+
+              schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
+              # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
+              # environment or whatever, then get either the controllers or routes list instead
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
+                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
+              css = +"<style>
 table {
   border-collapse: collapse;
   margin: 25px 0;
@@ -189,7 +176,12 @@ def hide_bcrypt(val)
   is_bcrypt?(val) ? '(hidden)' : val
 end %>"
 
-                script = "<script>
+              if ['index', 'show', 'update'].include?(args.first)
+                # Example:  <% bts = { "site_id" => [:site, Site, "id"], "study_id" => [:study, Study, "id"], "study_country_id" => [:study_country, StudyCountry, "id"], "user_id" => [:user, User, "id"], "role_id" => [:role, Role, "id"] } %>
+                css << "<% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} } %>"
+              end
+
+              script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
 var brickSchema;
 if (schemaSelect) {
@@ -243,9 +235,8 @@ function changeout(href, param, value) {
   return hrefParts[0] + \"?\" + Object.keys(params).reduce(function (s, v) { s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
 }
 </script>"
-
-                inline = case args.first
-                when 'index'
+              inline = case args.first
+                       when 'index'
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
@@ -253,9 +244,8 @@ function changeout(href, param, value) {
 <h1>#{model_name.pluralize}</h1>
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
 <table id=\"#{table_name}\">
-  <thead><tr>#{"<th></th>" if pk}
-  <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
-     @#{table_name}.columns.map(&:name).each do |col| %>
+  <thead><tr>#{'<th></th>' if pk}
+  <% @#{table_name}.columns.map(&:name).each do |col| %>
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
@@ -273,14 +263,14 @@ function changeout(href, param, value) {
   <tr>#{"
     <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk}
     <% #{obj_name}.attributes.each do |k, val| %>
-      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && k.end_with?('_ct')) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%# Instead of just 'bt_obj we have to put in all of this junk:
-        # send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))
-        # Otherwise we get stuff like:
-        # ActionView::Template::Error (undefined method `vehicle_path' for #<ActionView::Base:0x0000000033a888>) %>
-        <%= bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
+        <%# binding.pry if bt.first == :user %>
+        <% bt_txt = bt[1].brick_descrip(#{obj_name}, @_brick_bt_descrip[bt.first][1].map { |z| #{obj_name}.send(z.last) }, @_brick_bt_descrip[bt.first][2]) %>
+        <% bt_id_col = @_brick_bt_descrip[bt.first][2]; bt_id = #{obj_name}.send(bt_id_col) if bt_id_col %>
+        <%= bt_id ? link_to(bt_txt, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
+        <%#= Previously was:  bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
       <% else %>
         <%= hide_bcrypt(val) %>
       <% end %>
@@ -295,7 +285,7 @@ function changeout(href, param, value) {
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
-                when 'show', 'update'
+                       when 'show', 'update'
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
@@ -308,8 +298,7 @@ function changeout(href, param, value) {
    # url = send(:#{model_name.underscore}_path, obj.#{pk})
    form_for(obj) do |f| %>
   <table>
-  <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
-      @#{obj_name}.first.attributes.each do |k, val| %>
+  <% @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
     <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
@@ -331,7 +320,7 @@ function changeout(href, param, value) {
       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 %>
-      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_class = bt_name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_path_base = bt_name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
@@ -342,10 +331,10 @@ function changeout(href, param, value) {
       <% when :boolean %>
         <%= f.check_box k.to_sym %>
       <% when :integer, :decimal, :float, :date, :datetime, :time, :timestamp
-          # 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 %>
+         # 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 %>
       <% when :binary, :primary_key %>
       <% end %>
@@ -359,6 +348,7 @@ function changeout(href, param, value) {
 
   #{hms_headers.map do |hm|
     next unless (pk = hm.first.klass.primary_key)
+
   "<table id=\"#{hm_name = hm.first.name.to_s}\">
     <tr><th>#{hm.last}</th></tr>
     <% collection = @#{obj_name}.first.#{hm_name}
@@ -374,19 +364,16 @@ function changeout(href, param, value) {
 <% end %>
 #{script}"
 
-                end
-                # 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')
-                ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
-              else
-                _brick_find_template(*args, **options)
-              end
+                       end
+              # 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')
+              ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
             end
           end
         end
 
-        if ::Brick.enable_routes? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
+        if ::Brick.enable_routes?
           ActionDispatch::Routing::RouteSet.class_exec do
             # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
             prepend ::Brick::RouteSet

data/lib/brick/join_array.rb

@@ -0,0 +1,227 @@
+module Brick
+  # JoinArray and JoinHash
+  #
+  # These JOIN-related collection classes -- JoinArray and its related "partner in crime" JoinHash -- both interact to
+  # more easily build out nested sets of hashes and arrays to be used with ActiveRecord's .joins() method.  For example,
+  # if there is an Order, Customer, and Employee model, and Order belongs_to :customer and :employee, then from the
+  # perspective of Order all these three could be JOINed together by referencing the two belongs_to association names:
+  #
+  #  Order.joins([:customer, :employee])
+  #
+  # and from the perspective of Employee it would instead use a hash like this, using the has_many :orders association
+  # and the :customer belongs_to:
+  #
+  #  Employee.joins({ orders: :customer })
+  #
+  # (in both cases the same three tables are being JOINed, the two approaches differ just based on their starting standpoint.)
+  # These utility classes are designed to make building out any goofy linkages like this pretty simple in a few ways:
+  # ** if the same association is requested more than once then no duplicates.
+  # ** If a bunch of intermediary associations are referenced leading up to a final one then all of them get automatically built
+  #    out and added along the way, without any having to previously exist.
+  # ** If one reference was made previously and now another neighbouring one is called for, then what used to be a simple symbol
+  #    is automatically graduated into an array so that both members can be held.  For instance, if with the Order example above
+  #    there was also a LineItem model that belongs_to Order, then let's say you start from LineItem and want to now get all 4
+  #    related models.  You could start by going through :order to :employee like this:
+  #
+  # line_item_joins = JoinArray.new
+  # line_item_joins[:order] = :employee
+  # => { order: :employee }
+  #
+  #    and then add in the reference to :customer like this:
+  #
+  # line_item_joins[:order] = :customer
+  # => { order: [:employee, :customer] }
+  #
+  #    and then carry on incrementally building out more JOINs in whatever sequence makes the best sense.  This bundle of nested
+  #    stuff can then be used to query ActiveRecord like this:
+  #
+  # LineItem.joins(line_item_joins)
+
+  class JoinArray < Array
+    attr_reader :parent, :orig_parent, :parent_key
+    alias _brick_set []=
+
+    def [](*args)
+      if !(key = args[0]).is_a?(Symbol)
+        super
+      else
+        idx = -1
+        # Whenever a JoinHash has a value of a JoinArray with a single member then it is a wrapper, usually for a Symbol
+        matching = find { |x| idx += 1; (x.is_a?(::Brick::JoinArray) && x.first == key) || (x.is_a?(::Brick::JoinHash) && x.key?(key)) || x == key }
+        case matching
+        when ::Brick::JoinHash
+          matching[key]
+        when ::Brick::JoinArray
+          matching.first
+        else
+          ::Brick::JoinHash.new.tap do |child|
+            child.instance_variable_set(:@parent, self)
+            child.instance_variable_set(:@parent_key, key) # %%% Use idx instead of key?
+          end
+        end
+      end
+    end
+
+    def []=(*args)
+      ::Brick::JoinArray.attach_back_to_root(self, args[0], args[1])
+
+      if (key = args[0]).is_a?(Symbol) && ((value = args[1]).is_a?(::Brick::JoinHash) || value.is_a?(Symbol) || value.nil?)
+        # %%% This is for the first symbol added to a JoinArray, cleaning out the leftover {} that is temporarily built out
+        # when doing my_join_array[:value1][:value2] = nil.
+        idx = -1
+        delete_at(idx) if value.nil? && any? { |x| idx += 1; x.is_a?(::Brick::JoinHash) && x.empty? }
+
+        set_matching(key, value)
+      else
+        super
+      end
+    end
+
+    def self.attach_back_to_root(collection, key = nil, value = nil)
+      # Create a list of layers which start at the root
+      layers = []
+      layer = collection
+      while layer.parent
+        layers << layer
+        layer = layer.parent
+      end
+      # Go through the layers from root down to child, attaching everything
+      layers.each do |layer|
+        if (prnt = layer.remove_instance_variable(:@parent))
+          layer.instance_variable_set(:@orig_parent, prnt)
+        end
+        case prnt
+        when ::Brick::JoinHash
+          value = if prnt.key?(layer.parent_key)
+                    if layer.is_a?(Hash)
+                      layer
+                    else
+                      ::Brick::JoinArray.new.replace([prnt.fetch(layer.parent_key, nil), layer])
+                    end
+                  else
+                    layer
+                  end
+          # This is as if we did:  prnt[layer.parent_key] = value
+          # but calling it that way would attempt to infinitely recurse back onto this overridden version of the []= method,
+          # so we go directly to ._brick_store() instead.
+          prnt._brick_store(layer.parent_key, value)
+        when ::Brick::JoinArray
+          if (key)
+            puts "X1"
+            prnt[layer.parent_key][key] = value
+          else
+            prnt[layer.parent_key] = layer
+          end
+        end
+      end
+    end
+
+    def set_matching(key, value)
+      idx = -1
+      matching = find { |x| idx += 1; (x.is_a?(::Brick::JoinArray) && x.first == key) || (x.is_a?(::Brick::JoinHash) && x.key?(key)) || x == key }
+      case matching
+      when ::Brick::JoinHash
+        matching[key] = value
+      when Symbol
+        if value.nil? # If it already exists then no worries
+          matching
+        else
+          # Not yet there, so we will "graduate" this single value into being a key / value pair found in a JoinHash.  The
+          # destination hash to be used will be either an existing one if there is a neighbouring JoinHash available, or a
+          # newly-built one placed in the "new_hash" variable if none yet exists.
+          hash = find { |x| x.is_a?(::Brick::JoinHash) } || (new_hash = ::Brick::JoinHash.new)
+          hash._brick_store(key, ::Brick::JoinArray.new.tap { |val_array| val_array.replace([value]) })
+          # hash.instance_variable_set(:@parent, matching.parent) if matching.parent
+          # hash.instance_variable_set(:@parent_key, matching.parent_key) if matching.parent_key
+
+          # When a new JoinHash was created, we place it at the same index where the original lone symbol value was pulled from.
+          # If instead we used an existing JoinHash then since that symbol has now been graduated into a new key / value pair in
+          # the existing JoinHash then we delete the original symbol by its index.
+          new_hash ? _brick_set(idx, new_hash) : delete_at(idx)
+        end
+      when ::Brick::JoinArray # Replace this single thing (usually a Symbol found as a value in a JoinHash)
+        (hash = ::Brick::JoinHash.new)._brick_store(key, value)
+        if matching.parent
+          hash.instance_variable_set(:@parent, matching.parent)
+          hash.instance_variable_set(:@parent_key, matching.parent_key)
+        end
+        _brick_set(idx, hash)
+      else # Doesn't already exist anywhere, so add it to the end of this JoinArray and return the new member
+        if value
+          ::Brick::JoinHash.new.tap do |hash|
+            val_collection = if value.is_a?(::Brick::JoinHash)
+                               value
+                             else
+                               ::Brick::JoinArray.new.tap { |array| array.replace([value]) }
+                             end
+            val_collection.instance_variable_set(:@parent, hash)
+            val_collection.instance_variable_set(:@parent_key, key)
+            hash._brick_store(key, val_collection)
+            hash.instance_variable_set(:@parent, self)
+            hash.instance_variable_set(:@parent_key, length)
+          end
+        else
+          key
+        end.tap { |member| push(member) }
+      end
+    end
+  end
+
+  class JoinHash < Hash
+    attr_reader :parent, :orig_parent, :parent_key
+    alias _brick_store []=
+
+    def [](*args)
+      if (current = super)
+        current
+      elsif (key = args[0]).is_a?(Symbol)
+        ::Brick::JoinHash.new.tap do |child|
+          child.instance_variable_set(:@parent, self)
+          child.instance_variable_set(:@parent_key, key)
+        end
+      end
+    end
+
+    def []=(*args)
+      ::Brick::JoinArray.attach_back_to_root(self)
+
+      if !(key = args[0]).is_a?(Symbol) || (!(value = args[1]).is_a?(Symbol) && !value.nil?)
+        super # Revert to normal hash behaviour when we're not passed symbols
+      else
+        case (current = fetch(key, nil))
+        when value
+          if value.nil? # Setting a single value where nothing yet exists
+            case orig_parent
+            when ::Brick::JoinHash
+              if self.empty? # Convert this empty hash into a JoinArray
+                orig_parent._brick_store(parent_key, ::Brick::JoinArray.new.replace([key]))
+              else # Call back into []= to use our own logic, this time setting this value from the context of the parent
+                orig_parent[parent_key] = key
+              end
+            when ::Brick::JoinArray
+              orig_parent[parent_key][key] = nil
+            else # No knowledge of any parent, so all we can do is add this single value right here as { key => nil }
+              super
+            end
+            key
+          else # Setting a key / value pair where nothing yet exists
+            puts "X2"
+            super(key, ::Brick::JoinArray.new.replace([value]))
+            value
+          end
+        when Symbol # Upgrade an existing symbol to be a part of our special JoinArray
+          puts "X3"
+          super(key, ::Brick::JoinArray.new.replace([current, value]))
+        when ::Brick::JoinArray # Concatenate new stuff onto any existing JoinArray
+          current.set_matching(value, nil)
+        when ::Brick::JoinHash # Graduate an existing hash into being in an array if things are dissimilar
+          super(key, ::Brick::JoinArray.new.replace([current, value]))
+          value
+        else # Perhaps this is part of some hybrid thing
+          super(key, ::Brick::JoinArray.new.replace([value]))
+          value
+        end
+      end
+    end
+  end
+end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -102,14 +102,37 @@ module Brick
     end
 
     def get_bts_and_hms(model)
-      model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+      bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+        # So that we can map an association name to any special alias name used in an AREL query
+        ans = (model._assoc_names[a.name] ||= [])
+        next if !const_defined?(a.name.to_s.singularize.camelize) && ::Brick.config.exclude_tables.include?(a.plural_name)
+
+        ans << a.klass unless ans.include?(a.klass)
         case a.macro
         when :belongs_to
           s.first[a.foreign_key] = [a.name, a.klass]
-        when :has_many, :has_one
+        when :has_many, :has_one # This gets has_many as well as has_many :through
+          # %%% weed out ones that don't have an available model to reference
           s.last[a.name] = a
         end
       end
+      # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
+      # as well as any possible polymorphic associations
+      skip_hms = {}
+      associatives = hms.each_with_object({}) do |hmt, s|
+        if (through = hmt.last.options[:through])
+          skip_hms[through] = nil
+          s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
+        elsif hmt.last.inverse_of.nil?
+          puts "SKIPPING #{hmt.last.name.inspect}"
+          # %%% If we don't do this then below associative.name will find that associative is nil
+          skip_hms[hmt.last.name] = nil
+        end
+      end
+      skip_hms.each do |k, _v|
+        puts hms.delete(k).inspect
+      end
+      [bts, hms, associatives]
     end
 
     # Switches Brick auto-models on or off, for all threads

data/lib/generators/brick/install_generator.rb

@@ -58,24 +58,24 @@ module Brick
         end
 
         bar = case possible_additional_references.length
-      when 0
+              when 0
 +"# Brick.additional_references = [['orders', 'customer_id', 'customer'],
 #                                ['customer', 'region_id', 'regions']]"
-      when 1
-        +"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+              when 1
++"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
 # Brick.additional_references = [[#{possible_additional_references.first}]"
-      else
-        +"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+              else
++"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
 # Brick.additional_references = [
 #   #{possible_additional_references.join(",\n#   ")}
 # ]"
-      end
+              end
       if resembles_fks.length > 0
         bar << "\n# # Columns named somewhat like a foreign key which you may want to consider:
 # #   #{resembles_fks.join(', ')}"
       end
 
-        create_file filename, "# frozen_string_literal: true
+      create_file(filename, "# frozen_string_literal: true
 
 # # Settings for the Brick gem
 # # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
@@ -159,7 +159,7 @@ module Brick
 # Brick.default_route_fallback = 'customers' # This defaults to \"customers/index\"
 # Brick.default_route_fallback = 'orders/outstanding' # Example of a non-RESTful route
 # Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
-"
+")
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.19
+  version: 1.0.20
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-09 00:00:00.000000000 Z
+date: 2022-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -221,6 +221,7 @@ files:
 - lib/brick/frameworks/rails/controller.rb
 - lib/brick/frameworks/rails/engine.rb
 - lib/brick/frameworks/rspec.rb
+- lib/brick/join_array.rb
 - lib/brick/serializers/json.rb
 - lib/brick/serializers/yaml.rb
 - lib/brick/util.rb