brick 1.0.4 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe6bf3e38aef34261d9398b25f804504e7152721673b0534253c4284c9018013
-  data.tar.gz: 766af0df2edc3dc8c8c73a5d1ecd99c8d738ed7cd00fc21c79c38ac3db991819
+  metadata.gz: b65cbc8bbf472c887136395afb13f9dcf6e460f0c279dda0372939da8863178f
+  data.tar.gz: d63ae1e8795bb788e67c05d98f245c086aa773fbfc5585f716e3371652976878
 SHA512:
-  metadata.gz: 40f2eacaf7fada3056f5bfc701b01441ad02e34e76e87dc8e53b36a546c87216e8a319c3f0763b8fecff49344224d5660ff5b875937a3e30e2e7c80c662f684c
-  data.tar.gz: 7901020af2ec1759c27c16a0c3a3ffbcddcd09691c652c14c02781823964e36409533afc562fb0d9beb508cc3329b601d6fe8c266c101f6db6d93aad5e055a3e
+  metadata.gz: e27c5bc4385ae585e1904fc142aa6e0a61b1c780c6e9d68efc4b6ce1b60f985db71922466ad5dff365e3c239a0220411af90ec2f148705bdc5a993e552494c50
+  data.tar.gz: 2937ec1ecb167d7db208c0f46aaab60670b95403ba22b464597c254c782e9075e0245514fd950fbb4267c3e3f206b7b49969cd5052dd3d6d89db41a7883cd7d9

data/lib/brick/config.rb

@@ -65,6 +65,15 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
+    # Associations to treat as a has_one
+    def has_ones
+      @mutex.synchronize { @has_ones }
+    end
+
+    def has_ones=(references)
+      @mutex.synchronize { @has_ones = references }
+    end
+
     def skip_database_views
       @mutex.synchronize { @skip_database_views }
     end

data/lib/brick/extensions.rb

@@ -61,14 +61,15 @@ module ActiveRecord
       wheres = {}
       rel_joins = []
       params.each do |k, v|
-        if (ks = k.split('.')).length > 1
+        case (ks = k.split('.')).length
+        when 1
+          next unless klass._brick_get_fks.include?(k)
+        when 2
           assoc_name = ks.first.to_sym
           # Make sure it's a good association name and that the model has that column name
           next unless klass.reflect_on_association(assoc_name)&.klass&.columns&.map(&:name)&.include?(ks.last)
 
           rel_joins << assoc_name unless rel_joins.include?(assoc_name)
-        else
-          next unless klass._brick_get_fks.include?(k)
         end
         wheres[k] = v.split(',')
       end
@@ -79,6 +80,18 @@ module ActiveRecord
       end
     end
   end
+
+  module Inheritance
+    module ClassMethods
+      private
+
+      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)
+      end
+    end
+  end
 end
 
 # Object.class_exec do
@@ -112,6 +125,11 @@ class Object
         singular_table_name = ActiveSupport::Inflector.underscore(model_name)
         table_name = ActiveSupport::Inflector.pluralize(singular_table_name)
 
+        # Adjust for STI if we know of a base model for the requested model name
+        if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+          table_name = base_model.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)
@@ -137,8 +155,9 @@ class Object
       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)}\".")
       end
-      code = +"class #{model_name} < ActiveRecord::Base\n"
-      built_model = Class.new(ActiveRecord::Base) do |new_model_class|
+      base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ActiveRecord::Base
+      code = +"class #{model_name} < #{base_model.name}\n"
+      built_model = Class.new(base_model) do |new_model_class|
         Object.const_set(model_name.to_sym, new_model_class)
         # 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
@@ -175,8 +194,10 @@ class Object
         end
 
         fks = relation[:fks] || {}
-        fks.each do |_constraint_name, assoc|
-          assoc_name = assoc[:assoc_name]
+        # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
+        hmts = 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
+          assoc_name = (assoc = fk.last)[:assoc_name]
           inverse_assoc_name = assoc[:inverse][:assoc_name]
           options = {}
           singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
@@ -184,6 +205,14 @@ class Object
                     need_class_name = singular_table_name.underscore != assoc_name
                     need_fk = "#{assoc_name}_id" != assoc[:fk]
                     inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], assoc[:inverse])
+                    if (has_ones = ::Brick.config.has_ones&.fetch(assoc[:inverse][:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
+                      inverse_assoc_name = if has_ones[singular_inv_assoc_name]
+                                             need_inverse_of = true
+                                             has_ones[singular_inv_assoc_name]
+                                           else
+                                             singular_inv_assoc_name
+                                           end
+                    end
                     :belongs_to
                   else
                     # need_class_name = ActiveSupport::Inflector.singularize(assoc_name) == ActiveSupport::Inflector.singularize(table_name.underscore)
@@ -191,29 +220,66 @@ class Object
                     assoc_name, need_class_name = _brick_get_hm_assoc_name(relation, assoc)
                     need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
                     # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
-                    :has_many
+                    if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
+                      assoc_name = if has_ones[singular_assoc_name]
+                                     need_class_name = true
+                                     has_ones[singular_assoc_name]
+                                   else
+                                     singular_assoc_name
+                                   end
+                      :has_one
+                    else
+                      :has_many
+                    end
                   end
+          # Figure out if we need to specially call out the class_name and/or foreign key
+          # (and if either of those then definitely also a specific inverse_of)
           options[:class_name] = singular_table_name.camelize if need_class_name
-          # Figure out if we need to specially call out the foreign key
+          # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
           if need_fk # Funky foreign key?
-            options[:foreign_key] = assoc[:fk].to_sym
+            options[:foreign_key] = if assoc[:fk].is_a?(Array)
+                                      assoc_fk = assoc[:fk].uniq
+                                      assoc_fk.length < 2 ? assoc_fk.first : assoc_fk
+                                    else
+                                      assoc[:fk].to_sym
+                                    end
           end
-          options[:inverse_of] = inverse_assoc_name.to_sym if need_class_name || need_fk
-          assoc_name = assoc_name.to_sym
-          code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
-          self.send(macro, assoc_name, **options)
+          options[:inverse_of] = inverse_assoc_name.to_sym if need_class_name || need_fk || need_inverse_of
 
-          # Look for any valid "has_many :through"
+          # Prepare a list of entries for "has_many :through"
           if macro == :has_many
             relations[assoc[:inverse_table]][:hmt_fks].each do |k, hmt_fk|
               next if k == assoc[:fk]
 
-              hmt_fk = ActiveSupport::Inflector.pluralize(hmt_fk)
-              code << "  has_many :#{hmt_fk}, through: #{assoc_name.inspect}\n"
-              self.send(:has_many, hmt_fk.to_sym, **{ through: assoc_name })
+              hmts[ActiveSupport::Inflector.pluralize(hmt_fk.last)] << [assoc, hmt_fk.first]
             end
           end
+
+          # And finally create a has_one, has_many, or belongs_to for this association
+          assoc_name = assoc_name.to_sym
+          code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
+          self.send(macro, assoc_name, **options)
+          hmts
         end
+        hmts.each do |hmt_fk, fks|
+          fks.each do |fk|
+            source = nil
+            this_hmt_fk = if fks.length > 1
+                            singular_assoc_name = ActiveSupport::Inflector.singularize(fk.first[:inverse][:assoc_name])
+                            source = fk.last
+                            through = ActiveSupport::Inflector.pluralize(fk.first[:alternate_name])
+                            "#{singular_assoc_name}_#{hmt_fk}"
+                          else
+                            through = fk.first[:assoc_name]
+                            hmt_fk
+                          end
+            code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
+            options = { through: assoc_name }
+            options[:source] = source.to_sym if source
+            self.send(:has_many, this_hmt_fk.to_sym, **options)
+          end
+        end
+
         code << "end # model #{model_name}\n\n"
       end # class definition
       [built_model, code]
@@ -257,7 +323,7 @@ class Object
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
-      if relation[:hm_counts][hm_assoc[:assoc_name]] > 1
+      if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
         [ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name]), true]
       else
         [ActiveSupport::Inflector.pluralize(hm_assoc[:inverse_table]), nil]
@@ -273,9 +339,13 @@ end
 module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
-    x = _brick_establish_connection(*args)
+    conn = _brick_establish_connection(*args)
+    _brick_reflect_tables
+    conn
+  end
 
-    if (relations = ::Brick.relations).empty?
+  def _brick_reflect_tables
+      if (relations = ::Brick.relations).empty?
       # Only for Postgres?  (Doesn't work in sqlite3)
       # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
@@ -367,7 +437,7 @@ module ActiveRecord::ConnectionHandling
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2'
         sql = ActiveRecord::Base.send(:sanitize_sql_array, [
-          "SELECT kcu1.TABLE_NAME, kcu1.COLUMN_NAME, kcu2.TABLE_NAME, kcu1.CONSTRAINT_NAME
+          "SELECT kcu1.TABLE_NAME, kcu1.COLUMN_NAME, kcu2.TABLE_NAME AS primary_table, 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
@@ -389,9 +459,10 @@ module ActiveRecord::ConnectionHandling
       else
       end
       if sql
-        result = ActiveRecord::Base.connection.execute(sql)
-        result = result.values unless result.is_a?(Array)
-        result.each { |fk| ::Brick._add_bt_and_hm(fk, relations) }
+        ActiveRecord::Base.connection.execute(sql).each do |fk|
+          fk = fk.values unless fk.is_a?(Array)
+          ::Brick._add_bt_and_hm(fk, relations)
+        end
       end
     end
 
@@ -403,7 +474,6 @@ module ActiveRecord::ConnectionHandling
 
     # relations.keys.each { |k| ActiveSupport::Inflector.singularize(k).camelize.constantize }
     # Layout table describes permissioned hierarchy throughout
-    x
   end
 end
 

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

@@ -5,11 +5,8 @@ module Brick
     # See http://guides.rubyonrails.org/engines.html
     class Engine < ::Rails::Engine
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
-      puts "BEFORE - engine set config"
       config.brick = ActiveSupport::OrderedOptions.new
-      # initializer 'brick.initialisation' do |app|
       ActiveSupport.on_load(:before_initialize) do |app|
-        puts "BEFORE - engine initialisation"
         ::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)
@@ -25,83 +22,72 @@ module Brick
         # Additional references (virtual foreign keys)
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
-        # After we're initialized and before running the rest of stuff, put our configuration in place
-        ActiveSupport.on_load(:after_initialize) do |xyz|
-          puts "AFTER - engine initialisation"
-          # ====================================
-          # Dynamically create generic templates
-          # ====================================
-          if ::Brick.enable_views?
-            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
+        # Has one relationships
+        ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
+      end
+
+      # After we're initialized and before running the rest of stuff, put our configuration in place
+      ActiveSupport.on_load(:after_initialize) do
+        # ====================================
+        # Dynamically create generic templates
+        # ====================================
+        if ::Brick.enable_views?
+          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
-                is_template_exists
               end
+              is_template_exists
+            end
 
-              alias :_brick_find_template :find_template
-              def find_template(*args, **options)
-                if @_brick_model
-                  model_name = @_brick_model.name
-                  pk = @_brick_model.primary_key
-                  obj_name = model_name.underscore
-                  table_name = model_name.pluralize.underscore
-                  # This gets has_many as well as has_many :through
-                  # %%% weed out ones that don't have an available model to reference
-                  bts, hms = @_brick_model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
-                    case a.macro
-                    when :belongs_to
-                      # Build #brick_descrip if needed
-                      unless a.klass.instance_methods(false).include?(:brick_descrip)
-                        descrip_col = (a.klass.columns.map(&:name) - a.klass._brick_get_fks -
-                                      (::Brick.config.metadata_columns || []) -
-                                      [a.klass.primary_key]).first&.to_sym
-                        if descrip_col
-                          a.klass.define_method :brick_descrip do
-                            send(descrip_col)
-                          end
-                        end
-                      end
-
-                      s.first[a.foreign_key] = [a.name, a.klass]
-                    when :has_many
-                      s.last[a.name] = a
-                    end
-                    s
-                  end
-                  # Weed out has_manys that go to an associative table
-                  associatives = hms.select { |k, v| v.options[:through] }.each_with_object({}) do |hmt, s|
-                    s[hmt.first] = hms.delete(hmt.last.options[:through]) # End up with a hash of HMT names pointing to join-table associations
-                  end
-                  hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>HM#{'T' if hm.last.options[:through]} #{hm.first}</th>\n" }
-                  hms_columns = hms.each_with_object(+'') do |hm, s|
-                    hm_fk_name = if hm.last.options[:through]
-                      associative = associatives[hm.last.name]
-                      "'#{associative.name}.#{associative.foreign_key}'"
-                    else
-                      hm.last.foreign_key
-                    end
-                    s << "<td>
-  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) %>
+            alias :_brick_find_template :find_template
+            def find_template(*args, **options)
+              if @_brick_model
+                model_name = @_brick_model.name
+                pk = @_brick_model.primary_key
+                obj_name = model_name.underscore
+                table_name = model_name.pluralize.underscore
+                # This gets has_many as well as has_many :through
+                # %%% weed out ones that don't have an available model to reference
+                bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
+                # Weed out has_manys that go to an associative table
+                associatives = hms.select { |k, v| v.options[:through] }.each_with_object({}) do |hmt, s|
+                  s[hmt.first] = hms.delete(hmt.last.options[:through]) # End up with a hash of HMT names pointing to join-table associations
+                end
+                hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>H#{hm.last.macro == :has_one ? 'O' : 'M'}#{'T' if hm.last.options[:through]} #{hm.first}</th>\n" }
+                hms_columns = hms.each_with_object(+'') do |hm, s|
+                  hm_fk_name = if hm.last.options[:through]
+                                 associative = associatives[hm.last.name]
+                                 "'#{associative.name}.#{associative.foreign_key}'"
+                               else
+                                 hm.last.foreign_key
+                               end
+                  s << if hm.last.macro == :has_many
+"<td>
+  #\{#{obj_name}.#{hm.first}.count\} #{hm.first}<%= link_to \"\", #{hm.last&.klass&.name&.underscore&.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
 </td>\n"
-                  end
+                         else # has_one
+"<td>
+  <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
+</td>\n"
+                       end
+                end
 
-                  inline = case args.first
-                  when 'index'
-                    "<p style=\"color: green\"><%= notice %></p>
+                inline = case args.first
+                when 'index'
+                  "<p style=\"color: green\"><%= notice %></p>
 
 <h1>#{model_name.pluralize}</h1>
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
@@ -109,7 +95,7 @@ module Brick
 <table id=\"#{table_name}\">
   <tr>
   <% is_first = true; is_need_id_col = nil
-     bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last.last.name}, #{v.last.last.primary_key.inspect}]"}.join(', ')} }
+     bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
      @#{table_name}.columns.map(&:name).each do |col| %>
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
@@ -145,9 +131,9 @@ module Brick
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%= obj = bt[1].find_by(bt.last => val); link_to obj.brick_descrip, obj %>
+        <%= obj = bt[1].find_by(bt.last => val); link_to(obj.brick_descrip, obj) if obj %>
       <% elsif is_first %>
-        <%= is_first = false; link_to val, #{obj_name} %>
+        <%= is_first = false; link_to val, #{obj_name}_path(#{obj_name}.#{pk}) %>
       <% else %>
         <%= val %>
       <% end %>
@@ -161,63 +147,58 @@ module Brick
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
 "
-                  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)
+                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
 
-          if ::Brick.enable_routes?
-            ActionDispatch::Routing::RouteSet.class_exec do
-              alias _brick_finalize_routeset! finalize!
-              def finalize!(*args, **options)
-                unless @finalized
-                  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:
-                    relations = (::Brick.instance_variable_get(:@relations) || {})[ActiveRecord::Base.connection_pool.object_id] || {}
-                    relations.each do |k, v|
-                      unless existing_controllers.key?(controller_name = k.underscore.pluralize)
-                        options = {}
-                        options[:only] = [:index, :show] if v.key?(:isView)
-                        send(:resources, controller_name.to_sym, **options)
-                      end
+        if ::Brick.enable_routes?
+          ActionDispatch::Routing::RouteSet.class_exec do
+            alias _brick_finalize_routeset! finalize!
+            def finalize!(*args, **options)
+              unless @finalized
+                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 |k, v|
+                    unless existing_controllers.key?(controller_name = k.underscore.pluralize)
+                      options = {}
+                      options[:only] = [:index, :show] if v.key?(:isView)
+                      send(:resources, controller_name.to_sym, **options)
                     end
                   end
                 end
-                _brick_finalize_routeset!(*args, **options)
               end
+              _brick_finalize_routeset!(*args, **options)
             end
           end
+        end
 
-          # Additional references (virtual foreign keys)
-          if (ars = ::Brick.config.additional_references)
-            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
+        # Additional references (virtual foreign keys)
+        if (ars = ::Brick.config.additional_references)
+          ars.each do |fk|
+            ::Brick._add_bt_and_hm(fk[0..2])
           end
+        end
 
-          # Find associative tables that can be set up for has_many :through
-          ::Brick.relations.each do |_key, tbl|
-            tbl_cols = tbl[:cols].keys
-            fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = fk.last[:inverse_table] if fk.last[:is_bt]; s }
-            # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
-            # foreign keys then it can act as an associative table and thus be used with has_many :through.
-            if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - tbl[:pkey].values.first).length.zero?
-              fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
-            end
+        # Find associative tables that can be set up for has_many :through
+        ::Brick.relations.each do |_key, tbl|
+          tbl_cols = tbl[:cols].keys
+          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
+          # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
+          # foreign keys then it can act as an associative table and thus be used with has_many :through.
+          if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?
+            fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
           end
         end
       end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -81,6 +81,10 @@ if Gem::Specification.all_names.any? { |g| g.start_with?('rails-') }
   require 'brick/frameworks/rails'
 end
 module Brick
+  def self.sti_models
+    @sti_models ||= {}
+  end
+
   class << self
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
     def relations
@@ -90,6 +94,30 @@ module Brick
       (connections[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } })
     end
 
+    def get_bts_and_hms(model)
+      model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+        case a.macro
+        when :belongs_to
+          # Build #brick_descrip if needed
+          if a.klass.instance_methods(false).exclude?(:brick_descrip)
+            descrip_col = (a.klass.columns.map(&:name) - a.klass._brick_get_fks -
+                          (::Brick.config.metadata_columns || []) -
+                          [a.klass.primary_key]).first&.to_sym
+            if descrip_col
+              a.klass.define_method :brick_descrip do
+                send(descrip_col)
+              end
+            end
+          end
+
+          s.first[a.foreign_key] = [a.name, a.klass]
+        when :has_many, :has_one
+          s.last[a.name] = a
+        end
+        s
+      end
+    end
+
     # Switches Brick auto-models on or off, for all threads
     # @api public
     def enable_models=(value)
@@ -159,8 +187,28 @@ module Brick
 
     # Additional table associations to use (Think of these as virtual foreign keys perhaps)
     # @api public
-    def additional_references=(value)
-      Brick.config.additional_references = value
+    def additional_references=(ars)
+      if ars
+        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)
+        Brick.config.additional_references = ars
+      end
+    end
+
+    # Associations to treat as a has_one
+    # @api public
+    def has_ones=(hos)
+      if hos
+        hos = hos.call if hos.is_a?(Proc)
+        hos = hos.to_a unless hos.is_a?(Array)
+        hos = [hos] unless hos.empty? || hos.first.is_a?(Array)
+        # Translate to being nested hashes
+        Brick.config.has_ones = hos&.each_with_object(Hash.new { |h, k| h[k] = {} }) do |v, s|
+          s[v.first][v[1]] = v[2] if v[1]
+          s
+        end
+      end
     end
 
 

data/lib/generators/brick/install_generator.rb

@@ -48,6 +48,14 @@ module Brick
 # Brick.additional_references = [['orders', 'customer_id', 'customer'],
 #                                ['customer', 'region_id', 'regions']]
 
+# # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
+# # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
+# # using the primary model name and the association name which you instead want to have treated as a \"has_one\":
+# Brick.has_ones = [['User', 'user_profile']]
+# # If you want to use an alternate name for the \"has_one\", such as in the case above calling the association \"profile\"
+# # instead of \"user_profile\", then apply that as a third parameter like this:
+# Brick.has_ones = [['User', 'user_profile', 'profile']]
+
 # # We normally don't consider the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\" to count when
 # # finding tables which can serve as associative tables in an N:M association.  That is, ones that can be a
 # # part of a has_many :through association.  If you want to use different exclusion columns than our defaults

metadata

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