brick 1.0.142 → 1.0.144

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e907aa4b41603045845a12d80de47e9ad714768929225b8bec209ddd9b92212
-  data.tar.gz: 227137ba8ec83040eec6dbf76c3541f6438b7427c586690f7430572cdd59eb8a
+  metadata.gz: 6b84f681ffcc3cfbc37531e21ee68c07a27df07d0b0b63aed94d7e13fedc8ec1
+  data.tar.gz: b1f96b376d7c27b9a01e8025f8628efdfedff77875b089323e66bdff557a4141
 SHA512:
-  metadata.gz: b68b20ad2ef66293dd7bdfd329c1ea341fb535e6240128beb1d5cd0dec99503ecc95b44b1adfde24f1493e4d7edb20ea61c7a4c9a1e5f6502b95c3c512261208
-  data.tar.gz: 45722aa4054d96a858bab394a0e207e37d92ab415eb2a5832807e95d855e1c662139074bde9cf545d662a062fbe834ccd228d9595061c1dfde73990e6a3b3feb
+  metadata.gz: d6b2dfbd93defb98b61bd20c405657d8b3df5c9f1c4887dc37fe75a09fdcc61abc9ba15a1e9a16006487017f270d62ca1843fefeea574eb8df07fc55f136693b
+  data.tar.gz: 4f1d192f9420b9f8cfac9fa7d6f7f6c057d5bb0f852b8066937f79410b20005b4080b6bdec16f2e470e8fa1a9e5331fd26b64d675e1e397942ec65a371f8d977

data/lib/brick/compatibility.rb

@@ -10,6 +10,77 @@ unless ActiveRecord.respond_to?(:version)
   end
 end
 
+# Allow ActiveRecord < 3.2 to work with Ruby 2.7 and later
+if ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('2.7')
+  if ActiveRecord.version < ::Gem::Version.new('3.2')
+    # Remove circular reference for "now"
+    ::Brick::Util._patch_require(
+      'active_support/values/time_zone.rb', '/activesupport',
+      ['  def parse(str, now=now)',
+      '  def parse(str, now=now())']
+    )
+    # Remove circular reference for "reflection" for ActiveRecord 3.1
+    if ActiveRecord.version >= ::Gem::Version.new('3.1')
+      ::Brick::Util._patch_require(
+        'active_record/associations/has_many_association.rb', '/activerecord',
+        ['reflection = reflection)',
+        'reflection = reflection())'],
+        :HasManyAssociation # Make sure the path for this guy is available to be autoloaded
+      )
+    end
+  end
+
+  unless ActiveRecord.const_defined?(:NoDatabaseError) # Generic version of NoDatabaseError for Rails <= 4.0
+    require 'active_model'
+    require 'active_record/errors'
+    class ::ActiveRecord::NoDatabaseError < ::ActiveRecord::StatementInvalid
+    end
+  end
+
+  # Create unfrozen route path in Rails 3.x
+  if ActiveRecord.version < ::Gem::Version.new('4')
+    # ::Brick::Util._patch_require(
+    #   'action_dispatch/routing/route_set.rb', '/actiondispatch',
+    #   ["path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s",
+    #    "path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s.dup"]
+    #    #,
+    #   #:RouteSet # Make sure the path for this guy is available to be autoloaded
+    # )
+    require 'action_dispatch/routing/route_set'
+    # This is by no means elegant -- wish the above would work instead.  Here we completely replace #url_for
+    # only in order to add a ".dup"
+    ::ActionDispatch::Routing::RouteSet.class_exec do
+      def url_for(options)
+        finalize!
+        options = (options || {}).reverse_merge!(default_url_options)
+
+        handle_positional_args(options)
+
+        user, password = extract_authentication(options)
+        path_segments  = options.delete(:_path_segments)
+        script_name    = options.delete(:script_name)
+
+        # Just adding .dup on the end in order to not have a frozen string
+        path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s.dup
+
+        path_options = options.except(*::ActionDispatch::Routing::RouteSet::RESERVED_OPTIONS)
+        path_options = yield(path_options) if block_given?
+
+        path_addition, params = generate(path_options, path_segments || {})
+
+        path << path_addition
+
+        ActionDispatch::Http::URL.url_for(options.merge({
+          :path => path,
+          :params => params,
+          :user => user,
+          :password => password
+        }))
+      end
+    end
+  end
+end
+
 # ActiveSupport, ActionPack, and ActionView before 4.0 didn't have #version
 require 'active_support' # Needed for Rails 4.x
 unless ActiveSupport.respond_to?(:version)

data/lib/brick/extensions.rb

@@ -316,8 +316,10 @@ module ActiveRecord
     def self.brick_import_template
       template = constants.include?(:IMPORT_TEMPLATE) ? self::IMPORT_TEMPLATE : suggest_template(0, false, true)
       # Add the primary key to the template as being unique (unless it's already there)
