brick 1.0.11 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 513e7f88a3dc5ac0f198308e3d82b6f3990af72d5b7b628d83863d887ab50ee2
-  data.tar.gz: 845340d554fcfad33d1d841a3098fcf93aaae96dd426c17256cefbe103dd1997
+  metadata.gz: '09600b354a3f70f8680f3dd7a9be9349e6666c013c09a7c9a0dc240e811344ee'
+  data.tar.gz: 0f6ec90f3d38338797a10ec4fc338fae6fdea5b9fddb376c2044fe719afaaa8b
 SHA512:
-  metadata.gz: 87f4c91911e83770c025c36945bec40c191b73a539a94bf5188738b01b516df0347f20f3710d9cca8f392dfcc32b2df68413309edddedc13dfff8d47ca99efa6
-  data.tar.gz: e357a73bd2f5d6371a3d92344cd5635f458f332b2027d66851e068cd3f833f7fffd3ff6dc2a51d48bc2b9b9696d14a5ff999ea5a626341d14ff90286b4a19836
+  metadata.gz: 7189638a98c3899d49473a48638dce78da4ed109ed1d4a69185015f9b19428d658fa40ef0f70aa1652a478754b6c1b683a963424ec3e627c56e97b3c2528bba7
+  data.tar.gz: a843f0ec11b7e40bc4cf0a7387ab33e87edd4d9a36de1e24d10c899d969e148015da346fe7b7915f9ffd5a769818e8948de36beb1a368d38a6bb3ab3a97ca7c5

data/lib/brick/config.rb

@@ -91,6 +91,14 @@ module Brick
       @mutex.synchronize { @model_descrips = descrips }
     end
 
+    def sti_namespace_prefixes
+      @mutex.synchronize { @sti_namespace_prefixes ||= {} }
+    end
+
+    def sti_namespace_prefixes=(prefixes)
+      @mutex.synchronize { @sti_namespace_prefixes = prefixes }
+    end
+
     def skip_database_views
       @mutex.synchronize { @skip_database_views }
     end

data/lib/brick/extensions.rb

@@ -136,19 +136,67 @@ module ActiveRecord
 
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
-        ::Brick.sti_models[type_name] = { base: self } unless type_name.blank?
-        _brick_find_sti_class(type_name)
+        if ::Brick.sti_models.key?(type_name)
+          _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 ::Brick.config.sti_namespace_prefixes&.key?(module_name) ||
+             ::Brick.config.sti_namespace_prefixes&.key?(module_name[2..-1]) # Take off the leading '::' and see if this matches
+            _brick_find_sti_class(type_name)
+          elsif File.exists?(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
+            this_module = Object
+            module_prefixes[1..-2].each do |module_name|
+              mod = 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
+            # Build STI subclass and place it into the namespace module
+            this_module.const_set(module_prefixes.last.to_sym, klass = Class.new(self))
+            klass
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveSupport::Dependencies
+  class << self
+    # %%% Probably a little more targeted than other approaches we've taken thusfar
+    # This happens before the whole parent check
+    alias _brick_autoload_module! autoload_module!
+    def autoload_module!(*args)
+      into, const_name, qualified_name, path_suffix = args
+      if (base_class = ::Brick.config.sti_namespace_prefixes&.fetch(into.name, nil)&.constantize)
+        ::Brick.sti_models[qualified_name] = { base: base_class }
+        # Build subclass and place it into the specially STI-namespaced module
+        into.const_set(const_name.to_sym, klass = Class.new(base_class))
+        # %%% used to also have:  autoload_once_paths.include?(base_path) || 
+        autoloaded_constants << qualified_name unless autoloaded_constants.include?(qualified_name)
+        klass
+      else
+        _brick_autoload_module!(*args)
       end
     end
   end
 end
 
-# Object.class_exec do
 class Object
   class << self
     alias _brick_const_missing const_missing
     def const_missing(*args)
-      return Object.const_get(args.first) if Object.const_defined?(args.first)
+      return self.const_get(args.first) if self.const_defined?(args.first)
+      return Object.const_get(args.first) if Object.const_defined?(args.first) unless self == Object
 
       class_name = args.first.to_s
       # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
@@ -156,42 +204,58 @@ class Object
       # that is, checking #qualified_name_for with:  from_mod, const_name
       # If we want to support namespacing in the future, might have to utilise something like this:
       # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
-      # return Object._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
+      # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
       # If the file really exists, go and snag it:
-      return Object._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(class_name.underscore)
+      if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = self.name&.split('::'))
+        filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
+      end
+      if is_found
+        return self._brick_const_missing(*args)
+      elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
+        my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
+        return my_const
+      end
 
       relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-      result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
-        # Otherwise now it's up to us to fill in the gaps
-        if (model = ActiveSupport::Inflector.singularize(plural_class_name).constantize)
-          # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
-          build_controller(class_name, plural_class_name, model, relations)
-        end
-      elsif ::Brick.enable_models?
-        # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-        # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-        plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
-        singular_table_name = ActiveSupport::Inflector.underscore(model_name)
-
-        # Adjust for STI if we know of a base model for the requested model name
-        table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
-                       base_model.table_name
-                     else
-                       ActiveSupport::Inflector.pluralize(singular_table_name)
-                     end
-
-        # Maybe, just maybe there's a database table that will satisfy this need
-        if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
-          build_model(model_name, singular_table_name, table_name, relations, matching)
-        end
-      end
+      is_controllers_enabled = ::Brick.enable_controllers? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
+      result = if is_controllers_enabled && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
+                 # Otherwise now it's up to us to fill in the gaps
+                 if (model = ActiveSupport::Inflector.singularize(plural_class_name).constantize)
+                   # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
+                   build_controller(class_name, plural_class_name, model, relations)
+                 end
+               elsif ::Brick.enable_models?
+                 # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
+                 # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
+                 plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
+                 singular_table_name = ActiveSupport::Inflector.underscore(model_name)
+ 
+                 # Adjust for STI if we know of a base model for the requested model name
+                 table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+                               base_model.table_name
+                             else
+                               ActiveSupport::Inflector.pluralize(singular_table_name)
+                             end
+ 
+                 # Maybe, just maybe there's a database table that will satisfy this need
+                 if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
+                   build_model(model_name, singular_table_name, table_name, relations, matching)
+                 end
+               end
       if result
         built_class, code = result
         puts "\n#{code}"
         built_class
+      elsif ::Brick.config.sti_namespace_prefixes&.key?(class_name)
+        # binding.pry
+#         module_prefixes = type_name.split('::')
+#         path = self.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')
+        self._brick_const_missing(*args)
       else
         puts "MISSING! #{args.inspect} #{table_name}"
-        Object._brick_const_missing(*args)
+        self._brick_const_missing(*args)
       end
     end
 
@@ -203,7 +267,8 @@ class Object
 
       # Are they trying to use a pluralised class name such as "Employees" instead of "Employee"?
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
-        raise NameError.new("Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\".")
+        puts "Warning: Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\"."
+        return
       end
       if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
         is_sti = true

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

@@ -8,9 +8,9 @@ module Brick
       config.brick = ActiveSupport::OrderedOptions.new
       ActiveSupport.on_load(:before_initialize) do |app|
         ::Brick.enable_models = app.config.brick.fetch(:enable_models, true)
-        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, true)
-        ::Brick.enable_views = app.config.brick.fetch(:enable_views, true)
-        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true)
+        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, false)
+        ::Brick.enable_views = app.config.brick.fetch(:enable_views, false)
+        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, false)
         ::Brick.skip_database_views = app.config.brick.fetch(:skip_database_views, false)
 
         # Specific database tables and views to omit when auto-creating models
@@ -37,7 +37,7 @@ module Brick
         # ====================================
         # Dynamically create generic templates
         # ====================================
-        if ::Brick.enable_views?
+        if ::Brick.enable_views? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
           ActionView::LookupContext.class_exec do
             alias :_brick_template_exists? :template_exists?
             def template_exists?(*args, **options)
@@ -209,7 +209,11 @@ function changeout(href, param, value) {
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, bt_obj) if bt_obj %>
+        <%# Instead of just 'bt_obj we have to put in all of this junk:
+        # send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))
+        # Otherwise we get stuff like:
+        # ActionView::Template::Error (undefined method `vehicle_path' for #<ActionView::Base:0x0000000033a888>) %>
+        <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
       <% else %>
         <%= val %>
       <% end %>
@@ -244,7 +248,7 @@ function changeout(href, param, value) {
     </th>
     <td>
     <% if (bt = bts[k]) %>
-      <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, bt_obj) if bt_obj %>
+      <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
     <% else %>
       <%= val %>
     <% end %>
@@ -279,7 +283,7 @@ function changeout(href, param, value) {
           end
         end
 
-        if ::Brick.enable_routes?
+        if ::Brick.enable_routes? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
           ActionDispatch::Routing::RouteSet.class_exec do
             alias _brick_finalize_routeset! finalize!
             def finalize!(*args, **options)

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -228,6 +228,13 @@ module Brick
       Brick.config.model_descrips = descrips
     end
 
+    # Module prefixes to build out and associate with specific base STI models
+    # @api public
+    def sti_namespace_prefixes=(snp)
+      Brick.config.sti_namespace_prefixes = snp
+    end
+
+
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.
     #

data/lib/generators/brick/install_generator.rb

@@ -80,11 +80,13 @@ module Brick
 # # Settings for the Brick gem
 # # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
 
-# # Normally these all start out as being enabled, but can be selectively disabled:
-# Brick.enable_routes = false
+# # Normally all are enabled in development mode, and for security reasons only models are enabled in production
+# # and test.  This allows you to either (a) turn off models entirely, or (b) enable controllers, views, and routes
+# # in production.
+# Brick.enable_routes = true # Setting this to \"false\" will disable routes in development
 # Brick.enable_models = false
-# Brick.enable_controllers = false
-# Brick.enable_views = false
+# 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
 
 # # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
 # Brick.skip_database_views = true
@@ -133,6 +135,11 @@ module Brick
 # # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
 # Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
 
+# # Module prefixes to be built out and associated when new subclasses are requested for specific base STI models
+# # (If this setting exists then only these subclasses will be honoured, and other requested )
+# # The prefixed :: here on the sample module name LetterTemplates is optional.  Used here for clarity.
+# Brick.sti_namespace_prefixes = { '::LetterTemplates' => 'LetterTemplate' }
+
 # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
 # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
 # # name and action you wish in order to override this and have that be the default route when none other has been

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  version: 1.0.14
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-22 00:00:00.000000000 Z
+date: 2022-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord