brick 1.0.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 580f34a900e392172361e334170169b30c63f83e96bd7b3119e9d957d440d6b1
-  data.tar.gz: b02a7265b8010fe06d9599d353f7cdaf2435f872411fe8d6871fbd79e275ce19
+  metadata.gz: ff255b32c913dbb0e02d3f197d035faf43dc44afc4041cda3f57e92fc9df893a
+  data.tar.gz: 763b5579402a7668abf3d266665879643b8d44ed04686a35f2df145b1ddfee72
 SHA512:
-  metadata.gz: '038902e9a8bc77505c28cf0038ff6aa77d0440f389bbc43b29ffaccae4e344e37d1d8fa7a683aae44c5c36d6b51f282fcd22174539c47c8f30e162b3e9dc71b9'
-  data.tar.gz: f8e00496a7af527e47d75ef8a94cb02994224fa7fe536056b4399aac7758fdd3d3f3eddc364cbf6aec30efd4a56b852fa9982b7e06a48261a6bc9a178bc161fb
+  metadata.gz: f513e360dcba221bbd5061eb2ef3ef349a7c18ec6babae32273e877ba5b8cd0071f337f11c63460157afaa55cb0e8eea7dc99d80f64231270fc76218ef84397e
+  data.tar.gz: eb684612e551f8c884b618985884ad88b5ed827680fb4056f91f6c575fb479d18b92e6d4fa6de222ec24a7991f419723447313780fdbe5b7a0a903561dcb3dd7

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,38 @@ 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
+      @mutex.synchronize { @additional_references }
+    end
+
+    def additional_references=(references)
+      @mutex.synchronize { @additional_references = references }
+    end
+
+    def skip_database_views
+      @mutex.synchronize { @skip_database_views }
+    end
+
+    def skip_database_views=(disable)
+      @mutex.synchronize { @skip_database_views = disable }
+    end
+
+    def exclude_tables
+      @mutex.synchronize { @exclude_tables }
+    end
+
+    def exclude_tables=(value)
+      @mutex.synchronize { @exclude_tables = value }
+    end
+
+    def metadata_columns
+      @mutex.synchronize { @metadata_columns }
+    end
+
+    def metadata_columns=(columns)
+      @mutex.synchronize { @metadata_columns = columns }
+    end
   end
 end

data/lib/brick/extensions.rb

@@ -28,56 +28,64 @@
 
 # Drag TmfModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = sectionn / etc
 
+# ==========================================================
+# Dynamically create model or controller classes when needed
+# ==========================================================
 
-# ====================================
-# 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
+# By default all models indicate that they are not views
+module ActiveRecord
+  class Base
+    def self.is_view?
+      false
+    end
+
+    # Used to show a little prettier name for an object
+    def brick_descrip
+      klass = self.class
+      klass.primary_key ? "#{klass.name} ##{send(klass.primary_key)}" : to_s
+    end
+
+  private
+
+    def self._brick_get_fks
+      @_brick_get_fks ||= reflect_on_all_associations.select { |a2| a2.macro == :belongs_to }.map(&:foreign_key)
     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 %>"
+  class Relation
+    def brick_where(params)
+      wheres = {}
+      rel_joins = []
+      params.each do |k, v|
+        if (ks = k.split('.')).length > 1
+          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
+      unless wheres.empty?
+        where!(wheres)
+        joins!(rel_joins) unless rel_joins.empty?
+        wheres # Return the specific parameters that we did use
       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
-# ==========================================================
+# Rails::Application.class_exec do
+#   alias _brick_initialize! initialize!
+#   # Run Before initialize make sure our settings 
+#   def initialize!
+#     # initialization code goes here
+#     puts "BEFORE1"
+#     _brick_initialize!
+#   end
+# end
 
 # Object.class_exec do
 class Object
@@ -96,29 +104,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}"
@@ -129,9 +136,12 @@ class Object
   private
 
     def build_model(model_name, singular_table_name, table_name, relations, matching)
+      return if ((is_view = (relation = relations[matching]).key?(:isView)) && ::Brick.config.skip_database_views) ||
+                ::Brick.config.exclude_tables.include?(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 +149,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
+          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 +177,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 +229,32 @@ class Object
             end
           end
         end
+        code << "end # model #{model_name}\n\n"
       end # class definition
       [built_model, code]
     end
 
+    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)
 
-    def build_controller(class_name, model_name, singular_table_name, table_name, relations, matching)
       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 << "    @#{table_name}.brick_where(params)\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(:@_brick_params, ar_relation.brick_where(params))
+          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 +262,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
@@ -268,16 +286,11 @@ end
 # ==========================================================
 
 module ActiveRecord::ConnectionHandling
-  alias old_establish_connection establish_connection
+  alias _brick_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?
+    x = _brick_establish_connection(*args)
+
+    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, [
@@ -306,9 +319,6 @@ module ActiveRecord::ConnectionHandling
         # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
 
         relation = relations[r['relation_name']]
-        relation[:index] = r['relation_name'].underscore
-        relation[:show] = relation[:index].singularize
-        relation[:index] = relation[:index].pluralize
         relation[:isView] = true if r['table_type'] == 'VIEW'
         col_name = r['column_name']
         cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
@@ -326,7 +336,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,45 +350,12 @@ 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
-
-        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
-        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 created_at, updated_at,This table has only foreign keys?
-        if fks.length > 1 && (tbl_cols - fks.keys - ['created_at', 'updated_at', 'deleted_at', 'last_update'] - tbl[:pkey].values.first).length.zero?
-          fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
-        end
-      end
+      ActiveRecord::Base.connection.execute(sql).values.each { |fk| ::Brick._add_bt_and_hm(fk, relations) }
     end
 
-    puts "Classes built from tables:"
+    puts "Classes that can be built from tables:"
     relations.select { |_k, v| !v.key?(:isView) }.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
-    puts "Classes built from views:"
+    puts "Classes that can be built from views:"
     relations.select { |_k, v| v.key?(:isView) }.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
     # pp relations; nil
 
@@ -406,12 +383,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

@@ -5,15 +5,222 @@ 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|
-        # Auto-routing behaviour
-        if (::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true))
-          ::Brick.append_routes
+      # 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)
+        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true)
+        ::Brick.skip_database_views = app.config.brick.fetch(:skip_database_views, false)
+
+        # Specific database tables and views to omit when auto-creating models
+        ::Brick.exclude_tables = app.config.brick.fetch(:exclude_tables, [])
+
+        # Columns to treat as being metadata for purposes of identifying associative tables for has_many :through
+        ::Brick.metadata_columns = app.config.brick.fetch(:metadata_columns, ['created_at', 'updated_at', 'deleted_at'])
+
+        # 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
+                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} }) %>
+</td>\n"
+                  end
+
+                  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 %>
+
+<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(', ')} }
+     @#{table_name}.columns.map(&:name).each do |col| %>
+    <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
+    <th>
+    <% if bt = bts[col]
+        if is_first
+          is_first = false
+          is_need_id_col = true %>
+          </th><th>
+        <% end %>
+      BT <%= bt[1].name %>
+    <% else
+        is_first = false %>
+      <%= col %>
+    <% end %>
+    </th>
+  <% end %>
+  <% if is_first # STILL haven't been able to write a first non-key / non-metadata column?
+    is_first = false
+    is_need_id_col = true %>
+    <th></th>
+  <% end %>
+#{hms_headers}
+  </tr>
+
+  <% @#{table_name}.each do |#{obj_name}| %>
+  <tr>
+    <% is_first = true
+       if is_need_id_col
+         is_first = false %>
+      <td><%= link_to \"#\{#{obj_name}.class.name\} ##\{#{obj_name}.id\}\", #{obj_name} %></td>
+    <% end %>
+    <% #{obj_name}.attributes.each do |k, val| %>
+      <% 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 %>
+      <% elsif is_first %>
+        <%= is_first = false; link_to val, #{obj_name} %>
+      <% else %>
+        <%= val %>
+      <% end %>
+      </td>
+    <% end %>
+#{hms_columns}
+    <!-- td>X</td -->
+  </tr>
+  <% end %>
+</table>
+
+<%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>
+"
+                    # "<%= @#{@_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
+
+          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
+                    end
+                  end
+                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
+          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
+          end
         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)
       end
     end
   end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -79,15 +79,51 @@ require 'brick/config'
 require 'brick/frameworks/rails'
 module Brick
   class << self
-    def append_routes
-      ::Rails.application.routes.append do
-        relations = (::Brick.instance_variable_get(:@relations) || {})[ActiveRecord::Base.connection_pool.object_id] || {}
-        relations.each do |k, v|
-          options = {}
-          options[:only] = [:index, :show] if v.key?(:isView)
-          send(:resources, k.underscore.pluralize.to_sym, **options)
-        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
@@ -96,13 +132,35 @@ module Brick
       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
 
+    # @api public
+    def skip_database_views=(value)
+      Brick.config.skip_database_views = value
+    end
+
+    # @api public
+    def exclude_tables=(value)
+      Brick.config.exclude_tables = value
+    end
+
+    # @api public
+    def metadata_columns=(value)
+      Brick.config.metadata_columns = value
+    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`.
     #

data/lib/generators/brick/install_generator.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 require 'rails/generators'
-require 'rails/generators/active_record'
+# require 'rails/generators/active_record'
 
 module Brick
-  # Auto-generates an IMPORT_TEMPLATE entry for one or more models
   class InstallGenerator < ::Rails::Generators::Base
-    include ::Rails::Generators::Migration
+    # include ::Rails::Generators::Migration
 
     source_root File.expand_path('templates', __dir__)
     class_option(
@@ -16,81 +15,128 @@ module Brick
       desc: 'Store changeset (diff) with each version'
     )
 
-    desc 'Generates (but does not run) a migration to add a versions table.' \
-         '  Also generates an initializer file for configuring Brick'
+    desc 'Generates an initializer file for configuring Brick'
 
-    def create_migration_file
-      add_brick_migration('create_versions')
-      add_brick_migration('add_object_changes_to_versions') if options.with_changes?
-    end
+    def create_initializer_file
+      unless File.exists?(filename = 'config/initializers/brick.rb')
+        create_file filename, "# frozen_string_literal: true
 
-    def self.next_migration_number(dirname)
-      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
-    end
+# # Settings for the Brick gem
+# # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
 
-  protected
+# # Normally these all start out as being enabled, but can be selectively disabled:
+# Brick.enable_routes = false
+# Brick.enable_models = false
+# Brick.enable_controllers = false
+# Brick.enable_views = false
+
+# # By default models are auto-created from database views, and set to be read-only.  This can be skipped.
+# Brick.skip_database_views = true
+
+# # Any tables or views you'd like to skip when auto-creating models
+# Brick.exclude_tables = ['custom_metadata', 'version_info']
 
-    def add_brick_migration(template)
-      migration_dir = File.expand_path('db/migrate')
-      if self.class.migration_exists?(migration_dir, template)
-        ::Kernel.warn "Migration already exists: #{template}"
-      else
-        migration_template(
-          "#{template}.rb.erb",
-          "db/migrate/#{template}.rb",
-          item_type_options: item_type_options,
-          migration_version: migration_version,
-          versions_table_options: versions_table_options
-        )
+# # Additional table references which are used to create has_many / belongs_to associations inside auto-created
+# # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
+# # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
+# # performance reasons or just out of sheer laziness these might be missing.
+# # Each of these virtual foreign keys is defined as an array having three values:
+# #   foreign table name / foreign key column / primary table name.
+# # (We boldly expect that the primary key identified by ActiveRecord on the primary table will be accurate,
+# # usually this is \"id\" but there are some good smarts that are used in case some other column has been set
+# # to be the primary key.
+# Brick.additional_references = [['orders', 'customer_id', 'customer'],
+#                                ['customer', 'region_id', 'regions']]
+
+# # 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
+# # then this setting resets that list.  For instance, here is the override for the Sakila sample database:
+# Brick.metadata_columns = ['last_updated']
+
+# # 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
+# # specified in routes.rb or elsewhere.  (Or just use an empty string in order to disable this behaviour.)
+# Brick.default_route_fallback = 'customers' # This defaults to \"customers/index\"
+# Brick.default_route_fallback = 'orders/outstanding' # Example of a non-RESTful route
+# Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
+"
       end
     end
 
+    # def create_migration_file
+    #   add_brick_migration('create_versions')
+    #   add_brick_migration('add_object_changes_to_versions') if options.with_changes?
+    # end
+
+    # def self.next_migration_number(dirname)
+    #   ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    # end
+
+  protected
+
+    # def add_brick_migration(template)
+    #   migration_dir = File.expand_path('db/migrate')
+    #   if self.class.migration_exists?(migration_dir, template)
+    #     ::Kernel.warn "Migration already exists: #{template}"
+    #   else
+    #     migration_template(
+    #       "#{template}.rb.erb",
+    #       "db/migrate/#{template}.rb",
+    #       item_type_options: item_type_options,
+    #       migration_version: migration_version,
+    #       versions_table_options: versions_table_options
+    #     )
+    #   end
+    # end
+
   private
 
-    # MySQL 5.6 utf8mb4 limit is 191 chars for keys used in indexes.
-    def item_type_options
-      opt = { null: false }
-      opt[:limit] = 191 if mysql?
-      ", #{opt}"
-    end
+    # # MySQL 5.6 utf8mb4 limit is 191 chars for keys used in indexes.
+    # def item_type_options
+    #   opt = { null: false }
+    #   opt[:limit] = 191 if mysql?
+    #   ", #{opt}"
+    # end
 
-    def migration_version
-      return unless (major = ActiveRecord::VERSION::MAJOR) >= 5
+    # def migration_version
+    #   return unless (major = ActiveRecord::VERSION::MAJOR) >= 5
 
-      "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
-    end
+    #   "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
+    # end
 
-    # Class names of MySQL adapters.
-    # - `MysqlAdapter` - Used by gems: `mysql`, `activerecord-jdbcmysql-adapter`.
-    # - `Mysql2Adapter` - Used by `mysql2` gem.
-    def mysql?
-      [
-        'ActiveRecord::ConnectionAdapters::MysqlAdapter',
-        'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
-      ].freeze.include?(ActiveRecord::Base.connection.class.name)
-    end
+    # # Class names of MySQL adapters.
+    # # - `MysqlAdapter` - Used by gems: `mysql`, `activerecord-jdbcmysql-adapter`.
+    # # - `Mysql2Adapter` - Used by `mysql2` gem.
+    # def mysql?
+    #   [
+    #     'ActiveRecord::ConnectionAdapters::MysqlAdapter',
+    #     'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
+    #   ].freeze.include?(ActiveRecord::Base.connection.class.name)
+    # end
 
-    # Even modern versions of MySQL still use `latin1` as the default character
-    # encoding. Many users are not aware of this, and run into trouble when they
-    # try to use Brick in apps that otherwise tend to use UTF-8. Postgres, by
-    # comparison, uses UTF-8 except in the unusual case where the OS is configured
-    # with a custom locale.
-    #
-    # - https://dev.mysql.com/doc/refman/5.7/en/charset-applications.html
-    # - http://www.postgresql.org/docs/9.4/static/multibyte.html
-    #
-    # Furthermore, MySQL's original implementation of UTF-8 was flawed, and had
-    # to be fixed later by introducing a new charset, `utf8mb4`.
-    #
-    # - https://mathiasbynens.be/notes/mysql-utf8mb4
-    # - https://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html
-    #
-    def versions_table_options
-      if mysql?
-        ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
-      else
-        ''
-      end
-    end
+    # # Even modern versions of MySQL still use `latin1` as the default character
+    # # encoding. Many users are not aware of this, and run into trouble when they
+    # # try to use Brick in apps that otherwise tend to use UTF-8. Postgres, by
+    # # comparison, uses UTF-8 except in the unusual case where the OS is configured
+    # # with a custom locale.
+    # #
+    # # - https://dev.mysql.com/doc/refman/5.7/en/charset-applications.html
+    # # - http://www.postgresql.org/docs/9.4/static/multibyte.html
+    # #
+    # # Furthermore, MySQL's original implementation of UTF-8 was flawed, and had
+    # # to be fixed later by introducing a new charset, `utf8mb4`.
+    # #
+    # # - https://mathiasbynens.be/notes/mysql-utf8mb4
+    # # - https://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html
+    # #
+    # def versions_table_options
+    #   if mysql?
+    #     ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
+    #   else
+    #     ''
+    #   end
+    # end
   end
 end

metadata

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