-      template[:uniques] = [pk = primary_key.to_sym]
-      template[:all].unshift(pk) unless template[:all].include?(pk)
+      if primary_key
+        template[:uniques] = [pk = primary_key.to_sym]
+        template[:all].unshift(pk) unless template[:all].include?(pk)
+      end
       template
     end
 
@@ -458,17 +460,19 @@ module ActiveRecord
 
   module AttributeMethods
     module ClassMethods
-      alias _brick_dangerous_attribute_method? dangerous_attribute_method?
-      # Bypass the error "ActiveRecord::DangerousAttributeError" if this object comes from a view.
-      # (Allows for column names such as 'attribute', 'delete', and 'update' to still work.)
-      def dangerous_attribute_method?(name)
-        if (is_dangerous = _brick_dangerous_attribute_method?(name)) && is_view?
-          if column_names.include?(name.to_s)
-            puts "WARNING:  Column \"#{name}\" in view #{table_name} conflicts with a reserved ActiveRecord method name."
+      if respond_to?(:dangerous_attribute_method?)
+        alias _brick_dangerous_attribute_method? dangerous_attribute_method?
+        # Bypass the error "ActiveRecord::DangerousAttributeError" if this object comes from a view.
+        # (Allows for column names such as 'attribute', 'delete', and 'update' to still work.)
+        def dangerous_attribute_method?(name)
+          if (is_dangerous = _brick_dangerous_attribute_method?(name)) && is_view?
+            if column_names.include?(name.to_s)
+              puts "WARNING:  Column \"#{name}\" in view #{table_name} conflicts with a reserved ActiveRecord method name."
+            end
+            return false
           end
-          return false
+          is_dangerous
         end
-        is_dangerous
       end
     end
   end
@@ -510,9 +514,6 @@ module ActiveRecord
       # model early in case the user wants to do an ORDER BY based on any of that.
       model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
 
-      is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-      is_mysql = ['Mysql2', 'Trilogy'].include?(ActiveRecord::Base.connection.adapter_name)
-      is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
@@ -587,7 +588,7 @@ module ActiveRecord
 
       if join_array.present?
         if ActiveRecord.version < Gem::Version.new('4.2')
-          joins!(join_array)
+          self.joins_values += join_array # Same as:  joins!(join_array)
         else
           left_outer_joins!(join_array)
         end
@@ -834,47 +835,27 @@ module ActiveRecord
           next
         end
 
-        tbl_alias = if is_mysql
-                      "`b_r_#{hm.name}`"
-                    elsif is_postgres
-                      "\"b_r_#{hm.name}\""
-                    else
-                      "b_r_#{hm.name}"
-                    end
-        pri_tbl_name = is_mysql ? "`#{pri_tbl.table_name}`" : "\"#{pri_tbl.table_name.gsub('.', '"."')}\""
-        pri_tbl_name = if is_mysql
-                         "`#{pri_tbl.table_name}`"
-                       elsif is_postgres || is_mssql
-                         "\"#{pri_tbl.table_name.gsub('.', '"."')}\""
-                       else
-                         pri_tbl.table_name
-                       end
+        tbl_alias = "b_r_#{hm.name}"
         on_clause = []
         hm_selects = if fk_col.is_a?(Array) # Composite key?
-                       fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl_name}.#{pri_key[idx]}" }
+                       fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_key[idx]}" }
                        fk_col.dup
                      else
-                       on_clause << "#{tbl_alias}.#{fk_col} = #{pri_tbl_name}.#{pri_key}"
+                       on_clause << "#{_br_quoted_name("#{tbl_alias}.#{fk_col}")} = #{_br_quoted_name("#{pri_tbl.table_name}.#{pri_key}")}"
                        [fk_col]
                      end
         if poly_type
           hm_selects << poly_type
-          on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
+          on_clause << "#{_br_quoted_name("#{tbl_alias}.#{poly_type}")} = '#{name}'"
         end
         unless from_clause
           tbl_nm = hm.macro == :has_and_belongs_to_many ? hm.join_table : hm.table_name
-          hm_table_name = if is_mysql
-                            "`#{tbl_nm}`"
-                          elsif is_postgres || is_mssql
-                            "\"#{(tbl_nm).gsub('.', '"."')}\""
-                          else
-                            tbl_nm
-                          end
+          hm_table_name = _br_quoted_name(tbl_nm)
         end
         group_bys = ::Brick.is_oracle || is_mssql ? hm_selects : (1..hm_selects.length).to_a
         join_clause = "LEFT OUTER
-JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
-          }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
+JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#{s}") }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{_br_quoted_name(count_column)
+          }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{_br_quoted_name(tbl_alias)}"
         self.joins_values |= ["#{join_clause} ON #{on_clause.join(' AND ')}"] # Same as:  joins!(...)
       end unless cust_col_override
       while (n = nix.pop)
@@ -922,6 +903,7 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
               s << v
             end
           else # String stuff (which defines a custom ORDER BY) just comes straight through
+            v = v.split('.').map { |x| "\"#{x}\"" }.join('.')
             s << v
             # Avoid "PG::InvalidColumnReference: ERROR: for SELECT DISTINCT, ORDER BY expressions must appear in select list" in Postgres
             selects << v if is_distinct
@@ -1013,58 +995,80 @@ Might want to add this in your brick.rb:
     def shift_or_first(ary)
       ary.length > 1 ? ary.shift : ary.first
     end
+
+    def _br_quoted_name(name)
+      if is_mysql
+        "`#{name}`"
+      elsif is_postgres || is_mssql
+        "\"#{(name).gsub('.', '"."')}\""
+      else
+        name
+      end
+    end
+
+    def is_postgres
+      @is_postgres ||= ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+    end
+    def is_mysql
+      @is_mysql ||= ['Mysql2', 'Trilogy'].include?(ActiveRecord::Base.connection.adapter_name)
+    end
+    def is_mssql
+      @is_mssql ||= ActiveRecord::Base.connection.adapter_name == 'SQLServer'
+    end
   end
 
   module Inheritance
     module ClassMethods
     private
 
-      alias _brick_find_sti_class find_sti_class
-      def find_sti_class(type_name)
-        return if type_name.is_a?(Numeric)
+      if respond_to?(:find_sti_class)
+        alias _brick_find_sti_class find_sti_class
+        def find_sti_class(type_name)
+          return if type_name.is_a?(Numeric)
 
-        if ::Brick.sti_models.key?(type_name ||= name)
-          ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
-        else
-          # This auto-STI is more of a brute-force approach, building modules where needed
-          # The more graceful alternative is the overload of ActiveSupport::Dependencies#autoload_module! found below
-          ::Brick.sti_models[type_name] = { base: self } unless type_name.blank?
-          module_prefixes = type_name.split('::')
-          module_prefixes.unshift('') unless module_prefixes.first.blank?
-          module_name = module_prefixes[0..-2].join('::')
-          if (base_name = ::Brick.config.sti_namespace_prefixes&.fetch("#{module_name}::", nil)) ||
-             File.exist?(candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
-            if base_name
-              base_name == "::#{name}" ? self : base_name.constantize
-            else
-              _brick_find_sti_class(type_name) # Find this STI class normally
-            end
+          if ::Brick.sti_models.key?(type_name ||= name)
+            ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
           else
-            # Build missing prefix modules if they don't yet exist
-            this_module = Object
-            module_prefixes[1..-2].each do |module_name|
-              this_module = if this_module.const_defined?(module_name)
-                              this_module.const_get(module_name)
-                            else
-                              this_module.const_set(module_name.to_sym, Module.new)
-                            end
-            end
-            begin
-              if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
-                this_module.const_get(class_name)
+            # This auto-STI is more of a brute-force approach, building modules where needed
+            # The more graceful alternative is the overload of ActiveSupport::Dependencies#autoload_module! found below
+            ::Brick.sti_models[type_name] = { base: self } unless type_name.blank?
+            module_prefixes = type_name.split('::')
+            module_prefixes.unshift('') unless module_prefixes.first.blank?
+            module_name = module_prefixes[0..-2].join('::')
+            if (base_name = ::Brick.config.sti_namespace_prefixes&.fetch("#{module_name}::", nil)) ||
+              File.exist?(candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
+              if base_name
+                base_name == "::#{name}" ? self : base_name.constantize
               else
-                # Build STI subclass and place it into the namespace module
-                this_module.const_set(class_name, klass = Class.new(self))
-                klass
+                _brick_find_sti_class(type_name) # Find this STI class normally
               end
-            rescue NameError => err
-              if column_names.include?(inheritance_column)
-                puts "Table #{table_name} has column #{inheritance_column} which ActiveRecord expects to use as its special inheritance column."
-                puts "Unfortunately the value \"#{type_name}\" does not seem to refer to a valid type name, greatly confusing matters.  If that column is intended to be used for data and not STI, consider putting this line into your Brick initializer so that only for this table that column will not clash with ActiveRecord:"
-                puts "  Brick.sti_type_column = { 'rails_#{inheritance_column}' => ['#{table_name}'] }"
-                self
-              else
-                raise
+            else
+              # Build missing prefix modules if they don't yet exist
+              this_module = Object
+              module_prefixes[1..-2].each do |module_name|
+                this_module = if this_module.const_defined?(module_name)
+                                this_module.const_get(module_name)
+                              else
+                                this_module.const_set(module_name.to_sym, Module.new)
+                              end
+              end
+              begin
+                if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
+                  this_module.const_get(class_name)
+                else
+                  # Build STI subclass and place it into the namespace module
+                  this_module.const_set(class_name, klass = Class.new(self))
+                  klass
+                end
+              rescue NameError => err
+                if column_names.include?(inheritance_column)
+                  puts "Table #{table_name} has column #{inheritance_column} which ActiveRecord expects to use as its special inheritance column."
+                  puts "Unfortunately the value \"#{type_name}\" does not seem to refer to a valid type name, greatly confusing matters.  If that column is intended to be used for data and not STI, consider putting this line into your Brick initializer so that only for this table that column will not clash with ActiveRecord:"
+                  puts "  Brick.sti_type_column = { 'rails_#{inheritance_column}' => ['#{table_name}'] }"
+                  self
+                else
+                  raise
+                end
               end
             end
           end
@@ -2448,7 +2452,7 @@ end.class_exec do
                         end
           relation_name = schema_name ? "#{schema_name}.#{r['relation_name']}" : r['relation_name']
           # Both uppers and lowers as well as underscores?
-          apply_double_underscore_patch if relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
+          ::Brick.apply_double_underscore_patch if relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
           relation = relations[relation_name]
           relation[:isView] = true if r['table_type'] == 'VIEW'
           relation[:description] = r['table_description'] if r['table_description']
@@ -2497,7 +2501,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
             relation_name.downcase!
           # Both uppers and lowers as well as underscores?
           elsif relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
-            apply_double_underscore_patch
+            ::Brick.apply_double_underscore_patch
           end
           # Expect the default schema for SQL Server to be 'dbo'.
           if (::Brick.is_oracle && r[0] != schema) || (is_mssql && r[0] != 'dbo')
@@ -2524,6 +2528,15 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         end
       end
 
+      # PostGIS adds three views which would confuse Rails if models were to be built for them.
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        if relations.key?('geography_columns') && relations.key?('geometry_columns') && relations.key?('spatial_ref_sys')
+          (::Brick.config.exclude_tables ||= []) << 'geography_columns'
+          ::Brick.config.exclude_tables << 'geometry_columns'
+          ::Brick.config.exclude_tables << 'spatial_ref_sys'
+        end
+      end
+
       # # Add unique OIDs
       # if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       #   ActiveRecord::Base.execute_sql(
@@ -2655,7 +2668,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       pg_catalog.col_description(
         ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass::oid, c.ordinal_position
       ) AS column_description," if is_postgres}
-      c.column_name, c.data_type,
+      c.column_name, #{is_postgres ? "CASE c.data_type WHEN 'USER-DEFINED' THEN pg_t.typname ELSE c.data_type END AS data_type" : 'c.data_type'},
       COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
       kcu.constraint_type AS const, kcu.constraint_name AS \"key\",
       c.is_nullable
@@ -2676,7 +2689,11 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         kcu.CONSTRAINT_SCHEMA = c.table_schema
         AND kcu.TABLE_NAME = c.table_name
         AND kcu.column_name = c.column_name#{"
-    --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}
+    --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}#{"
+      INNER JOIN pg_catalog.pg_namespace pg_n ON pg_n.nspname = t.table_schema
+      INNER JOIN pg_catalog.pg_class pg_c ON pg_n.oid = pg_c.relnamespace AND pg_c.relname = c.table_name
+      INNER JOIN pg_catalog.pg_attribute pg_a ON pg_c.oid = pg_a.attrelid AND pg_a.attname = c.column_name
+      INNER JOIN pg_catalog.pg_type pg_t ON pg_t.oid = pg_a.atttypid" if is_postgres}
     WHERE t.table_schema #{is_postgres || is_mssql ?
         "NOT IN ('information_schema', 'pg_catalog', 'pg_toast', 'heroku_ext',
                  'INFORMATION_SCHEMA', 'sys')"
@@ -2698,43 +2715,6 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : 'ar_internal_metadata'
     [ar_smtn, ar_imtn]
   end
-
-  def apply_double_underscore_patch
-    unless @double_underscore_applied
-      # Same as normal #camelize and #underscore, just that double-underscores turn into a single underscore
-      ActiveSupport::Inflector.class_eval do
-        def camelize(term, uppercase_first_letter = true)
-          strings = term.to_s.split('__').map do |string|
-            # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
-            if !uppercase_first_letter || uppercase_first_letter == :lower
-              string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
-            else
-              string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
-            end
-            string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
-              word = $2
-              substituted = inflections.acronyms[word] || word.capitalize! || word
-              $1 ? "::#{substituted}" : substituted
-            end
-            string
-          end
-          strings.join('_')
-        end
-
-        def underscore(camel_cased_word)
-          return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
-          camel_cased_word.to_s.gsub("::", "/").split('_').map do |word|
-            word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
-            word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
-            word.tr!("-", "_")
-            word.downcase!
-            word
-          end.join('__')
-        end
-      end
-      @double_underscore_applied = true
-    end
-  end
 end
 
 # ==========================================
@@ -2761,7 +2741,7 @@ module Brick
 
   class << self
     def _add_bt_and_hm(fk, relations, polymorphic_class = nil, is_optional = false)
-      bt_assoc_name = ::Brick.namify(fk[2], :downcase)
+      bt_assoc_name = ::Brick.namify(fk[2].dup, :downcase)
       unless polymorphic_class
         bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
                           bt_assoc_name[-3] == '_' ? bt_assoc_name[0..-4] : bt_assoc_name[0..-3]

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

@@ -64,7 +64,7 @@ module Brick
             if lat_lng && !(lat_lng.first.zero? && lat_lng.last.zero?)
               # Create a link to this style of Google maps URL:  https://www.google.com/maps/place/38.7071296+-121.2810649/@38.7071296,-121.2810649,12z
               "<a href=\"https://www.google.com/maps/place/#{lat_lng.first}+#{lat_lng.last}/@#{lat_lng.first},#{lat_lng.last},12z\" target=\"blank\">#{val}</a>"
-            elsif val.is_a?(Numeric)
+            elsif val.is_a?(Numeric) && ::ActiveSupport.const_defined?(:NumberHelper)
               ::ActiveSupport::NumberHelper.number_to_delimited(val, delimiter: ',')
             else
               ::Brick::Rails::FormBuilder.hide_bcrypt(val, col_type == :xml)
@@ -685,8 +685,8 @@ window.addEventListener(\"popstate\", linkSchemas);
                 rescue StandardError => e
                   # Search through the routes to confirm that something might match (Devise stuff for instance, which has its own view templates),
                   # and bubble the same exception (probably an ActionView::MissingTemplate) if a legitimate option is found.
-                  raise if ::Rails.application.routes.set.find { |x| args[1].include?(x.defaults[:controller]) && args[0] == x.defaults[:action] } &&
-                           ActionView.version >= ::Gem::Version.new('5.0')
+                  raise if ActionView.version >= ::Gem::Version.new('5.0') &&
+                           ::Rails.application.routes.set.find { |x| args[1].include?(x.defaults[:controller]) && args[0] == x.defaults[:action] }
 
                   find_template_err = e
                 end
@@ -1258,57 +1258,73 @@ erDiagram
     // Have a click on the sheets link to bring up the sign-in window.  (Must happen from some kind of user click.)
     sheetsLink.addEventListener(\"click\", async function (evt) {
       evt.preventDefault();
-      await gapi.load(\"client\", function () {
-        gapi.client.init({ // Load the discovery doc to initialize the API
-          clientId: \"487319557829-fgj4u660igrpptdji7ev0r5hb6kh05dh.apps.googleusercontent.com\",
-          scope: \"https://www.googleapis.com/auth/spreadsheets https://www.googleapis.com/auth/drive.file\",
-          discoveryDocs: [\"https://sheets.googleapis.com/$discovery/rest?version=v4\"]
-        }).then(function () {
-          gapi.auth2.getAuthInstance().isSignedIn.listen(updateSignInStatus);
-          updateSignInStatus(gapi.auth2.getAuthInstance().isSignedIn.get());
-        });
+      var client = google.accounts.oauth2.initTokenClient({
+        client_id: \"487319557829-fgj4u660igrpptdji7ev0r5hb6kh05dh.apps.googleusercontent.com\",
+        scope: \"https://www.googleapis.com/auth/spreadsheets https://www.googleapis.com/auth/drive.file\",
+        callback: updateSignInStatus
       });
+      client.requestAccessToken();
     });
   }
 
-  async function updateSignInStatus(isSignedIn) {
-    if (isSignedIn) {
-      await gapi.client.sheets.spreadsheets.create({
-        properties: {
-          title: #{table_name.inspect},
-        },
-        sheets: [
-          // sheet1, sheet2, sheet3
-        ]
-      }).then(function (response) {
-        sheetUrl = response.result.spreadsheetUrl;
-        spreadsheetId = response.result.spreadsheetId;
-        sheetsLink.setAttribute(\"href\", sheetUrl); // response.result.spreadsheetUrl
-        console.log(\"x1\", sheetUrl);
-
-        // Get JSON data
-        fetch(changeout(<%= #{@_brick_model._brick_index}_path(format: :js).inspect.html_safe %>, \"_brick_schema\", brickSchema)).then(function (response) {
-          response.json().then(function (data) {
-            gapi.client.sheets.spreadsheets.values.append({
-              spreadsheetId: spreadsheetId,
-              range: \"Sheet1\",
-              valueInputOption: \"RAW\",
-              insertDataOption: \"INSERT_ROWS\"
-            }, {
-              range: \"Sheet1\",
-              majorDimension: \"ROWS\",
-              values: data,
-            }).then(function (response2) {
-  //            console.log(\"beefcake\", response2);
-            });
+  async function updateSignInStatus(token) {
+    await new Promise(function (resolve) {
+      gapi.load(\"client\", function () {
+        resolve(); // gapi client code now loaded
+      });
+    }).then(async function (x) {
+      gapi.client.setToken(token);
+      var discoveryDoc = await (await fetch(\"https://sheets.googleapis.com/$discovery/rest?version=v4\")).json();
+      await gapi.client.load(discoveryDoc, function () {
+        resolve(); // Spreadsheets code now loaded
+      });
+    });
+
+    await gapi.client.sheets.spreadsheets.create({
+      properties: {
+        title: #{table_name.inspect},
+      },
+      sheets: [
+        // sheet1, sheet2, sheet3
+      ]
+    }).then(function (response) {
+      sheetUrl = response.result.spreadsheetUrl;
+      spreadsheetId = response.result.spreadsheetId;
+      // sheetsLink.setAttribute(\"href\", sheetUrl);
+
+      // Get JSON data
+      var jsPath = <%= #{@_brick_model._brick_index}_path(format: :js).inspect.html_safe %>;
+      if (brickSchema) jsPath = changeout(jsPath, \"_brick_schema\", brickSchema);
+      fetch(jsPath).then(function (response) {
+        response.json().then(function (resp) {
+          // Expect the first row to have field names
+          var colHeaders = Object.keys(resp.data[0]);;
+          var ary = [colHeaders];
+          // Add all the rows
+          var row;
+          resp.data.forEach(function (row) {
+            ary.push(Object.keys(colHeaders).reduce(function(x, y) {
+              x.push(row[colHeaders[y]]); return x
+            }, []));
+          });
+          // Send to spreadsheet
+          gapi.client.sheets.spreadsheets.values.append({
+            spreadsheetId: spreadsheetId,
+            range: 'Sheet1',
+            valueInputOption: 'RAW',
+            insertDataOption: 'INSERT_ROWS',
+            values: ary
+          }).then(function (response2) {
+            // console.log('Spreadsheet created', response2);
           });
         });
       });
       window.open(sheetUrl, '_blank');
-    }
+    });
   }
 </script>
-<script async defer src=\"https://apis.google.com/js/api.js\" onload=\"gapiLoaded()\"></script>
+<script src=\"https://apis.google.com/js/api.js\"></script>
+<script async defer src=\"https://accounts.google.com/gsi/client\" onload=\"gapiLoaded()\"></script>
 "
                          end # DutyFree data export and import
 # %%% Instead of our current "for Janet Leverling (Employee)" kind of link we previously had this code that did a "where x = 123" thing:
@@ -1723,7 +1739,10 @@ end
         case collection
         when ActiveRecord::Relation # has_many (which comes in as a CollectionProxy) or a has_one#{
           poly_fix}
-          collection2, descrip_cols = collection.brick_list
+          collection2, descrip_cols = begin
+                                        collection.brick_list
+                                      rescue
+                                      end
         when ActiveRecord::Base # Object from a has_one :through
           collection2 = [collection]
         else # We get an array back when AR < 4.2

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

@@ -41,7 +41,7 @@ module Brick::Rails::FormBuilder
                    col&.type
                  end
       case (col_type ||= col&.sql_type)
-      when :string, :text
+      when :string, :text, :citext
         if ::Brick::Rails::FormBuilder.is_bcrypt?(val) # || .readonly?
           is_revert = false
           out << ::Brick::Rails::FormBuilder.hide_bcrypt(val, nil, 1000)

data/lib/brick/util.rb

@@ -32,9 +32,6 @@ module Brick
            !alp.include?(custom_require_dir)
           alp.unshift(custom_require_dir)
         end
-        # require 'pry-byebug'
-        # binding.pry
-        # z = 10
       elsif is_bundler
         puts "Bundler hack"
         require 'pry-byebug'
@@ -52,12 +49,11 @@ module Brick
           # then required in place of the original.
 
           Kernel.module_exec do
-            # class << self
             alias_method :orig_require, :require
-            # end
             # To be most faithful to Ruby's normal behaviour, this should look like a public singleton
             define_method(:require) do |name|
-              puts name if name.to_s.include?('cucu')
+              # %%% Can get a message such as "ActionDispatch::Routing is not missing constant RouteSet! (NameError)"
+              # binding.pry if name.start_with?('action_dispatch/routing/route_') # || name == 'active_support/values/time_zone'
               if (require_override = ::Brick::Util.instance_variable_get(:@_require_overrides)[name])
                 extension, folder_matcher, replacements, autoload_symbol = require_override
                 patched_filename = "/patched_#{name.tr('/', '_')}#{extension}"

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'brick/compatibility'
+ruby_version = ::Gem::Version.new(RUBY_VERSION)
 
 # Allow ActiveRecord 4.2.7 and older to work with newer Ruby (>= 2.4) by avoiding a "stack level too deep"
 # error when ActiveSupport tries to smarten up Numeric by messing with Fixnum and Bignum at the end of:
@@ -25,37 +26,6 @@ end
 
 require 'brick/util'
 
-# Allow ActiveRecord < 3.2 to work with Ruby 2.7 and later
-if (is_ruby_2_7 = (ruby_version = ::Gem::Version.new(RUBY_VERSION)) >= ::Gem::Version.new('2.7'))
-  if ActiveRecord.version < ::Gem::Version.new('3.2')
-    # Remove circular reference for "now"
-    ::Brick::Util._patch_require(
-      'active_support/values/time_zone.rb', '/activesupport',
-      ['  def parse(str, now=now)',
-      '  def parse(str, now=now())']
-    )
-    # Remove circular reference for "reflection" for ActiveRecord 3.1
-    if ActiveRecord.version >= ::Gem::Version.new('3.1')
-      ::Brick::Util._patch_require(
-        'active_record/associations/has_many_association.rb', '/activerecord',
-        ['reflection = reflection)',
-        'reflection = reflection())'],
-        :HasManyAssociation # Make sure the path for this guy is available to be autoloaded
-      )
-    end
-  end
-
-  # # Create unfrozen route path in Rails 3.2
-  # if ActiveRecord.version < ::Gem::Version.new('4')
-  #   ::Brick::Util._patch_require(
-  #     'action_dispatch/routing/route_set.rb', '/actiondispatch',
-  #     ["script_name.chomp('/')).to_s",
-  #      "script_name.chomp('/')).to_s.dup"],
-  #     :RouteSet # Make sure the path for this guy is available to be autoloaded
-  #   )
-  # end
-end
-
 # Add left_outer_joins! to Associations::JoinDependency and Relation::QueryMethods
 if ActiveRecord.version >= ::Gem::Version.new('4') && ActiveRecord.version < ::Gem::Version.new('5')
   ::Brick::Util._patch_require(
@@ -163,7 +133,8 @@ module Brick
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
     def relations
-      return {} if ::ActiveRecord::Base.connection_handler.connection_pool_list.blank?
+      return {} if (ch = ::ActiveRecord::Base.connection_handler).respond_to?(:connection_pool_list) &&
+                   ch.connection_pool_list.blank?
 
       # Key our list of relations for this connection off of the connection pool's object_id
       (@relations ||= {})[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
@@ -724,6 +695,44 @@ In config/initializers/brick.rb appropriate entries would look something like:
       end
       [klass, sti_type, found]
     end
+
+    def apply_double_underscore_patch
+      unless @double_underscore_applied
+        # Same as normal #camelize and #underscore, just that double-underscores turn into a single underscore
+        ActiveSupport::Inflector.class_eval do
+          def camelize(term, uppercase_first_letter = true)
+            strings = term.to_s.split('__').map do |string|
+              # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
+              if !uppercase_first_letter || uppercase_first_letter == :lower
+                string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+              else
+                string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
+              end
+              string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+                word = $2
+                substituted = inflections.acronyms[word] || word.capitalize! || word
+                $1 ? "::#{substituted}" : substituted
+              end
+              string
+            end
+            strings.join('_')
+          end
+
+          def underscore(camel_cased_word)
+            return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+            regex = inflections.respond_to?(:acronyms_underscore_regex) ? inflections.acronyms_underscore_regex : inflections.acronym_regex
+            camel_cased_word.to_s.gsub('::', '/').split('_').map do |word|
+              word.gsub!(regex) { "#{$1 && '_' }#{$2.downcase}" }
+              word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << '_' }
+              word.tr!('-', '_')
+              word.downcase!
+              word
+            end.join('__')
+          end
+        end
+        @double_underscore_applied = true
+      end
+    end
   end
 
   module RouteSet
@@ -946,20 +955,22 @@ In config/initializers/brick.rb appropriate entries would look something like:
           end
         end
 
-        if ::Brick.config.add_status && (status_as = "#{controller_prefix.tr('/', '_')}brick_status".to_sym)
-           (
-             !(status_route = instance_variable_get(:@set).named_routes.find { |route| route.first == status_as }&.last) ||
-             !status_route.ast.to_s.include?("/#{controller_prefix}brick_status/")
-           )
-          get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: status_as.to_s)
-        end
+        if (named_routes = instance_variable_get(:@set).named_routes).respond_to?(:find)
+          if ::Brick.config.add_status && (status_as = "#{controller_prefix.tr('/', '_')}brick_status".to_sym)
+            (
+              !(status_route = instance_variable_get(:@set).named_routes.find { |route| route.first == status_as }&.last) ||
+              !status_route.ast.to_s.include?("/#{controller_prefix}brick_status/")
+            )
+            get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: status_as.to_s)
+          end
 
-        if ::Brick.config.add_orphans && (orphans_as = "#{controller_prefix.tr('/', '_')}brick_orphans".to_sym)
-           (
-             !(orphans_route = instance_variable_get(:@set).named_routes.find { |route| route.first == orphans_as }&.last) ||
-             !orphans_route.ast.to_s.include?("/#{controller_prefix}brick_orphans/")
-           )
-          get("/#{controller_prefix}brick_orphans", to: 'brick_gem#orphans', as: 'brick_orphans')
+          if ::Brick.config.add_orphans && (orphans_as = "#{controller_prefix.tr('/', '_')}brick_orphans".to_sym)
+            (
+              !(orphans_route = instance_variable_get(:@set).named_routes.find { |route| route.first == orphans_as }&.last) ||
+              !orphans_route.ast.to_s.include?("/#{controller_prefix}brick_orphans/")
+            )
+            get("/#{controller_prefix}brick_orphans", to: 'brick_gem#orphans', as: 'brick_orphans')
+          end
         end
 
         if instance_variable_get(:@set).named_routes.names.exclude?(:brick_crosstab)
@@ -1030,7 +1041,11 @@ require 'brick/version_number'
 if (is_postgres = (Object.const_defined?('PG::VERSION') || Gem::Specification.find_all_by_name('pg').present?)) &&
    ActiveRecord.version < ::Gem::Version.new('4.2.6')
   ::Brick::Util._patch_require(
-    'active_record/connection_adapters/postgresql_adapter.rb', '/activerecord', ["'panic'", "'error'"]
+    'active_record/connection_adapters/postgresql_adapter.rb', '/activerecord', [
+      ["'panic'", "'error'"],
+      # ActiveRecord < 3.2.13 uses the pg_attrdef.adsrc column, but it's missing in Postgres 12 and later, so we need to use pg_get_expr(d.adbin, d.adrelid).
+      [', d.adsrc,', ', pg_get_expr(d.adbin, d.adrelid),']
+    ]
   )
 end
 
@@ -1317,8 +1332,8 @@ ActiveSupport.on_load(:active_record) do
   end
   # rubocop:enable Lint/ConstantDefinitionInBlock
 
-  arsc = ::ActiveRecord::StatementCache
-  if is_ruby_2_7 && arsc.respond_to?(:create) &&
+  if ruby_version >= ::Gem::Version.new('2.7') && ::ActiveRecord.const_defined?(:StatementCache) &&
+     (arsc = ::ActiveRecord::StatementCache).respond_to?(:create) &&
      (params = arsc.method(:create).parameters).length == 2 && params.last == [:opt, :block]
     arsc.class_exec do
       def self.create(connection, callable = nil, &block)
@@ -1423,14 +1438,18 @@ ActiveSupport.on_load(:active_record) do
         elsif araat.respond_to?(:create) # Rails 4.1 and 4.2
           @alias_tracker = araat.create(base.connection, joins)
           @alias_tracker.aliased_table_for(base, base.table_name) # Updates the count for base.table_name to 1
-        else # Rails 4.0
+        else # Rails <= 4.0
           is_rails_4 = true
           @base_klass    = base
           @table_joins   = joins
           @join_parts    = [JoinBase.new(base)]
           @associations  = {}
           @reflections   = []
-          @alias_tracker = araat.new(base.connection, joins)
+          @alias_tracker = if araat.instance_method(:initialize).parameters.length == 2 # Rails > 3.2.8
+                             araat.new(base.connection, joins)
+                           else
+                             araat.new(joins)
+                           end
           @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
           tree = build(associations)
         end
@@ -1441,7 +1460,7 @@ ActiveSupport.on_load(:active_record) do
         if (relation = associations.instance_variable_get(:@relation))
           tree.instance_variable_set(:@relation, relation)
         end
-        return if is_rails_4 # Rails 4.0 doesn't know about the rest
+        return if is_rails_4 # Rails <= 4.0 doesn't know about the rest
 
         @join_root = JoinBase.new base, build(tree, base)
         @join_root.children.each { |child| construct_tables! @join_root, child }
@@ -1618,7 +1637,7 @@ module ActiveRecord
         _brick_build_join_query(manager, buckets, *args) # , **kwargs)
       end
 
-    else # elsif private_instance_methods.include?(:select_association_list)
+    elsif private_instance_methods.include?(:select_association_list)
       alias _brick_select_association_list select_association_list
       def select_association_list(associations, stashed_joins = nil)
         result = _brick_select_association_list(associations, stashed_joins)

data/lib/generators/brick/migrations_generator.rb

@@ -137,7 +137,8 @@ module Brick
         fringe.each do |tbl|
           next unless (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
 
-          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ApplicationRecord.primary_key].flatten.sort)
+          ar_base = Object.const_defined?(:ApplicationRecord) ? ApplicationRecord : Class.new(ActiveRecord::Base)
+          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ar_base.primary_key].flatten.sort)
           # In case things aren't as standard
           if pkey_cols.empty?
             pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.142
+  version: 1.0.144
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-17 00:00:00.000000000 Z
+date: 2023-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.1.1
 - !ruby/object:Gem::Dependency
   name: fancy_gets
   requirement: !ruby/object:Gem::Requirement