brick 1.0.107 → 1.0.109

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74bd7cd6539a5f048aecc3e02be8912e1bc77851ac8b9f65402892e964a024de
-  data.tar.gz: c32c53d0012f2a9292463d803d0c679d4f32800c8931c3361469aa22c09a3fc5
+  metadata.gz: 1621b6af75759b90c788ce080db85608731c2bfc026c82d7bcea011a89c2162e
+  data.tar.gz: a4242388d2fa29a12229c620d91b5d572e9e2f7688783beb6963817cf3fac340
 SHA512:
-  metadata.gz: f84ee2aae03622a4ca67a6921daf7e975f85601e66fc608c2357613da976414d2ceeec87276887232a832413116ec1495638c883ecc712db3706f51c34efbd44
-  data.tar.gz: e97fbe41eca4d839795f7567bfd3e8a3d6494d4887032fa5f0f87d88ba3c9fdc810bde8a259c3cbf0b8f944c8b345c33290aa5d1e8f7aa67737e7fe7be248a6d
+  metadata.gz: fa089c1bc9663e764b783c639ca9ca24c18a5cbbc788281e11620b33277e87282b6e1a0195d12686b72f53a5ae4a5bcb9e8343e9ef9bb4d97f53fb69ad4619fe
+  data.tar.gz: 784eed99a879191dff95b5dfd061f8025d52d3e30eb16b7a754b425c2f4ad58e03e8631949d807f130dc86e55cb3a5e08d215a3f1729b4465c58dc3cecffb96d

data/lib/brick/compatibility.rb

@@ -42,9 +42,36 @@ end
 # file by having the line "require 'brick/compatibility'" to be the last line in that
 # file.
 require 'bigdecimal'
-if ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('2.6') &&
-   ActiveRecord.version < ::Gem::Version.new('5.0')
-  def BigDecimal.new(*args, **kwargs)
-    BigDecimal(*args, **kwargs)
+if ActiveRecord.version < ::Gem::Version.new('5.0')
+  if ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('2.6')
+    def BigDecimal.new(*args, **kwargs)
+      BigDecimal(*args, **kwargs)
+    end
+
+    if ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('3.1')
+      # @@schemes fix for global_id gem < 1.0
+      URI.class_variable_set(:@@schemes, {}) unless URI.class_variables.include?(:@@schemes)
+      if Gem::Specification.all_names.find { |g| g.start_with?('puma-') }
+        require 'rack/handler/puma'
+        module Rack::Handler::Puma
+          class << self
+            alias _brick_run run
+            def run(app, *args, **options)
+              options.merge!(args.pop) if args.last.is_a?(Hash)
+              _brick_run(app, **options)
+            end
+          end
+        end
+      end
+
+      require 'json'
+      if JSON::Parser.method(:initialize).parameters.length < 2 && JSON.method(:parse).arity == -2
+        JSON.class_exec do
+          def self.parse(source, opts = {})
+            ::JSON::Parser.new(source, **opts).parse
+          end
+        end
+      end
+    end
   end
 end

data/lib/brick/config.rb

@@ -110,6 +110,50 @@ module Brick
       @mutex.synchronize { @api_filter = proc }
     end
 
+    # # Proc gets called with up to 4 arguments:  object_name, api_version, columns, data
+    # # Expected to return an array, either just of symbols defining column names, or an array with two sub-arrays, first of column detail and second of data
+    # def api_column_filter
+    #   @mutex.synchronize { @api_column_filter }
+    # end
+
+    # def api_column_filter=(proc)
+    #   @mutex.synchronize { @api_column_filter = proc }
+    # end
+
+    # Allows you to rename and exclude columns either specific to a given API version, or generally for a database object name
+    def api_column_renaming
+      @mutex.synchronize { @api_column_renaming }
+    end
+
+    def api_column_renaming=(renames)
+      @mutex.synchronize { @api_column_renaming = renames }
+    end
+
+    # All the view prefix things
+    def api_view_prefix
+      @mutex.synchronize { @api_view_prefix }
+    end
+
+    def api_view_prefix=(view_prefix)
+      @mutex.synchronize { @api_view_prefix = view_prefix }
+    end
+
+    def api_remove_view_prefix
+      @mutex.synchronize { @api_remove_view_prefix || @api_view_prefix }
+    end
+
+    def api_remove_view_prefix=(view_prefix)
+      @mutex.synchronize { @api_remove_view_prefix = view_prefix }
+    end
+
+    def api_add_view_prefix
+      @mutex.synchronize { @api_add_view_prefix || @api_view_prefix }
+    end
+
+    def api_add_view_prefix=(view_prefix)
+      @mutex.synchronize { @api_add_view_prefix = view_prefix }
+    end
+
     # Additional table associations to use (Think of these as virtual foreign keys perhaps)
     def additional_references
       @mutex.synchronize { @additional_references }

data/lib/brick/extensions.rb

@@ -44,16 +44,20 @@
 
 module ActiveRecord
   class Base
-    def self.is_brick?
-      instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
-    end
+    class << self
+      attr_reader :_brick_relation
 
-    def self._assoc_names
-      @_assoc_names ||= {}
-    end
+      def is_brick?
+        instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
+      end
+
+      def _assoc_names
+        @_assoc_names ||= {}
+      end
 
-    def self.is_view?
-      false
+      def is_view?
+        false
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -417,7 +421,10 @@ module ActiveRecord
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
-        next if ['_brick_schema', '_brick_order', 'controller', 'action'].include?(k)
+        next if ['_brick_schema', '_brick_order',
+                 '_brick_erd', '_brick_exclude', '_brick_unexclude',
+                 '_brick_page', '_brick_page_size', '_brick_offset', '_brick_limit',
+                 '_brick_is_api', 'controller', 'action'].include?(k)
 
         if (where_col = (ks = k.split('.')).last)[-1] == '!'
           where_col = where_col[0..-2]
@@ -444,7 +451,10 @@ module ActiveRecord
         # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
         #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
         #     Relevant info here:  https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/402
+        is_api = params['_brick_is_api']
         columns.each do |col|
+          next if (col.type.nil? || col.type == :binary) && is_api
+
           col_alias = " AS #{col.name}_" if (col_name = col.name) == 'class'
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
@@ -787,21 +797,21 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
         end
         self.order_values |= final_order_by # Same as:  order!(*final_order_by)
       end
-      if (page = params['_brick_page']&.to_i)
-        page = 1 if page < 1
-        limit = params['_brick_page_size'] || 1000
-        offset = (page - 1) * limit.to_i
-      else
-        offset = params['_brick_offset']
-        limit = params['_brick_limit']
-      end
+      # By default just 1000 rows
+      row_limit = params['_brick_limit'] || params['_brick_page_size'] || 1000
+      offset = if (page = params['_brick_page']&.to_i)
+                 page = 1 if page < 1
+                 (page - 1) * row_limit.to_i
+               else
+                 params['_brick_offset']
+               end
       if offset.is_a?(Numeric) || offset&.present?
         offset = offset.to_i
         self.offset_value = offset unless offset == 0
-        @_brick_page_num = (offset / limit.to_i) + 1 if limit&.!= 0 && (offset % limit.to_i) == 0
+        @_brick_page_num = (offset / row_limit.to_i) + 1 if row_limit&.!= 0 && (offset % row_limit.to_i) == 0
       end
-      # By default just 1000 rows  (Like doing:  limit!(1000)  but this way is compatible with AR <= 4.2)
-      self.limit_value = limit&.to_i || 1000 unless limit.is_a?(String) && limit.empty?
+      # Setting limit_value= is the same as doing:  limit!(1000)  but this way is compatible with AR <= 4.2
+      self.limit_value = row_limit.to_i unless row_limit.is_a?(String) && row_limit.empty?
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
@@ -1261,6 +1271,7 @@ class Object
       # Having this separate -- will this now work out better?
         built_model.class_exec do
           @_brick_built = true
+          @_brick_relation = relation
           hmts&.each do |hmt_fk, hms|
             hmt_fk = hmt_fk.tr('.', '_')
             hms.each do |hm|
@@ -1533,9 +1544,13 @@ class Object
             end
             if (current_api_root || is_openapi) &&
                !params&.key?('_brick_schema') &&
-               (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
+               (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.each_with_object({}) do |x, s|
+                 if (kv = x.split('=')).length > 1
+                   s[kv.first] = kv[1..-1].join('=')
+                 end
+               end).present?
               if params
-                referrer_params.each { |k, v| params.send(:parameters)[k] = v }
+                referrer_params.each { |k, v| (params.respond_to?(:parameters) ? send(:parameters) : params)[k] = v }
               else
                 api_params = referrer_params&.to_h
               end
@@ -1570,13 +1585,22 @@ class Object
                   (api_ver_paths || { relation.first => all_actions }).each do |api_ver_path, actions|
                     relation_name = (api_ver_path || relation.first).tr('.', '/')
                     table_description = relation.last[:description]
+
+                    # Column renaming / exclusions
+                    renamed_columns = if (column_renaming = ::Brick.find_col_renaming(api_ver_path, relation.first))
+                                        column_renaming.each_with_object({}) do |rename, s|
+                                          s[rename.last] = relation.last[:cols][rename.first] if rename.last
+                                        end
+                                      else
+                                        relation.last[:cols]
+                                      end
                     { :index => [:get, 'list'], :create => [:post, 'create a'] }.each do |k, v|
                       unless actions&.exclude?(k)
                         this_resource = (s["#{current_api_root}#{relation_name}"] ||= {})
                         this_resource[v.first] = {
                           'summary': "#{v[1]} #{relation.first}",
                           'description': table_description,
-                          'parameters': relation.last[:cols].map do |k2, v2|
+                          'parameters': renamed_columns.map do |k2, v2|
                                           param = { in: 'query', 'name': k2, 'schema': { 'type': v2.first } }
                                           if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k2, nil))
                                             param['description'] = col_descrip
@@ -1596,7 +1620,7 @@ class Object
                           this_resource[v.first] = {
                             'summary': "#{v[1]} a #{relation.first.singularize}",
                             'description': table_description,
-                            'parameters': relation.last[:cols].reject { |k1, _v1| Brick.config.metadata_columns.include?(k1) }.map do |k2, v2|
+                            'parameters': renamed_columns.reject { |k1, _v1| Brick.config.metadata_columns.include?(k1) }.map do |k2, v2|
                               param = { 'name': k2, 'schema': { 'type': v2.first } }
                               if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k2, nil))
                                 param['description'] = col_descrip
@@ -1637,13 +1661,46 @@ class Object
             order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
 
             ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
+            params['_brick_is_api'] = true if (is_api = request.format == :js || current_api_root)
             @_brick_params = ar_relation.brick_select(params, (selects ||= []), order_by,
                                                       translations = {},
                                                       join_array = ::Brick::JoinArray.new)
 
-            if request.format == :js || current_api_root # Asking for JSON?
+            if is_api # Asking for JSON?
+              # Apply column renaming
               data = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects) : ar_relation.select(selects)
-              render inline: { data: data }.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
+              if data.present? &&
+                 (column_renaming = ::Brick.find_col_renaming(current_api_root, model&._brick_relation)&.select { |cr| cr.last })
+                data.map!({}) do |row, s|
+                  column_renaming.each_with_object({}) do |rename, s|
+                    s[rename.last] = row[rename.first] if rename.last
+                  end
+                end
+              end
+
+              # # %%% This currently only gives a window to check security and raise an exception if someone isn't
+              # # authenticated / authorised. Still need to figure out column filtering and transformations.
+              # proc_result = if (column_filter = ::Brick.config.api_column_filter).is_a?(Proc)
+              #                 object_columns = (relation = model&._brick_relation)[:cols]
+              #                 begin
+              #                   num_args = column_filter.arity.negative? ? 5 : column_filter.arity
+              #                   # object_name, api_version, columns, data
+              #                   api_ver_path = request.path[0..-relation[:resource].length]
+              #                   # Call the api_column_filter in the context of this auto-built controller
+              #                   instance_exec(*[relation[:resource], relation, api_ver_path, object_columns, data][0...num_args], &column_filter)
+              #                 rescue StandardError => e
+              #                   puts "::Brick.api_column_filter Proc error: #{e.message}"
+              #                 end
+              #               end
+              # columns = if (proc_result) # Proc returns up to 2 things:  columns, data
+              #             # If it's all valid column name strings then we're just rearranging the column sequence
+              #             col_names = proc_result.all? { |pr| object_columns.key?(pr) } ? proc_result : proc_result.first.keys
+              #             col_names.each_with_object({}) { |cn, s| s[cn] = relation.last[:cols][cn] }
+              #           else
+              #             relation.last[:cols]
+              #           end
+
+              render inline: { data: data }.to_json, content_type: ['*/*', 'text/html'].include?(request.format) ? 'application/json' : request.format
               return
             end
 
@@ -1940,7 +1997,6 @@ end.class_exec do
 
     # return if ActiveRecord::Base.connection.current_database == 'postgres'
 
-    initializer_loaded = false
     orig_schema = nil
     if (relations = ::Brick.relations).empty?
       # Very first thing, load inflections since we'll be using .pluralize and .singularize on table and model names
@@ -1949,7 +2005,7 @@ end.class_exec do
       end
       # Now the Brick initializer since there may be important schema things configured
       if File.exist?(brick_initializer = ::Rails.root.join('config/initializers/brick.rb'))
-        initializer_loaded = load brick_initializer
+        ::Brick.initializer_loaded = load brick_initializer
       end
       # Load the initializer for the Apartment gem a little early so that if .excluded_models and
       # .default_schema are specified then we can work with non-tenanted models more appropriately
@@ -2222,7 +2278,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       end
       v[:class_name] = (schema_names + [singular]).map(&:camelize).join('::')
     end
-    ::Brick.load_additional_references if initializer_loaded
+    ::Brick.load_additional_references if ::Brick.initializer_loaded
 
     if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first)
       puts "Now switching back to \"#{orig_schema}\" schema."
@@ -2603,6 +2659,13 @@ module Brick
       end
     end
 
+    def find_col_renaming(api_ver_path, relation_name)
+      ::Brick.config.api_column_renaming&.fetch(
+        api_ver_path,
+        ::Brick.config.api_column_renaming&.fetch(relation_name, nil)
+      )
+    end
+
     def _class_pk(dotted_name, multitenant)
       Object.const_get((multitenant ? [dotted_name.split('.').last] : dotted_name.split('.')).map { |nm| "::#{nm.singularize.camelize}" }.join).primary_key
     end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -135,7 +135,7 @@ module Brick
       @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
     end
 
-    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models
+    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models, :initializer_loaded
 
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
@@ -682,45 +682,86 @@ In config/initializers/brick.rb appropriate entries would look something like:
             if (schema_name = v.fetch(:schema, nil))
               schema_prefix = "#{schema_name}."
             end
+
+            # Track routes being built
+            if (class_name = v.fetch(:class_name, nil))
+              if v.key?(:isView)
+                view_class_length = class_name.length if class_name.length > view_class_length
+                views
+              else
+                table_class_length = class_name.length if class_name.length > table_class_length
+                tables
+              end << [class_name, "#{schema_prefix&.tr('.', '/')}#{v[:resource]}"]
+            end
+
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
-            # First do the API routes if necessary
+
+            # First do the normal routes
+            if path_prefix
+              # Was:  send(:scope, path: path_prefix) do
+              send(:namespace, path_prefix) do
+                brick_routes_create.call(schema_name, v[:resource], options)
+                sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
+                  brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
+                end
+              end
+            else
+              brick_routes_create.call(schema_name, v[:resource], options)
+              sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
+                brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
+              end
+            end
+
+            # Now the API routes if necessary
             full_resource = nil
             ::Brick.api_roots&.each do |api_root|
               api_done_views = (versioned_views[api_root] ||= {})
               found = nil
+              test_ver_num = nil
               view_relation = nil
               # If it's a view then see if there's a versioned one available by searching for resource names
               # versioned with the closest number (equal to or less than) compared with our API version number.
-              if v.key?(:isView) && (ver = object_name.match(/^v([\d_]*)/)&.captures&.first) && ver[-1] == '_'
-                core_object_name = object_name[ver.length + 1..-1]
-                next if api_done_views.key?(unversioned = "#{schema_prefix}v_#{core_object_name}")
-
-                # Expect that the last item in the path generally holds versioning information
-                api_ver = api_root.split('/')[-1]&.gsub('_', '.')
-                vn_idx = api_ver.rindex(/[^\d._]/) # Position of the first numeric digit at the end of the version number
-                # Was:  .to_d
-                test_ver_num = api_ver_num = api_ver[vn_idx + 1..-1].gsub('_', '.').to_i # Attempt to turn something like "v3" into the decimal value 3
-                # puts [api_ver, vn_idx, api_ver_num, unversioned].inspect
-
-                next if ver.to_i > api_ver_num # Don't surface any newer views in an older API
-
-                test_ver_num -= 1 until test_ver_num.zero? ||
-                                        (view_relation = ::Brick.relations.fetch(
-                                          found = "#{schema_prefix}v#{test_ver_num}_#{core_object_name}", nil
-                                        ))
-                api_done_views[unversioned] = nil # Mark that for this API version this view is done
-
-                # puts "Found #{found}" if view_relation
-                # If we haven't found "v3_view_name" or "v2_view_name" or so forth, at the last
-                # fall back to simply looking for "v_view_name", and then finally  "view_name".
-                no_v_prefix_name = "#{schema_prefix}#{core_object_name}"
+              if v.key?(:isView)
+                if (ver = object_name.match(/^v([\d_]*)/)&.captures&.first) && ver[-1] == '_'
+                  core_object_name = object_name[ver.length + 1..-1]
+                  next if api_done_views.key?(unversioned = "#{schema_prefix}v_#{core_object_name}")
+
+                  # Expect that the last item in the path generally holds versioning information
+                  api_ver = api_root.split('/')[-1]&.gsub('_', '.')
+                  vn_idx = api_ver.rindex(/[^\d._]/) # Position of the first numeric digit at the end of the version number
+                  # Was:  .to_d
+                  test_ver_num = api_ver_num = api_ver[vn_idx + 1..-1].gsub('_', '.').to_i # Attempt to turn something like "v3" into the decimal value 3
+                  # puts [api_ver, vn_idx, api_ver_num, unversioned].inspect
+
+                  next if ver.to_i > api_ver_num # Don't surface any newer views in an older API
+
+                  test_ver_num -= 1 until test_ver_num.zero? ||
+                                          (view_relation = ::Brick.relations.fetch(
+                                            found = "#{schema_prefix}v#{test_ver_num}_#{core_object_name}", nil
+                                          ))
+                  api_done_views[unversioned] = nil # Mark that for this API version this view is done
+
+                  # puts "Found #{found}" if view_relation
+                  # If we haven't found "v3_view_name" or "v2_view_name" or so forth, at the last
+                  # fall back to simply looking for "v_view_name", and then finally  "view_name".
+                  no_v_prefix_name = "#{schema_prefix}#{core_object_name}"
+                  standard_prefix = 'v_'
+                else
+                  core_object_name = object_name
+                end
+                if (rvp = ::Brick.config.api_remove_view_prefix) && core_object_name.start_with?(rvp)
+                  core_object_name.slice!(0, rvp.length)
+                end
+                no_prefix_name = "#{schema_prefix}#{core_object_name}"
+                unversioned = "#{schema_prefix}#{standard_prefix}#{::Brick.config.api_add_view_prefix}#{core_object_name}"
               else
                 unversioned = k
               end
 
               view_relation ||= ::Brick.relations.fetch(found = unversioned, nil) ||
-                                (no_v_prefix_name && ::Brick.relations.fetch(found = no_v_prefix_name, nil))
+                                (no_v_prefix_name && ::Brick.relations.fetch(found = no_v_prefix_name, nil)) ||
+                                (no_prefix_name && ::Brick.relations.fetch(found = no_prefix_name, nil))
               if view_relation
                 actions = view_relation.key?(:isView) ? [:index, :show] : ::Brick::ALL_API_ACTIONS # By default all actions are allowed
                 # Call proc that limits which endpoints get surfaced based on version, table or view name, method (get list / get one / post / patch / delete)
