brick 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 580f34a900e392172361e334170169b30c63f83e96bd7b3119e9d957d440d6b1
-  data.tar.gz: b02a7265b8010fe06d9599d353f7cdaf2435f872411fe8d6871fbd79e275ce19
+  metadata.gz: 1b4733a804fae7a4759eae48690541f1873cb81fd1b2a9986f849202c1c76c5d
+  data.tar.gz: d721f215cfed0473804f82969fd3c89dd7a94671d24b0f44b0e03cc73d787754
 SHA512:
-  metadata.gz: '038902e9a8bc77505c28cf0038ff6aa77d0440f389bbc43b29ffaccae4e344e37d1d8fa7a683aae44c5c36d6b51f282fcd22174539c47c8f30e162b3e9dc71b9'
-  data.tar.gz: f8e00496a7af527e47d75ef8a94cb02994224fa7fe536056b4399aac7758fdd3d3f3eddc364cbf6aec30efd4a56b852fa9982b7e06a48261a6bc9a178bc161fb
+  metadata.gz: b73c787a9c7aa6804d2cfce77921252dd77ce3e6e3710bd30875436d0f66011e6043e0ae4cbdaaeff6f4abb725d8051b5c1be139ee28b80648314f124ff7204f
+  data.tar.gz: 000b467728db85565d793df6e22429e3ff804bb7d39e5c4d6346becc24bc940ec9476fe00758d1e4a4fad868239e755ba7bdef596ecb115f358332656fd1be5e

data/lib/brick/config.rb

@@ -20,6 +20,33 @@ module Brick
       @serializer = Brick::Serializers::YAML
     end
 
+    # Indicates whether Brick models are on or off. Default: true.
+    def enable_models
+      @mutex.synchronize { !!@enable_models }
+    end
+
+    def enable_models=(enable)
+      @mutex.synchronize { @enable_models = enable }
+    end
+
+    # Indicates whether Brick controllers are on or off. Default: true.
+    def enable_controllers
+      @mutex.synchronize { !!@enable_controllers }
+    end
+
+    def enable_controllers=(enable)
+      @mutex.synchronize { @enable_controllers = enable }
+    end
+
+    # Indicates whether Brick views are on or off. Default: true.
+    def enable_views
+      @mutex.synchronize { !!@enable_views }
+    end
+
+    def enable_views=(enable)
+      @mutex.synchronize { @enable_views = enable }
+    end
+
     # Indicates whether Brick routes are on or off. Default: true.
     def enable_routes
       @mutex.synchronize { !!@enable_routes }
@@ -28,5 +55,14 @@ module Brick
     def enable_routes=(enable)
       @mutex.synchronize { @enable_routes = enable }
     end
+
+    # Additional table associations to use (Think of these as virtual foreign keys perhaps)
+    def additional_references=(references)
+      @mutex.synchronize { @additional_references = references }
+    end
+
+    def additional_references
+      @mutex.synchronize { @additional_references }
+    end
   end
 end

data/lib/brick/extensions.rb

@@ -28,57 +28,17 @@
 
 # Drag TmfModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = sectionn / etc
 
-
-# ====================================
-# Dynamically create generic templates
-# ====================================
-
-# For templates:
-class ActionView::LookupContext
-  alias :_brick_template_exists? :template_exists?
-  def template_exists?(*args, **options)
-    x = _brick_template_exists?(*args, **options)
-    # Need to return true if we can fill in the blanks for a missing one
-    # args will be something like:  ["index", ["categories"]]
-    unless x
-      relations = Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-      matching = [views_name = args[1]&.first, views_name.singularize].find { |m| relations.key?(m) }
-      if (x = matching && (matching = relations[matching]) &&
-           (['index', 'show'].include?(args.first) || # Everything has index and show
-             # Only CRU stuff has create / update / destroy
-             (!matching.key?(:isView) && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
-           )
-         )
-        instance_variable_set(:@_brick_match, matching)
-      end
-    end
-    x
-  end
-
-  alias :_brick_find_template :find_template
-  def find_template(*args, **options)
-    if @_brick_match
-      inline = case args.first
-      when 'index'
-        # Something like:  <%= @categories.inspect %>
-        "<%= @#{@_brick_match[:index]}.inspect %>"
-      when 'show'
-        "<%= @#{@_brick_match[:show]}.inspect %>"
-      end
-      # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
-      keys = options.has_key?(:locals) ? options[:locals].keys : []
-      handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')
-      ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
-    else
-      _brick_find_template(*args, **options)
-    end
-  end
-end
-
 # ==========================================================
 # Dynamically create model or controller classes when needed
 # ==========================================================
 
+# By default all models indicate that they are not views
+class ActiveRecord::Base
+  def self.is_view?
+    false
+  end
+end
+
 # Object.class_exec do
 class Object
   class << self
@@ -96,29 +56,28 @@ class Object
       # 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 class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
+      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
-        is_controller = true
-        table_name = ActiveSupport::Inflector.underscore(plural_class_name)
-        model_name = ActiveSupport::Inflector.singularize(plural_class_name)
-        singular_table_name = ActiveSupport::Inflector.singularize(table_name)
-      else # Model
+        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)
         table_name = ActiveSupport::Inflector.pluralize(singular_table_name)
+
+        # 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
-      relations = Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-      # Maybe, just maybe there's a database table that will satisfy this need
-      matches = [table_name, singular_table_name, plural_class_name, model_name]
-      if matching = matches.find { |m| relations.key?(m) }
-        built_class, code = if is_controller
-                              build_controller(class_name, model_name, singular_table_name, table_name, relations, matching)
-                            else
-                              build_model(model_name, singular_table_name, table_name, relations, matching)
-                            end
-        puts "#{code}end # #{ is_controller ? 'controller' : 'model' }\n\n"
+      if result
+        built_class, code = result
+        puts "\n#{code}"
         built_class
       else
         puts "MISSING! #{args.inspect} #{table_name}"
@@ -131,7 +90,7 @@ class Object
     def build_model(model_name, singular_table_name, table_name, relations, matching)
       # 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(class_name)}\".")
+        raise NameError.new("Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\".")
       end
       code = +"class #{model_name} < ActiveRecord::Base\n"
       built_model = Class.new(ActiveRecord::Base) do |new_model_class|
@@ -139,11 +98,13 @@ class Object
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" unless table_name == matching
 
-        # By default, views get marked as read-only
-        if (relation = relations[matching]).key?(:isView)
-          self.define_method :'readonly?' do
+        # 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)
+        if (is_view = (relation = relations[matching]).key?(:isView))
+          new_model_class.define_singleton_method :'is_view?' do
             true
           end
+          code << "  def self.is_view?; true; end\n"
         end
 
         # Missing a primary key column?  (Usually "id")
@@ -165,7 +126,7 @@ class Object
             code << "  self.primary_key = #{pk_sym.inspect}\n"
           end
         else
-          code << "  # Could not identify any column(s) to use as a primary key\n"
+          code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
         end
 
         # if relation[:cols].key?('last_update')
@@ -217,28 +178,31 @@ class Object
             end
           end
         end
+        code << "end # model #{model_name}\n\n"
       end # class definition
       [built_model, code]
     end
 
 
-    def build_controller(class_name, model_name, singular_table_name, table_name, relations, matching)
+    def build_controller(class_name, plural_class_name, model, relations)
+      table_name = ActiveSupport::Inflector.underscore(plural_class_name)
+      singular_table_name = ActiveSupport::Inflector.singularize(table_name)
+
       code = +"class #{class_name} < ApplicationController\n"
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
         Object.const_set(class_name.to_sym, new_controller_class)
 
-        model = model_name.constantize
         code << "  def index\n"
-        code << "    @#{table_name} = #{model_name}#{model.primary_key ? ".order(#{model.primary_key.inspect}" : '.all'})\n"
+        code << "    @#{table_name} = #{model.name}#{model.primary_key ? ".order(#{model.primary_key.inspect}" : '.all'})\n"
         code << "  end\n"
         self.define_method :index do
-          relation = model.primary_key ? model.order(model.primary_key) : model.all
-          instance_variable_set("@#{table_name}".to_sym, relation)
+          ar_relation = model.primary_key ? model.order(model.primary_key) : model.all
+          instance_variable_set("@#{table_name}".to_sym, ar_relation)
         end
 
         if model.primary_key
           code << "  def show\n"
-          code << "    @#{singular_table_name} = #{model_name}.find(params[:id].split(','))\n"
+          code << "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n"
           code << "  end\n"
           self.define_method :show do
             instance_variable_set("@#{singular_table_name}".to_sym, model.find(params[:id].split(',')))
@@ -246,9 +210,11 @@ class Object
         end
 
         # By default, views get marked as read-only
-        unless (relation = relations[matching]).key?(:isView)
+        unless (relation = relations[model.table_name]).key?(:isView)
           code << "  # (Define :new, :create, :edit, :update, and :destroy)\n"
+          # Get column names for params from relations[model.table_name][:cols].keys
         end
+        code << "end # #{class_name}\n\n"
       end # class definition
       [built_controller, code]
     end
@@ -270,14 +236,10 @@ end
 module ActiveRecord::ConnectionHandling
   alias old_establish_connection establish_connection
   def establish_connection(*args)
-    connections = Brick.instance_variable_get(:@relations) ||
-      Brick.instance_variable_set(:@relations, (connections = {}))
     # puts connections.inspect
     x = old_establish_connection(*args)
-    # Key our list of relations for this connection off of the connection pool's object_id
-    relations = (connections[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } })
 
-    if relations.empty?
+    if (relations = ::Brick.relations).empty?
       schema = 'public'
       puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
       sql = ActiveRecord::Base.send(:sanitize_sql_array, [
@@ -326,7 +288,7 @@ module ActiveRecord::ConnectionHandling
       end
 
       sql = ActiveRecord::Base.send(:sanitize_sql_array, [
-        "SELECT kcu1.CONSTRAINT_NAME, kcu1.TABLE_NAME, kcu1.COLUMN_NAME, kcu2.TABLE_NAME
+        "SELECT kcu1.TABLE_NAME, kcu1.COLUMN_NAME, kcu2.TABLE_NAME, kcu1.CONSTRAINT_NAME
         FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
           INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
             ON kcu1.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
@@ -340,31 +302,8 @@ module ActiveRecord::ConnectionHandling
         WHERE kcu1.CONSTRAINT_SCHEMA = ? -- COALESCE(current_setting('SEARCH_PATH'), 'public')", schema
         # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
       ])
-      ActiveRecord::Base.connection.execute(sql).values.each do |fk|
-        bt_assoc_name = fk[2].underscore
-        bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
-
-        bts = (relation = relations[fk[1]]).fetch(:fks) { relation[:fks] = {} }
-        if (assoc_bt = bts[fk[0]])
-          assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[2]] : assoc_bt[:fk].concat(fk[2])
-          assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[2]}"
-        else
-          assoc_bt = bts[fk[0]] = { is_bt: true, fk: fk[2], assoc_name: bt_assoc_name, inverse_table: fk[3] }
-        end
+      ActiveRecord::Base.connection.execute(sql).values.each { |fk| ::Brick._add_bt_and_hm(fk, relations) }
 
-        hms = (relation = relations[fk[3]]).fetch(:fks) { relation[:fks] = {} }
-        if (assoc_hm = hms[fk[0]])
-          assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[2]] : assoc_hm[:fk].concat(fk[2])
-          assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
-          assoc_hm[:inverse] = assoc_bt
-        else
-          assoc_hm = hms[fk[0]] = { is_bt: false, fk: fk[2], assoc_name: fk[1], alternate_name: bt_assoc_name, inverse_table: fk[1], inverse: assoc_bt }
-          hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-          hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
-        end
-        assoc_bt[:inverse] = assoc_hm
-        # hms[fk[0]] << { is_bt: false, fk: fk[2], assoc_name: fk[1], alternate_name: bt_assoc_name, inverse_table: fk[1] }
-      end
       # Find associative tables that can be set up for has_many :through
       relations.each do |_key, tbl|
         tbl_cols = tbl[:cols].keys
@@ -406,12 +345,62 @@ module Brick
 
     private
 
-      def _create_class()
-      end
     end
   end # module Extensions
   # rubocop:enable Style/CommentedKeyword
 
+  def self._add_bt_and_hm(fk, relations = nil)
+    relations ||= ::Brick.relations
+    bt_assoc_name = fk[1].underscore
+    bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
+
+    bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
+    hms = (relation = relations.fetch(fk[2], nil))&.fetch(:fks) { relation[:fks] = {} }
+
+    unless (cnstr_name = fk[3])
+      # For any appended references (those that come from config), arrive upon a definitely unique constraint name
+      cnstr_base = cnstr_name = "(brick) #{fk[0]}_#{fk[2]}"
+      cnstr_added_num = 1
+      cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
+      missing = []
+      missing << fk[0] unless relations.key?(fk[0])
+      missing << fk[2] unless relations.key?(fk[2])
+      unless missing.empty?
+        tables = relations.reject { |k, v| v.fetch(:isView, nil) }.keys.sort
+        puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
+        return
+      end
+      unless (cols = relations[fk[0]][:cols]).key?(fk[1])
+        columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
+        puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
+        return
+      end
+      if (redundant = bts.find{|k, v| v[:inverse][:inverse_table] == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == fk[2] })
+        puts "Brick: Additional reference #{fk.inspect} is redundant and can be removed.  (Already established by #{redundant.first}.)"
+        return
+      end
+    end
+
+    if (assoc_bt = bts[cnstr_name])
+      assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[1]] : assoc_bt[:fk].concat(fk[1])
+      assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
+    else
+      assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: fk[2] }
+    end
+
+    if (assoc_hm = hms[cnstr_name])
+      assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
+      assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
+      assoc_hm[:inverse] = assoc_bt
+    else
+      assoc_hm = hms[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+      hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
+      hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
+    end
+    assoc_bt[:inverse] = assoc_hm
+    # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
+  end
+
   # Rails < 4.0 doesn't have ActiveRecord::RecordNotUnique, so use the more generic ActiveRecord::ActiveRecordError instead
   ar_not_unique_error = ActiveRecord.const_defined?('RecordNotUnique') ? ActiveRecord::RecordNotUnique : ActiveRecord::ActiveRecordError
   class NoUniqueColumnError < ar_not_unique_error

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

@@ -7,13 +7,67 @@ module Brick
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
       config.brick = ActiveSupport::OrderedOptions.new
       initializer 'brick.initialisation' do |app|
+        Brick.enable_models = app.config.brick.fetch(:enable_models, true)
+        Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, true)
+
+        # ====================================
+        # Dynamically create generic templates
+        # ====================================
+        if (Brick.enable_views = app.config.brick.fetch(:enable_views, true))
+          ActionView::LookupContext.class_exec do
+            alias :_brick_template_exists? :template_exists?
+            def template_exists?(*args, **options)
+              unless (is_template_exists = _brick_template_exists?(*args, **options))
+                # Need to return true if we can fill in the blanks for a missing one
+                # args will be something like:  ["index", ["categories"]]
+                model = args[1].map(&:camelize).join('::').singularize.constantize
+                if (
+                     is_template_exists = model && (
+                       ['index', 'show'].include?(args.first) || # Everything has index and show
+                       # Only CRU stuff has create / update / destroy
+                       (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
+                     )
+                   )
+                  instance_variable_set(:@_brick_model, model)
+                end
+              end
+              is_template_exists
+            end
+
+            alias :_brick_find_template :find_template
+            def find_template(*args, **options)
+              if @_brick_model
+                inline = case args.first
+                when 'index'
+                  # Something like:  <%= @categories.inspect %>
+                  "<%= @#{@_brick_model.name.underscore.pluralize}.inspect %>"
+                when 'show'
+                  "<%= @#{@_brick_model.name.underscore}.inspect %>"
+                end
+                # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
+                keys = options.has_key?(:locals) ? options[:locals].keys : []
+                handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')
+                ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
+              else
+                _brick_find_template(*args, **options)
+              end
+            end
+          end
+        end
+
         # Auto-routing behaviour
         if (::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true))
           ::Brick.append_routes
         end
-        # 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)
+        # Additional references (virtual foreign keys)
+        if (ars = (::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)))
+          ars = ars.call if ars.is_a?(Proc)
+          ars = ars.to_a unless ars.is_a?(Array)
+          ars = [ars] unless ars.empty? || ars.first.is_a?(Array)
+          ars.each do |fk|
+            ::Brick._add_bt_and_hm(fk[0..2])
+          end
+        end
       end
     end
   end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -90,19 +90,73 @@ module Brick
       end
     end
 
+    # All tables and views (what Postgres calls "relations" including column and foreign key info)
+    def relations
+      connections = Brick.instance_variable_get(:@relations) ||
+        Brick.instance_variable_set(:@relations, (connections = {}))
+      # Key our list of relations for this connection off of the connection pool's object_id
+      (connections[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } })
+    end
+
+    # Switches Brick auto-models on or off, for all threads
+    # @api public
+    def enable_models=(value)
+      Brick.config.enable_models = value
+    end
+
+    # Returns `true` if Brick models are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_models?
+      !!Brick.config.enable_models
+    end
+
+    # Switches Brick auto-controllers on or off, for all threads
+    # @api public
+    def enable_controllers=(value)
+      Brick.config.enable_controllers = value
+    end
+
+    # Returns `true` if Brick controllers are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_controllers?
+      !!Brick.config.enable_controllers
+    end
+
+    # Switches Brick auto-views on or off, for all threads
+    # @api public
+    def enable_views=(value)
+      Brick.config.enable_views = value
+    end
+
+    # Returns `true` if Brick views are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_views?
+      !!Brick.config.enable_views
+    end
+
     # Switches Brick auto-routes on or off, for all threads
     # @api public
     def enable_routes=(value)
       Brick.config.enable_routes = value
     end
 
-    # Returns `true` if Brick routes are on, `false` otherwise. This is the
-    # on/off switch that affects all threads. Enabled by default.
+    # Returns `true` if Brick routes are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
     # @api public
     def enable_routes?
       !!Brick.config.enable_routes
     end
 
+    # Additional table associations to use (Think of these as virtual foreign keys perhaps)
+    # @api public
+    def additional_references=(value)
+      Brick.config.additional_references = value
+    end
+
+
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.
     #

metadata

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