brick 1.0.155 → 1.0.157

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fceffbcf863eb9c03b64a0cb4420a33ded5eb7f3908b40b263a345ae9bf5c164
-  data.tar.gz: 81f9f96bd1463b8b7e7736ed4716bcf78609bae27485af4de15cb23ae12e27ee
+  metadata.gz: 995a300b0971af02a39ed75857ce349c99720068555cbb1d6311a75d9a13f2b8
+  data.tar.gz: e9153dac19552fc8dd581774f89b9ed682ac040b5a4dc0d47f4b28fe079ca36d
 SHA512:
-  metadata.gz: c41a59ca62c80012166225b0cf80505b81fe57ccdfeb92c4add7f227d6d4a9cc0c664aaf5209c31dabd54c3e471fe140fd3dc75bf1441bbed0fca67e9801ffd9
-  data.tar.gz: 83c874515b230b0b607da32e41366284b15e830ebd7f7022fb318db412fef94a0339495de54c9ab0277425af2635cc8ab235675074cbb50f703082979ebd28b5
+  metadata.gz: 4c0c8553d5ef266aa6e947d6f0dd9ee4ae23d64118cd3c69565345747be0afa4de63be999976bd8e4fed55ebec2f3551aa87a4f4b84dee0a3dced188d23260f6
+  data.tar.gz: a7e0dbdd27c5d0905d7acf0a7a3f6fb5e254556ef65a0633a3021c395664c65f152afd3cecc53992c0f5da0095a1246b10d14898c34d82c60fc1cec298e62a68

data/lib/brick/config.rb

@@ -332,6 +332,14 @@ module Brick
       @mutex.synchronize { @table_name_prefixes = value }
     end
 
+    def treat_as_module
+      @mutex.synchronize { @treat_as_module || [] }
+    end
+
+    def treat_as_module=(mod_names)
+      @mutex.synchronize { @treat_as_module = mod_names }
+    end
+
     def order
       @mutex.synchronize { @order || {} }
     end

data/lib/brick/extensions.rb

@@ -59,7 +59,7 @@ module ActiveRecord
       end
 
       def is_brick?
-        instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
+        instance_variables.include?(:@_brick_relation) && instance_variable_get(:@_brick_relation)
       end
 
       def _assoc_names
@@ -544,11 +544,9 @@ module ActiveRecord
       wheres = {}
       params.each do |k, v|
         k = k.to_s # Rails < 4.2 comes in as a symbol
-        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)
+        next unless k.start_with?('__')
 
+        k = k[2..-1] # Take off leading "__"
         if (where_col = (ks = k.split('.')).last)[-1] == '!'
           where_col = where_col[0..-2]
         end
@@ -1163,6 +1161,9 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
 end
 
 ::Brick::ADD_CONST_MISSING = lambda do
+  return if @_brick_const_missing_done
+
+  @_brick_const_missing_done = true
   alias _brick_const_missing const_missing
   def const_missing(*args)
     requested = args.first.to_s
@@ -1187,9 +1188,13 @@ end
     end
     base_module = if self < ActiveRecord::Migration || !self.name
                     brick_root || Object
-                  elsif (split_self_name || self.name.split('::')).length > 1 # Classic mode
+                  elsif split_self_name&.length&.> 1 # Classic mode
                     begin
-                      return self._brick_const_missing(*args)
+                      base = self
+                      unless (base_goal = requested.split('::')[0..-2].join('::')).empty?
+                        base = base.parent while base.name != base_goal && base != Object
+                      end
+                      return base._brick_const_missing(*args)
 
                     rescue NameError # %%% Avoid the error "____ cannot be autoloaded from an anonymous class or module"
                       return self.const_get(args.first) if self.const_defined?(args.first)
@@ -1294,10 +1299,16 @@ end
                # Build out a module for the schema if it's namespaced
                # schema_name = schema_name.camelize
                base_module.const_set(schema_name.to_sym, (built_module = Module.new))
-
                [built_module, "module #{schema_name}; end\n"]
                # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
 
+             # MODULE (overrides from "treat_as_module")
+             elsif (::Brick.enable_models? || ::Brick.enable_controllers?) &&
+                   (possible_module = (base_module == Object ? '' : "#{base_module.name}::") + class_name) &&
+                   ::Brick.config.treat_as_module.include?(possible_module)
+               base_module.const_set(class_name.to_sym, (built_module = Module.new))
+               [built_module, "module #{possible_module}; end\n"]
+
              # AVO Resource
              elsif base_module == Object && Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) && requested.end_with?('Resource') &&
                    # Expect that anything called MotorResource or SpinaResource could be from those administrative gems
@@ -1464,12 +1475,12 @@ class Object
                                                               rescue StandardError => ex
                                                                 ::ActiveRecord::Base
                                                               end))
-
       end
       hmts = nil
       code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
         (schema_module || Object).const_set((chosen_name = (inheritable_name || model_name)).to_sym, new_model_class)
+        @_brick_relation = relation
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
             super(subclass)
@@ -1479,7 +1490,7 @@ class Object
               puts "should be \"class #{model_name} < #{inheritable_name}\"\n           (not \"#{subclass.name} < #{inheritable_name}\")"
             end
           end
-          self.abstract_class = true
+          new_model_class.abstract_class = true
           code << "  self.abstract_class = true\n"
         elsif Object.const_defined?('BCrypt') && relation[:cols].include?('password_digest') &&
               !instance_methods.include?(:password) && respond_to?(:has_secure_password)
@@ -1489,6 +1500,10 @@ class Object
         end
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || self.table_name != matching
+        if (inh_col = ::Brick.config.sti_type_column.find { |_k, v| v.include?(matching) }&.first)
+          new_model_class.inheritance_column = inh_col
+          code << "  self.inheritance_column = '#{inh_col}'\n"
+        end
 
         # Override models backed by a view so they return true for #is_view?
         # (Dynamically-created controllers and view templates for such models will then act in a read-only way)
@@ -1539,19 +1554,19 @@ class Object
         unless is_sti
           fks = relation[:fks] || {}
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
-          fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
-            # The key in each hash entry (fk.first) is the constraint name
-            inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
-            if (invs = assoc[:inverse_table]).is_a?(Array)
-              if assoc[:is_bt]
-                invs = invs.first # Just do the first one of what would be multiple identical polymorphic belongs_to
-              else
-                invs.each { |inv| build_bt_or_hm(full_name, relations, relation, hmts, assoc, inverse_assoc_name, inv, code) }
-              end
-            end
-            build_bt_or_hm(full_name, relations, relation, hmts, assoc, inverse_assoc_name, invs, code) unless invs.is_a?(Array)
-            hmts
-          end
+          hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts2|
+                   # The key in each hash entry (fk.first) is the constraint name
+                   inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
+                   if (invs = assoc[:inverse_table]).is_a?(Array)
+                     if assoc[:is_bt]
+                       invs = invs.first # Just do the first one of what would be multiple identical polymorphic belongs_to
+                     else
+                       invs.each { |inv| build_bt_or_hm(full_name, relations, relation, hmts2, assoc, inverse_assoc_name, inv, code) }
+                     end
+                   else
+                     build_bt_or_hm(full_name, relations, relation, hmts2, assoc, inverse_assoc_name, invs, code)
+                   end
+                 end
           # # Not NULLables
           # # %%% For the minute we've had to pull this out because it's been troublesome implementing the NotNull validator
           # relation[:cols].each do |col, datatype|
@@ -1569,58 +1584,54 @@ class Object
         #   self.broadcasts_to ->(model) { (model&.class&.name || chosen_name).underscore.pluralize.to_sym }
         #   code << "  broadcasts_to ->(#{chosen_name}) { #{chosen_name}&.class&.name&.underscore&.pluralize&.to_sym }\n"
         # end
-      end # class definition
-      # Having this separate -- will this now work out better?
-        built_model.class_exec do
-          @_brick_built = true
-          @_brick_relation = relation
-          hmts&.each do |hmt_fk, hms|
-            hmt_fk = hmt_fk.tr('.', '_')
-            hms.each do |hm|
-              # %%% Need to confirm that HMTs work when they are built from has_manys with custom names
-              through = ::Brick.config.schema_behavior[:multitenant] ? hm.first[:assoc_name] : hm.first[:inverse_table].tr('.', '_').pluralize
-              options = {}
-              hmt_name = if hms.length > 1
-                           if hms[0].first[:inverse][:assoc_name] == hms[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
-                             "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
-                           else # Use BT names to provide uniqueness
-                             if self.name.underscore.singularize == hm.first[:alternate_name]
-                               #  Has previously been:
-                               # # If it folds back on itself then look at the other side
-                               # # (At this point just infer the source be the inverse of the first has_many that
-                               # # we find that is not ourselves.  If there are more than two then uh oh, can't
-                               # # yet handle that rare circumstance!)
-                               # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
-                               # options[:source] = other.first[:inverse][:assoc_name].to_sym
-                               #  And also has been:
-                               # hm.first[:inverse][:assoc_name].to_sym
-                               options[:source] = hm.last.to_sym
-                             else
-                               through = hm.first.fetch(:alternate_chosen_name, hm.first[:alternate_name])
-                             end
-                             singular_assoc_name = hm.first[:inverse][:assoc_name].singularize
-                             "#{singular_assoc_name}_#{hmt_fk}"
-                           end
-                         else
-                           hmt_fk
-                         end
-              options[:through] = through.to_sym
-              if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
-                hmt_name = "#{hmt_name.singularize}_#{hm.first[:assoc_name]}"
-                # Was:
-                # options[:class_name] = hm.first[:inverse_table].singularize.camelize
-                # options[:foreign_key] = hm.first[:fk].to_sym
-                far_assoc = relations[hm.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == hm.last }
-                options[:class_name] = far_assoc.last[:inverse_table].singularize.camelize
-                options[:foreign_key] = far_assoc.last[:fk].to_sym
-              end
-              options[:source] ||= hm.last.to_sym unless hmt_name.singularize == hm.last
-              code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
-              self.send(:has_many, hmt_name.to_sym, **options)
+
+        hmts&.each do |hmt_fk, hms|
+          hmt_fk = hmt_fk.tr('.', '_')
+          hms.each do |hm|
+            # %%% Need to confirm that HMTs work when they are built from has_manys with custom names
+            through = ::Brick.config.schema_behavior[:multitenant] ? hm.first[:assoc_name] : hm.first[:inverse_table].tr('.', '_').pluralize
+            options = {}
+            hmt_name = if hms.length > 1
+                          if hms[0].first[:inverse][:assoc_name] == hms[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
+                            "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
+                          else # Use BT names to provide uniqueness
+                            if self.name.underscore.singularize == hm.first[:alternate_name]
+                              #  Has previously been:
+                              # # If it folds back on itself then look at the other side
+                              # # (At this point just infer the source be the inverse of the first has_many that
+                              # # we find that is not ourselves.  If there are more than two then uh oh, can't
+                              # # yet handle that rare circumstance!)
+                              # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
+                              # options[:source] = other.first[:inverse][:assoc_name].to_sym
+                              #  And also has been:
+                              # hm.first[:inverse][:assoc_name].to_sym
+                              options[:source] = hm.last.to_sym
+                            else
+                              through = hm.first.fetch(:alternate_chosen_name, hm.first[:alternate_name])
+                            end
+                            singular_assoc_name = hm.first[:inverse][:assoc_name].singularize
+                            "#{singular_assoc_name}_#{hmt_fk}"
+                          end
+                        else
+                          hmt_fk
+                        end
+            options[:through] = through.to_sym
+            if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
+              hmt_name = "#{hmt_name.singularize}_#{hm.first[:assoc_name]}"
+              # Was:
+              # options[:class_name] = hm.first[:inverse_table].singularize.camelize
+              # options[:foreign_key] = hm.first[:fk].to_sym
+              far_assoc = relations[hm.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == hm.last }
+              options[:class_name] = far_assoc.last[:inverse_table].singularize.camelize
+              options[:foreign_key] = far_assoc.last[:fk].to_sym
             end
+            options[:source] ||= hm.last.to_sym unless hmt_name.singularize == hm.last
+            code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
+            new_model_class.send(:has_many, hmt_name.to_sym, **options)
           end
         end
         code << "end # model #{full_name}\n"
+      end # model class definition
       [built_model, code]
     end
 
@@ -2147,6 +2158,17 @@ class Object
                 new_obj.send("#{k}=", ActiveStorage::Filename.new('')) if v.is_a?(ActiveStorage::Filename) && !v.instance_variable_get(:@filename)
               end if Object.const_defined?('ActiveStorage')
             end
+            new_obj.attribute_names.each do |a|
+              if (val = params["__#{a}"])
+                # val = case new_obj.class.column_for_attribute(a).type
+                #       when :datetime, :date, :time, :timestamp
+                #         val.
+                #       else
+                #         val
+                #       end
+                new_obj.send("#{a}=", val)
+              end
+            end
             instance_variable_set("@#{singular_table_name}".to_sym, new_obj)
             add_csp_hash
           end

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

@@ -750,12 +750,12 @@ window.addEventListener(\"popstate\", linkSchemas);
                                      (hm_fk_name.is_a?(String) && hm_fk_name.include?('.')) # HMT?  (Could do a better check for this)
                                     predicates = path_keys(hm_assoc, hm_fk_name, pk).map do |k, v|
                                                    if v == '[sti_type]'
-                                                     "'#{k}': (@#{obj_name}.#{hm_assoc.active_record.inheritance_column})&.constantize&.base_class&.name"
+                                                     "'__#{k}': (@#{obj_name}.#{hm_assoc.active_record.inheritance_column})&.constantize&.base_class&.name"
                                                    else
-                                                     v.is_a?(String) ? "'#{k}': '#{v}'" : "'#{k}': @#{obj_name}.#{v}"
+                                                     v.is_a?(String) ? "'__#{k}': '#{v}'" : "'__#{k}': @#{obj_name}.#{v}"
                                                    end
                                                  end.join(', ')
-                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{predicates} }) %>\n"
+                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path(predicates = { #{predicates} }) %>\n"
                                   else
                                     puts "Warning:  has_many :#{hm_assoc.name} in model #{hm_assoc.active_record.name} currently looks for a foreign key called \"#{hm_assoc.foreign_key}\".  "\
                                          "Instead it should use the clause  \"foreign_key: :#{hm_assoc.inverse_of&.foreign_key}\"."
@@ -897,6 +897,9 @@ tr th {
 tr th a {
   color: #80FFB8;
 }
+.add-hm-related {
+  float: right;
+}
 
 tr th, tr td {
   padding: 0.2em 0.5em;
@@ -1169,7 +1172,10 @@ if (window.brickFontFamily) {
       x.style.fontFamily = brickFontFamily.toString();
   });
 }
-</script>"
+</script>
+<% if (apartment_default_schema = ::Brick.apartment_multitenant && ::Brick.apartment_default_tenant)
+     Apartment::Tenant.switch!(apartment_default_schema)
+   end %>"
 
               erd_markup = if @_brick_model
                              "<div id=\"mermaidErd\" class=\"mermaid\">
@@ -1658,7 +1664,7 @@ end
      # path_options = [obj.#{pk}]
      # path_options << { '_brick_schema':  } if
      options = {}
-     if ::Brick.config.path_prefix
+     if ::Brick.config.path_prefix || (obj.class.table_name.singularize == obj.class.table_name)
        path_helper = obj.new_record? ? #{model_name}._brick_index : #{model_name}._brick_index(:singular)
        options[:url] = send(\"#\{path_helper}_path\".to_sym, obj)
      end
@@ -1763,7 +1769,14 @@ end
                      end"}"
                  end
       s << "<table id=\"#{hm_name}\" class=\"shadow\">
-        <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}</th></tr>
+        <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}
+          <span class = \"add-hm-related\"><%=
+            pk_val = (obj_pk = model.primary_key).is_a?(String) ? obj.send(obj_pk) : obj_pk.map { |pk_part| obj.send(pk_part) }
+            pk_val_arr = [pk_val] unless pk_val.is_a?(Array)
+            link_to('<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\"><path fill=\"#fff\" d=\"M24 10h-10v-10h-4v10h-10v4h10v10h4v-10h10z\"/></svg>'.html_safe,
+              new_#{hm.first.klass._brick_index(:singular)}_path(predicates))
+          %></span>
+        </th></tr>
         <% if (assoc = @#{obj_name}.class.reflect_on_association(:#{hm_name})).macro == :has_one &&
               assoc.options&.fetch(:through, nil).nil?
              # In order to apply DSL properly, evaluate this HO the other way around as if it were as a BT
@@ -2034,9 +2047,7 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
               alias _brick_render_template render_template
               def render_template(view, template, layout_name, *args)
                 layout_name = nil if (is_brick = template.instance_variable_get(:@is_brick)) && layout_name.is_a?(Proc)
-                result = _brick_render_template(view, template, layout_name, *args)
-                Apartment::Tenant.switch!(::Brick.apartment_default_tenant) if is_brick && ::Brick.apartment_multitenant
-                result
+                _brick_render_template(view, template, layout_name, *args)
               end
           end # TemplateRenderer
         end

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

@@ -71,11 +71,11 @@ module Brick::Rails::FormBuilder
         # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
         # If it's not yet enabled then:  create extension \"uuid-ossp\";
         # ActiveUUID gem created a new :uuid type
-        out << val
+        out << val if val
       when :ltree
         # In Postgres labels of data stored in a hierarchical tree-like structure
         # If it's not yet enabled then:  create extension ltree;
-        out << val
+        out << val if val
       when :binary
         is_revert = false
         if val
@@ -95,7 +95,7 @@ module Brick::Rails::FormBuilder
         else
           eheij = ActiveSupport::JSON::Encoding.escape_html_entities_in_json
           ActiveSupport::JSON::Encoding.escape_html_entities_in_json = false if eheij
-          val_str = val.to_json
+          val_str = val&.to_json
           ActiveSupport::JSON::Encoding.escape_html_entities_in_json = eheij
         end
         # Because there are so danged many quotes in JSON, escape them specially by converting to backticks.

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -113,21 +113,23 @@ module Brick
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
       # a different tenant.  If so then don't allow schema navigation.
-      chosen = if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' &&
-                  (current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2]
-                                                       .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first) &&
-                  (is_show_schema_list = (apartment_multitenant && current_schema == ::Brick.default_schema)) &&
-                  (schema = (params ? params['_brick_schema'] : ::Brick.default_schema)) &&
-                  ::Brick.db_schemas&.key?(schema)
-                 Apartment::Tenant.switch!(schema)
-                 schema
-               elsif ::Brick.test_schema
-                 is_show_schema_list = true
-                 Apartment::Tenant.switch!(::Brick.test_schema)
-                 ::Brick.test_schema
-               else
-                 current_schema # Just return the current schema
-               end
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && apartment_multitenant
+        current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)')
+                                            .first['current_schemas'][1..-2]
+                                            .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first
+        is_show_schema_list = current_schema == ::Brick.default_schema
+        schema = (is_show_schema_list && params && params['_brick_schema']) || ::Brick.default_schema
+        chosen = if is_show_schema_list && ::Brick.db_schemas&.key?(schema)
+                   Apartment::Tenant.switch!(schema)
+                   schema
+                 elsif ::Brick.test_schema
+                   is_show_schema_list = true
+                   Apartment::Tenant.switch!(::Brick.test_schema)
+                   ::Brick.test_schema
+                 else
+                   current_schema # Just return the current schema
+                 end
+      end
       [chosen == ::Brick.default_schema ? nil : chosen, is_show_schema_list]
     end
 
@@ -416,6 +418,12 @@ module Brick
       Brick.config.table_name_prefixes = value
     end
 
+    # @api public
+    # Causes Decidim to work with this line:  Brick.treat_as_module = ['Decidim::ContentBlocks']
+    def treat_as_module=(value)
+      Brick.config.treat_as_module = value
+    end
+
     # @api public
     def metadata_columns=(value)
       Brick.config.metadata_columns = value
@@ -1147,8 +1155,11 @@ ActiveSupport.on_load(:active_record) do
         class << self
           def execute_sql(sql, *param_array)
             param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
-            if ['OracleEnhanced', 'SQLServer'].include?(ActiveRecord::Base.connection.adapter_name)
+            case ActiveRecord::Base.connection.adapter_name
+            when 'OracleEnhanced', 'SQLServer'
               connection.exec_query(send(:sanitize_sql_array, [sql] + param_array)).rows
+            when 'Trilogy'
+              connection.execute(send(:sanitize_sql_array, [sql] + param_array)).rows
             else
               connection.execute(send(:sanitize_sql_array, [sql] + param_array))
             end
@@ -1159,8 +1170,7 @@ ActiveSupport.on_load(:active_record) do
       # :singleton-method:
       # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
       # dates and times from the database. This is set to :utc by default.
-      unless respond_to?(:default_timezone)
-        puts "ADDING!!! 4.w"
+      unless ::ActiveRecord.respond_to?(:default_timezone) || respond_to?(:default_timezone)
         mattr_accessor :default_timezone, instance_writer: false
         self.default_timezone = :utc
       end
@@ -1453,7 +1463,8 @@ ActiveSupport.on_load(:active_record) do
       class << self
         alias _original_load load
         def load(yaml, *args, **kwargs)
-          if kwargs[:aliases].nil? && caller[0..4].any? { |line| line.end_with?("`database_configuration'") }
+          if kwargs[:aliases].nil? && caller[0..4].any? { |line| line.end_with?("`database_configuration'") ||
+                                                                 line.end_with?("`secrets'") }
             kwargs[:aliases] = true
           end
           _original_load(yaml, *args, **kwargs)

data/lib/generators/brick/migrations_generator.rb

@@ -23,7 +23,8 @@ module Brick
                   'time with time zone' => 'time',
                   'double precision' => 'float',
                   'smallint' => 'integer', # %%% Need to put in "limit: 2"
-                  # # Oracle data types
+                  'ARRAY' => 'string', # Note that we'll also add ", array: true"
+                  # Oracle data types
                   'VARCHAR2' => 'string',
                   'CHAR' => 'string',
                   ['NUMBER', 22] => 'integer',
@@ -54,8 +55,8 @@ module Brick
     def brick_migrations
       # If Apartment is active, see if a default schema to analyse is indicated
 
-      # # Load all models
-      # ::Brick.eager_load_classes
+      ::Brick.mode = :on
+      ActiveRecord::Base.establish_connection
 
       if (tables = ::Brick.relations.reject { |k, v| v.key?(:isView) && v[:isView] == true }.map(&:first).sort).empty?
         puts "No tables found in database #{ActiveRecord::Base.connection.current_database}."
@@ -176,7 +177,7 @@ module Brick
           # Support missing primary key (by adding:  , id: false)
           id_option = if pk_is_also_fk || !pkey_cols&.present?
                         needs_serial_col = true
-                        ', id: false'
+                        +', id: false'
                       elsif ((pkey_col_first = (col_def = relation[:cols][pkey_cols&.first])&.first) &&
                              (pkey_col_first = SQL_TYPES[pkey_col_first] || SQL_TYPES[col_def&.[](0..1)] ||
                                                SQL_TYPES.find { |r| r.first.is_a?(Regexp) && pkey_col_first =~ r.first }&.last ||
@@ -185,16 +186,16 @@ module Brick
                             )
                         case pkey_col_first
                         when 'integer'
-                          ', id: :serial'
+                          +', id: :serial'
                         when 'bigint'
-                          ', id: :bigserial'
+                          +', id: :bigserial'
                         else
-                          ", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
+                          +", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
                         end +
                           (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
                       end
           if !id_option && pkey_cols.sort != arpk
-            id_option = ", primary_key: :#{pkey_cols.first}"
+            id_option = +", primary_key: :#{pkey_cols.first}"
           end
           if !is_4x_rails && (comment = relation&.fetch(:description, nil))&.present?
             (id_option ||= +'') << ", comment: #{comment.inspect}"
@@ -223,6 +224,7 @@ module Brick
                        SQL_TYPES.find { |r| r.first.is_a?(Regexp) && col_type.first =~ r.first }&.last ||
                        col_type.first
             suffix = col_type[3] || pkey_cols&.include?(col) ? +', null: false' : +''
+            suffix << ', array: true' if (col_type.first == 'ARRAY')
             if !is_4x_rails && klass && (comment = klass.columns_hash.fetch(col, nil)&.comment)&.present?
               suffix << ", comment: #{comment.inspect}"
             end

data/lib/generators/brick/models_generator.rb

@@ -15,6 +15,9 @@ module Brick
     def brick_models
       # %%% If Apartment is active and there's no schema_to_analyse, ask which schema they want
 
+      ::Brick.mode = :on
+      ActiveRecord::Base.establish_connection
+
       # Load all models
       ::Brick.eager_load_classes
 

data/lib/generators/brick/seeds_generator.rb

@@ -9,29 +9,50 @@ module Brick
 
     desc 'Auto-generates a seeds file from existing data.'
 
+    SeedModel = Struct.new(:table_name, :klass, :is_brick)
+    SeedModel.define_method(:to_s) do
+      "#{klass.name}#{' (brick-generated)' if is_brick}"
+    end
+
     def brick_seeds
       # %%% If Apartment is active and there's no schema_to_analyse, ask which schema they want
 
       ::Brick.mode = :on
       ActiveRecord::Base.establish_connection
 
-      if (tables = ::Brick.relations.reject { |k, v| v.key?(:isView) && v[:isView] == true }.map(&:first).sort).empty?
-        puts "No tables found in database #{ActiveRecord::Base.connection.current_database}."
+      # Load all models
+      ::Brick.eager_load_classes
+
+      # Generate a list of viable models that can be chosen
+      # First start with any existing models that have been defined ...
+      existing_models = ActiveRecord::Base.descendants.each_with_object({}) do |m, s|
+        s[m.table_name] = SeedModel.new(m.table_name, m, false) if !m.abstract_class? && m.table_exists?
+      end
+      models = (existing_models.values +
+                # ... then add models which can be auto-built by Brick
+                ::Brick.relations.reject do |k, v|
+                  (v.key?(:isView) && v[:isView] == true) || existing_models.key?(k)
+                end.map { |k, v| SeedModel.new(k, v[:class_name].constantize, true) }
+               ).sort { |a, b| a.to_s <=> b.to_s }
+      if models.empty?
+        puts "No viable models found for database #{ActiveRecord::Base.connection.current_database}."
         return
       end
 
       if File.exist?(seed_file_path = "#{::Rails.root}/db/seeds.rb")
-        puts "WARNING: seeds file #{seed_file_path} appears to already be present."
+        puts "WARNING: seeds file #{seed_file_path} appears to already be present.\nOverwrite?"
+        return unless gets_list(list: ['No', 'Yes']) == 'Yes'
+
+        puts "\n"
       end
 
-      # Generate a list of tables that can be chosen
-      chosen = gets_list(list: tables, chosen: tables.dup)
+      chosen = gets_list(list: models, chosen: models.dup)
       schemas = chosen.each_with_object({}) do |v, s|
-        if (v_parts = v.split('.')).length > 1
+        if (v_parts = v.table_name.split('.')).length > 1
           s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
         end
       end
-      seeds = +"# Seeds file for #{ActiveRecord::Base.connection.current_database}:"
+      seeds = +"# Seeds file for #{ActiveRecord::Base.connection.current_database}:\n"
       done = []
       fks = {}
       stuck = {}
@@ -40,12 +61,13 @@ module Brick
       # Start by making entries for fringe models (those with no foreign keys).
       # Continue layer by layer, creating entries for models that reference ones already done, until
       # no more entries can be created.  (At that point hopefully all models are accounted for.)
-      while (fringe = chosen.reject do |tbl|
+      while (fringe = chosen.reject do |seed_model|
+                        tbl = seed_model.table_name
                         snag_fks = []
                         snags = ::Brick.relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
                           v[:is_bt] && !v[:polymorphic] &&
                           tbl != v[:inverse_table] && # Ignore self-referencing associations (stuff like "parent_id")
-                          !done.include?(v[:inverse_table]) &&
+                          !done.any? { |done_seed_model| done_seed_model.table_name == v[:inverse_table] } &&
                           ::Brick.config.ignore_migration_fks.exclude?(snag_fk = "#{tbl}.#{v[:fk]}") &&
                           snag_fks << snag_fk
                         end
@@ -53,12 +75,14 @@ module Brick
                           # puts snag_fks.inspect
                           stuck[tbl] = snags
                         end
-                      end).present?
+                      end
+            ).present?
         seeds << "\n"
-        fringe.each do |tbl|
+        fringe.each do |seed_model|
+          tbl = seed_model.table_name
           next unless ::Brick.config.exclude_tables.exclude?(tbl) &&
                       (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present? &&
-                      (klass = Object.const_get(class_name = relation[:class_name])).table_exists?
+                      (klass = seed_model.klass).table_exists?
 
           pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ar_base.primary_key].flatten.sort)
           # In case things aren't as standard
@@ -82,10 +106,14 @@ module Brick
           fkeys = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
           # Refer to this table name as a symbol or dotted string as appropriate
           # tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
-          seeds << "  # #{class_name}\n"
 
+          has_rows = false
           is_empty = true
           klass.order(*pkey_cols).each do |obj|
+            unless has_rows
+              has_rows = true
+              seeds << "  puts 'Seeding: #{seed_model.klass.name}'\n"
+            end
             is_empty = false
             pk_val = obj.send(pkey_cols.first)
             fk_vals = []
@@ -98,19 +126,55 @@ module Brick
                 val = val.to_s
               end
               if fk
-                fk_vals << "#{fk[:assoc_name]}: #{fk[:inverse_table]}_#{val.inspect}" if val
+                inv_tbl = fk[:inverse_table].gsub('.', '__')
+                fk_vals << "#{fk[:assoc_name]}: #{inv_tbl}_#{brick_escape(val)}" if val
               else
                 data << "#{col}: #{val.inspect}"
               end
             end
-            seeds << "#{tbl}_#{pk_val} = #{class_name}.create(#{(fk_vals + data).join(', ')})\n"
+            seeds << "#{tbl.gsub('.', '__')}_#{brick_escape(pk_val)} = #{seed_model.klass.name}.create(#{(fk_vals + data).join(', ')})\n"
           end
+          seeds << "  # (Skipping #{seed_model.klass.name} as it has no rows)\n" unless has_rows
           File.open(seed_file_path, "w") { |f| f.write seeds }
         end
         done.concat(fringe)
         chosen -= done
       end
+      stuck_counts = Hash.new { |h, k| h[k] = 0 }
+      chosen.each do |leftover|
+        puts "Can't do #{leftover.klass.name} because:\n  #{stuck[leftover.table_name].map do |snag|
+          stuck_counts[snag.last[:inverse_table]] += 1
+          snag.last[:assoc_name]
+        end.join(', ')}"
+      end
       puts "\n*** Created seeds for #{done.length} models in db/seeds.rb ***"
+      if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
+        puts "-----------------------------------------"
+        puts "Unable to create migrations for #{stuck_sorted.length} tables#{
+          ".  Here's the top 5 blockers" if stuck_sorted.length > 5
+        }:"
+        pp stuck_sorted[0..4]
+      end
+    end
+
+  private
+
+    def brick_escape(val)
+      val = val.to_s if val.is_a?(Date) || val.is_a?(Time) # Accommodate when for whatever reason a primary key is a date or time
+      case val
+      when String
+        ret = +''
+        val.each_char do |ch|
+          if ch < '0' || (ch > '9' && ch < 'A') || ch > 'Z'
+            ret << (ch == '_' ? ch : "x#{'K'.unpack('H*')[0]}")
+          else
+            ret << ch
+          end
+        end
+        ret
+      else
+        val
+      end
     end
   end
 end

metadata

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