@@ -730,7 +771,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
                 proc_result = if (filter = ::Brick.config.api_filter).is_a?(Proc)
                                 begin
                                   num_args = filter.arity.negative? ? 6 : filter.arity
-                                  filter.call(*[unversioned, k, actions, api_ver_num, found, test_ver_num][0...num_args])
+                                  filter.call(*[unversioned, k, view_relation, actions, api_ver_num, found, test_ver_num][0...num_args])
                                 rescue StandardError => e
                                   puts "::Brick.api_filter Proc error: #{e.message}"
                                 end
@@ -799,33 +840,6 @@ In config/initializers/brick.rb appropriate entries would look something like:
                 end
               end
             end
-
-            # Track routes being built
-            if (class_name = v.fetch(:class_name, nil))
-              if v.key?(:isView)
-                view_class_length = class_name.length if class_name.length > view_class_length
-                views
-              else
-                table_class_length = class_name.length if class_name.length > table_class_length
-                tables
-              end << [class_name, "#{schema_prefix&.tr('.', '/')}#{v[:resource]}"]
-            end
-
-            # Now the normal routes
-            if path_prefix
-              # Was:  send(:scope, path: path_prefix) do
-              send(:namespace, path_prefix) do
-                brick_routes_create.call(schema_name, v[:resource], options)
-                sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
-                  brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
-                end
-              end
-            else
-              brick_routes_create.call(schema_name, v[:resource], options)
-              sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
-                brick_routes_create.call(schema_name, sc.underscore.tr('/', '_').pluralize, options)
-              end
-            end
           end
 
           if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
@@ -845,7 +859,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
             if Object.const_defined?('Rswag::Ui')
               rswag_path = ::Rails.application.routes.routes.find { |r| r.app.app == Rswag::Ui::Engine }&.instance_variable_get(:@path_formatter)&.instance_variable_get(:@parts)&.join
               first_endpoint_parts = nil
-              (doc_endpoints = Rswag::Ui.config.config_object[:urls]&.uniq!)&.each do |doc_endpoint|
+              (doc_endpoints = Rswag::Ui.config.config_object[:urls])&.each do |doc_endpoint|
                 puts "Mounting OpenApi 3.0 documentation endpoint for \"#{doc_endpoint[:name]}\" on #{doc_endpoint[:url]}"
                 send(:get, doc_endpoint[:url], { to: 'brick_openapi#index' })
                 endpoint_parts = doc_endpoint[:url]&.split('/')
@@ -1180,8 +1194,13 @@ ActiveSupport.on_load(:active_record) do
     arsc.class_exec do
       def self.create(connection, callable = nil, &block)
         relation = (callable || block).call ::ActiveRecord::StatementCache::Params.new
-        bind_map = ::ActiveRecord::StatementCache::BindMap.new relation.bound_attributes
-        query_builder = connection.cacheable_query(self, relation.arel)
+        bind_map = ::ActiveRecord::StatementCache::BindMap.new(
+                     # AR <= 4.2 uses relation.bind_values
+                     relation.respond_to?(:bound_attributes) ? relation.bound_attributes : relation.bind_values
+                   )
+        options = [self, relation.arel]
+        options.shift if connection.method(:cacheable_query).arity == 1 # Rails <= 5.0
+        query_builder = connection.cacheable_query(*options)
         new query_builder, bind_map
       end
     end
@@ -1225,7 +1244,8 @@ ActiveSupport.on_load(:active_record) do
     end
   end
 
-  if Psych.respond_to?(:unsafe_load) && ActiveRecord.version < ::Gem::Version.new('6.1')
+  if ActiveRecord.version < ::Gem::Version.new('6.1') &&
+     Psych.method(:load).parameters.any? { |param| param.first == :key && param.last == :aliases }
     Psych.class_exec do
       class << self
         alias _original_load load
@@ -1267,7 +1287,9 @@ ActiveSupport.on_load(:active_record) do
       def initialize(base, associations, joins, eager_loading: true)
         araat = ::ActiveRecord::Associations::AliasTracker
         if araat.respond_to?(:create_with_joins) # Rails 5.0 and 5.1
-          @alias_tracker = araat.create_with_joins(base.connection, base.table_name, joins)
+          cwj_options = [base.connection, base.table_name, joins]
+          cwj_options << base.type_caster if araat.method(:create_with_joins).arity > 3 # Rails <= 5.1
+          @alias_tracker = araat.create_with_joins(*cwj_options)
           @eager_loading = eager_loading # (Unused in Rails 5.0)
         else # Rails 4.2
           @alias_tracker = araat.create(base.connection, joins)
@@ -1636,21 +1658,24 @@ if ActiveRecord.version < ::Gem::Version.new('6.0') && ruby_version >= ::Gem::Ve
   end
 
   require 'active_model'
-  require 'active_model/type'
-  require 'active_model/type/value'
-  class ActiveModel::Type::Value
-    def initialize(*args, precision: nil, limit: nil, scale: nil)
-      @precision = precision
-      @scale = scale
-      @limit = limit
+  begin
+    require 'active_model/type'
+    require 'active_model/type/value'
+    class ActiveModel::Type::Value
+      def initialize(*args, precision: nil, limit: nil, scale: nil)
+        @precision = precision
+        @scale = scale
+        @limit = limit
+      end
     end
+  rescue LoadError => e # AR <= 4.2 doesn't have ActiveModel::Type
   end
 
   if Object.const_defined?('I18n')
     module I18n::Base
       alias _brick_translate translate
       def translate(key = nil, *args, throw: false, raise: false, locale: nil, **options)
-        options.merge!(args.pop) if args.length > 0 && args.last.is_a?(Hash)
+        options.merge!(args.pop) if args.last.is_a?(Hash)
         _brick_translate(key = nil, throw: false, raise: false, locale: nil, **options)
       end
     end
@@ -1661,8 +1686,12 @@ if ActiveRecord.version < ::Gem::Version.new('6.0') && ruby_version >= ::Gem::Ve
 
     # Creates the authenticity token for the current request.
     def form_authenticity_token(*args, form_options: {}) # :doc:
-      form_options.merge!(args.pop) if args.length > 0 && args.last.is_a?(Hash)
-      masked_authenticity_token(session, form_options: form_options)
+      if method(:masked_authenticity_token).arity == 1
+        masked_authenticity_token(session) # AR <= 4.2 doesn't use form_options
+      else
+        form_options.merge!(args.pop) if args.last.is_a?(Hash)
+        masked_authenticity_token(session, form_options: form_options)
+      end
     end
   end
 
@@ -1672,7 +1701,7 @@ if ActiveRecord.version < ::Gem::Version.new('6.0') && ruby_version >= ::Gem::Ve
         encrypted = if method(:_encrypt).arity == 1
                       _encrypt(value) # Rails <= 5.1
                     else
-                      if args.length > 0 && args.last.is_a?(Hash)
+                      if args.last.is_a?(Hash)
                         expires_at ||= args.last[:expires_at]
                         expires_in ||= args.last[:expires_in]
                         purpose ||= args.last[:purpose]
@@ -1685,7 +1714,7 @@ if ActiveRecord.version < ::Gem::Version.new('6.0') && ruby_version >= ::Gem::Ve
     if const_defined?('Messages')
       class Messages::Metadata
         def self.wrap(message, *args, expires_at: nil, expires_in: nil, purpose: nil)
-          if args.length > 0 && args.last.is_a?(Hash)
+          if args.last.is_a?(Hash)
             expires_at ||= args.last[:expires_at]
             expires_in ||= args.last[:expires_in]
             purpose ||= args.last[:purpose]

data/lib/generators/brick/install_generator.rb

@@ -139,7 +139,7 @@ module Brick
 # Settings for the Brick gem
 # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
 
-if ActiveRecord::Base.respond_to?(:brick_select)
+if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # Mode -- generally :on or :off, or only in :development.  Also available is :diag_env which enables only
   # when the environment variable BRICK is set.
   Brick.mode = :development

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.107
+  version: 1.0.109
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-19 00:00:00.000000000 Z
+date: 2023-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord