brick 1.0.73 → 1.0.75

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31f69b5035fcebf947e729c3ebabdf3a686c364fb9ddc6a764a2b34740fdb7c9
-  data.tar.gz: 87009aad044a5a110146d26dc02f62451b18e7ad67b2b07d420edff0718a18c6
+  metadata.gz: acd5fdf68935981a46106c879f5ac1fb44ac790c269c3eb2c5429cd67880f916
+  data.tar.gz: 260ce60eeaf2e4b17ca5b5e76e54960c4d2685c9cb9d8549a35a16ce49b5a36c
 SHA512:
-  metadata.gz: 300fe830280b2ad9d265fa62166aac01ba3e511090f95efa412d1b9ed42fbd72b9f17f8fe51ac1bb358be42f012b46cffbb3c142f6fd3b11f2a442025824e8ec
-  data.tar.gz: abbd021f67adb2c03aae76340ba1cb1f38d0be5b5774d11c5a01a1315e02b80c293c9008021915315416da28937b40af59d821e41ad6ac0eed890be162865d98
+  metadata.gz: 00f45ff020fcd729c2115f6d9f6ab0ab588247b2d727de7e1bd6acf53fa685ef76eeecce181a7a0c4659d8156971f88466915749cfad44e993993179435acdbd
+  data.tar.gz: 74f0b40c44bae3729624ca0ba6a378f9067e4b0aa98460a03aa193e292432576327991d8c2a107317d8ce51ce223eee780a0d632d5805ca14b91a1b55388259f

data/lib/brick/extensions.rb

@@ -235,7 +235,7 @@ module ActiveRecord
 
     def self.bt_link(assoc_name)
       assoc_name = CGI.escapeHTML(assoc_name.to_s)
-      model_path = Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
+      model_path = ::Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
       av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
       av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('7')
       link = av_class.link_to(name, model_path)
@@ -641,7 +641,7 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
           module_prefixes.unshift('') unless module_prefixes.first.blank?
           module_name = module_prefixes[0..-2].join('::')
           if (snp = ::Brick.config.sti_namespace_prefixes)&.key?("::#{module_name}::") || snp&.key?("#{module_name}::") ||
-             File.exist?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
+             File.exist?(candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
             _brick_find_sti_class(type_name) # Find this STI class normally
           else
             # Build missing prefix modules if they don't yet exist
@@ -710,13 +710,17 @@ end
 Module.class_exec do
   alias _brick_const_missing const_missing
   def const_missing(*args)
-    if (self.const_defined?(args.first) && (possible = self.const_get(args.first)) && possible != self) ||
-       (self != Object && Object.const_defined?(args.first) &&
-         (
-           (possible = Object.const_get(args.first)) &&
-           (possible != self || (possible == self && possible.is_a?(Class)))
-         )
-       )
+    desired_classname = (self == Object) ? args.first.to_s : "#{name}::#{args.first}"
+    if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) && possible.name == desired_classname) ||
+       # Try to require the respective Ruby file
+       ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
+                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = args.first.to_s).underscore))
+        ) && (require_dependency(filename) || true) &&
+        ((possible = self.const_get(args.first)) && possible.name == desired_classname)
+       ) ||
+       # If any class has turned up so far (and we're not in the middle of eager loading)
+       # then return what we've found.
+       (is_defined && !::Brick.is_eager_loading)
       return possible
     end
     class_name = ::Brick.namify(args.first.to_s)
@@ -766,7 +770,7 @@ Module.class_exec do
                    (schema_name = [(singular_table_name = class_name.underscore),
                                    (table_name = singular_table_name.pluralize),
                                    ::Brick.is_oracle ? class_name.upcase : class_name,
-                                   (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }&.camelize ||
+                                   (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas&.include?(s) }&.camelize ||
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
                return self.const_get(schema_name) if self.const_defined?(schema_name)
 
@@ -789,7 +793,7 @@ Module.class_exec do
 #         module_prefixes = type_name.split('::')
 #         path = base_module.name.split('::')[0..-2] + []
 #         module_prefixes.unshift('') unless module_prefixes.first.blank?
-#         candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
+#         candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
       base_module._brick_const_missing(*args)
     # elsif base_module != Object
     #   module_parent.const_missing(*args)
@@ -811,7 +815,7 @@ class Object
         schema_name = [(singular_schema_name = base_name.underscore),
                        (schema_name = singular_schema_name.pluralize),
                        base_name,
-                       base_name.pluralize].find { |s| Brick.db_schemas.include?(s) }
+                       base_name.pluralize].find { |s| Brick.db_schemas&.include?(s) }
       end
       plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
       # If it's namespaced then we turn the first part into what would be a schema name
@@ -1141,16 +1145,18 @@ class Object
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
-          if is_swagger
-            if !params&.key?('_brick_schema') &&
-              (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
-              if params
-                referrer_params.each { |k, v| params.send(:parameters)[k] = v }
-              else
-                api_params = referrer_params&.to_h
-              end
+          if (is_swagger || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
+             !params&.key?('_brick_schema') &&
+             (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
+            if params
+              referrer_params.each { |k, v| params.send(:parameters)[k] = v }
+            else
+              api_params = referrer_params&.to_h
             end
-            ::Brick.set_db_schema(params || api_params)
+          end
+          ::Brick.set_db_schema(params || api_params)
+
+          if is_swagger
             json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
                      'servers': [
                        { 'url': '{scheme}://{defaultHost}', 'variables': {
@@ -1432,6 +1438,27 @@ module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
     conn = _brick_establish_connection(*args)
+      # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
+      # the default DEFERRED mode.
+      #   https://discuss.rubyonrails.org/t/failed-write-transaction-upgrades-in-sqlite3/81480/2
+      if ActiveRecord::Base.connection.adapter_name == 'SQLite'
+        arca = ::ActiveRecord::ConnectionAdapters
+        db_statements = arca::SQLite3::DatabaseStatements
+        # Rails 7.1 and later
+        if arca::AbstractAdapter.private_instance_methods.include?(:with_raw_connection)
+          db_statements.define_method(:begin_db_transaction) do
+            log("begin immediate transaction", "TRANSACTION") do
+              with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+                conn.transaction(:immediate)
+              end
+            end
+          end
+        else # Rails < 7.1
+          db_statements.define_method(:begin_db_transaction) do
+            log('begin immediate transaction', 'TRANSACTION') { @connection.transaction(:immediate) }
+          end
+        end
+      end
     begin
       _brick_reflect_tables
     rescue ActiveRecord::NoDatabaseError
@@ -1445,13 +1472,13 @@ module ActiveRecord::ConnectionHandling
     initializer_loaded = false
     if (relations = ::Brick.relations).empty?
       # If there's schema things configured then we only expect our initializer to be named exactly this
-      if File.exist?(brick_initializer = Rails.root.join('config/initializers/brick.rb'))
+      if File.exist?(brick_initializer = ::Rails.root.join('config/initializers/brick.rb'))
         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
       apartment = Object.const_defined?('Apartment')
-      if apartment && File.exist?(apartment_initializer = Rails.root.join('config/initializers/apartment.rb'))
+      if apartment && File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
@@ -1701,48 +1728,18 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       end
     end
 
-    tables = []
-    views = []
-    table_class_length = 0
-    view_class_length = 0
     relations.each do |k, v|
-      name_parts = k.split('.')
-      idx = 1
-      name_parts = name_parts.map do |x|
-        (idx += 1) <= name_parts.length ? x : x.singularize
-      end
-      name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
-      class_name = name_parts.map(&:camelize).join('::')
-      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, name_parts]
+      rel_name = k.split('.').map { |rel_part| ::Brick.namify(rel_part, :underscore) }
+      schema_names = rel_name[0..-2]
+      schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
+      v[:schema] = schema_names.join('.') unless schema_names.empty?
+      # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
+      v[:resource] = rel_name.last
+      v[:class_name] = (schema_names + [rel_name.last.singularize]).map(&:camelize).join('::')
     end
-    puts "\n" if tables.present? || views.present?
-    if tables.present?
-      puts "Classes that can be built from tables:"
-      display_classes(tables, table_class_length)
-    end
-    if views.present?
-      puts "Classes that can be built from views:"
-      display_classes(views, view_class_length)
-    end
-
     ::Brick.load_additional_references if initializer_loaded
   end
 
-  def display_classes(rels, max_length)
-    rels.sort.each do |rel|
-      rel_link = rel.last.dup.map(&:underscore)
-      rel_link[-1] = rel_link[-1]
-      puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel_link.join('/')}"
-    end
-    puts "\n"
-  end
-
   def retrieve_schema_and_tables(sql = nil, is_postgres = nil, is_mssql = nil, schema = nil)
     is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer' if is_mssql.nil?
     sql ||= "SELECT t.table_schema AS \"schema\", t.table_name AS relation_name, t.table_type,#{"
@@ -2008,14 +2005,7 @@ module Brick
                        end
                      end
                    end
-      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
-         ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
-        Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
-      else
-        Zeitwerk::Loader.eager_load_all
-      end
-      abstract_activerecord_bases = ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
-      # abstract_activerecord_bases << ActiveRecord::Base
+      abstract_activerecord_bases = ::Brick.eager_load_classes(true)
       models = if Dir.exist?(model_path = "#{rails_root}/app/models")
                  Dir["#{model_path}/**/*.rb"].each_with_object({}) do |v, s|
                    File.read(v).split("\n").each do |line|

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

@@ -72,7 +72,6 @@ module Brick
             def set_brick_model(find_args)
               # Need to return true if we can fill in the blanks for a missing one
               # args will be something like:  ["index", ["categories"]]
-              find_args[1] = find_args[1].each_with_object([]) { |a, s| s.concat(a.split('/')) }
               if (class_name = find_args[1].last&.singularize)
                 find_args[1][find_args[1].length - 1] = class_name # Make sure the last item, defining the class name, is singular
                 if (model = find_args[1].map(&:camelize).join('::').constantize) && (
@@ -100,10 +99,13 @@ module Brick
             def find_template(*args, **options)
               unless (model_name = @_brick_model&.name) ||
                      (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
-                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
-                     # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
-                     (model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name)
-                return _brick_find_template(*args, **options)
+                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']])
+                if (possible_template = _brick_find_template(*args, **options))
+                  return possible_template
+                else
+                  # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
+                  model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name
+                end
               end
 
               if @_brick_model
@@ -726,7 +728,7 @@ erDiagram
   <td><h1>#{model_name}</h1></td>
   <td id=\"imgErd\" title=\"Show ERD\"></td>
 </tr></table>#{template_link}<%
-   if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
+   if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)).present? %><%=
      description %><br><%
    end
    # FILTER PARAMETERS

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -123,7 +123,7 @@ module Brick
   end
 
   class << self
-    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle
+    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading
 
     def set_db_schema(params = nil)
       schema = (params ? params['_brick_schema'] : ::Brick.default_schema) || 'public'
@@ -494,6 +494,28 @@ In config/initializers/brick.rb appropriate entries would look something like:
     def version
       VERSION::STRING
     end
+
+    def eager_load_classes(do_ar_abstract_bases = false)
+      ::Brick.is_eager_loading = true
+      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
+         ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
+        ::Rails.configuration.eager_load_namespaces.select { |ns| ns < ::Rails::Application }.each(&:eager_load!)
+      else
+        Zeitwerk::Loader.eager_load_all
+      end
+      abstract_ar_bases = if do_ar_abstract_bases
+                            ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
+                          end
+      ::Brick.is_eager_loading = false
+      abstract_ar_bases
+    end
+
+    def display_classes(rels, max_length)
+      rels.sort.each do |rel|
+        puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel.last}"
+      end
+      puts "\n"
+    end
   end
 
   module RouteSet
@@ -501,35 +523,59 @@ In config/initializers/brick.rb appropriate entries would look something like:
       return super if ::Brick.routes_done
 
       ::Brick.routes_done = true
+      tables = []
+      views = []
+      table_class_length = 38 # Length of "Classes that can be built from tables:"
+      view_class_length = 37 # Length of "Classes that can be built from views:"
       existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
       ::Rails.application.routes.append do
         # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
         # If auto-controllers and auto-models are both enabled then this makes sense:
-        ::Brick.relations.each do |rel_name, v|
-          rel_name = rel_name.split('.').map { |rel_part| ::Brick.namify(rel_part, :underscore) }
-          schema_names = rel_name[0..-2]
-          schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
-          # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
-          k = rel_name.last
-          unless existing_controllers.key?(controller_name = k.pluralize)
+        ::Brick.relations.each do |k, v|
+          unless !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
-            if schema_names.present? # && !Object.const_defined('Apartment')
-              send(:namespace, schema_names.first) do
-                send(:resources, k.to_sym, **options)
+            full_resource = nil
+            if (schema_name = v.fetch(:schema, nil)) # && !Object.const_defined('Apartment')
+              send(:namespace, schema_name) do
+                send(:resources, v[:resource].to_sym, **options)
               end
-              send(:get, "/api/v1/#{schema_names.first}/#{k}", { to: "#{schema_names.first}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              full_resource = "#{schema_name}/#{v[:resource]}"
+              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
             else
-              send(:resources, k.to_sym, **options)
-              send(:get, "/api/v1/#{k}", { to: "#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              send(:resources, v[:resource].to_sym, **options)
+              # Normally goes to something like:  /api/v1/employees
+              send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+            end
+
+            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, full_resource || v[:resource]]
             end
           end
-          if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
-            get('/brick_status', to: 'brick_gem#status', as: 'brick_status')
-          end
-          if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
-            get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
-          end
+        end
+        puts "\n" if tables.present? || views.present?
+        if tables.present?
+          puts "Classes that can be built from tables:#{' ' * (table_class_length - 38)}  Path:"
+          puts "======================================#{' ' * (table_class_length - 38)}  ====="
+          ::Brick.display_classes(tables, table_class_length)
+        end
+        if views.present?
+          puts "Classes that can be built from views:#{' ' * (view_class_length - 37)}  Path:"
+          puts "=====================================#{' ' * (view_class_length - 37)}  ====="
+          ::Brick.display_classes(views, view_class_length)
+        end
+
+        if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
+          get('/brick_status', to: 'brick_gem#status', as: 'brick_status')
+        end
+        if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
+          get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
         end
         if Object.const_defined?('Rswag::Ui') && doc_endpoint = Rswag::Ui.config.config_object[:urls].last
           # Serves JSON swagger info from a path such as  '/api-docs/v1/swagger.json'
@@ -562,12 +608,12 @@ require 'active_record/relation/query_methods' if ActiveRecord.version < ::Gem::
 require 'rails/railtie' if ActiveRecord.version < ::Gem::Version.new('4.2')
 
 # Rake tasks
-class Railtie < Rails::Railtie
+class Railtie < ::Rails::Railtie
   Dir.glob("#{File.expand_path(__dir__)}/brick/tasks/**/*.rake").each { |task| load task }
 end
 
 # Rails < 4.2 does not have env
-module Rails
+module ::Rails
   unless respond_to?(:env)
     def self.env
       @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")

data/lib/generators/brick/install_generator.rb

@@ -147,7 +147,7 @@ module Brick
 # Brick.enable_controllers = true # Setting this to \"false\" will disable controllers in development
 # Brick.enable_views = true # Setting this to \"false\" will disable views in development
 
-# Brick.api_root = '/api/v1/' # Path from which to serve out API resources when the RSwag gem is present
+# ::Brick.api_root = '/api/v1/' # Path from which to serve out API resources when the RSwag gem is present
 
 # # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
 # Brick.skip_database_views = true

data/lib/generators/brick/migrations_generator.rb

@@ -55,7 +55,7 @@ module Brick
       # If Apartment is active, see if a default schema to analyse is indicated
 
       # # Load all models
-      # Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+      # ::Brick.eager_load_classes
 
       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}."

data/lib/generators/brick/models_generator.rb

@@ -16,12 +16,7 @@ module Brick
       # %%% If Apartment is active and there's no schema_to_analyse, ask which schema they want
 
       # Load all models
-      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
-        ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
-        Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
-      else
-        Zeitwerk::Loader.eager_load_all
-      end
+      ::Brick.eager_load_classes
 
       # Generate a list of viable models that can be chosen
       longest_length = 0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.73
+  version: 1.0.75
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-26 00:00:00.000000000 Z
+date: 2022-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord