brick 1.0.2 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36447b749972f091f6d4c7c9127a7abfd5291d159f4ab81e0fb423feae7c2c03
-  data.tar.gz: eb2d1c36e67dd692ac765198c132c801c8633e32ecd199f42605f7659e7f3abd
+  metadata.gz: 9cd49783dae6701760920fe007cbde7382fd3dbaf5e8f7472d475c0fe8aaf660
+  data.tar.gz: d2330f28e87dde00b1377f6cbca31cbbfe2dd3b2c495f1fbd0aebc0f8a951504
 SHA512:
-  metadata.gz: da45315cae612125917448549f3be6cf163c6dc30ac97794f57544321b2c21536600903e9eb30a379fc6a0845656fe7704df863db13ad62a70c623f4f9cba454
-  data.tar.gz: 64ec86f256752004d07447e94788e453f3e6cf9006082629f5e46791b36d6ce8031e22753217d5f23be5b672f65b35ddb9a55b696db5de0bb85686f854154fee
+  metadata.gz: 2a3c7ba47d32f3a6ab6c9be838006826f5266efb1349d90ce7d53b5e8f89ea078bdcb699a7db8084176e2de444a27931ce8e0216af666c25704c0568b59ac827
+  data.tar.gz: 41fccf3387315cd54fd596955c3f07760941cd4aa51959dc99f87d0b6fb38de742ad11fe7dabb084a3e72167c340b8aafce838c7704626359ccb41878e202ae2

data/lib/brick/config.rb

@@ -65,6 +65,15 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
+    # Associations to treat has 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

@@ -26,7 +26,11 @@
 
 # colour coded origins
 
-# Drag TmfModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = sectionn / etc
+# Drag something like TmfModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = section / etc
+
+# Support for Postgres / MySQL enums (add enum to model, use model enums to make a drop-down in the UI)
+
+# Currently quadrupling up routes
 
 # ==========================================================
 # Dynamically create model or controller classes when needed
@@ -55,13 +59,23 @@ module ActiveRecord
   class Relation
     def brick_where(params)
       wheres = {}
+      rel_joins = []
       params.each do |k, v|
-        next unless klass._brick_get_fks.include?(k)
-
+        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)
+        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
     end
@@ -161,15 +175,6 @@ class Object
           code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
         end
 
-        # if relation[:cols].key?('last_update')
-        #   define_method :updated_at do
-        #     last_update
-        #   end
-        #   define_method :'updated_at=' do |val|
-        #     last_update=(val)
-        #   end
-        # end
-
         fks = relation[:fks] || {}
         fks.each do |_constraint_name, assoc|
           assoc_name = assoc[:assoc_name]
@@ -180,21 +185,38 @@ 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)
                     # Are there multiple foreign keys out to the same table?
                     assoc_name, need_class_name = _brick_get_hm_assoc_name(relation, assoc)
-                    need_fk = "#{singular_table_name}_id" != assoc[:fk]
+                    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
-          if need_fk # Funky foreign key?
-            options[:foreign_key] = assoc[:fk].to_sym
-          end
-          options[:inverse_of] = inverse_assoc_name.to_sym if need_class_name || need_fk
+          options[:foreign_key] = assoc[:fk].to_sym if need_fk # Funky foreign key?
+          options[:inverse_of] = inverse_assoc_name.to_sym if need_class_name || need_fk || need_inverse_of
           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)
@@ -224,7 +246,7 @@ class Object
         Object.const_set(class_name.to_sym, new_controller_class)
 
         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
@@ -269,16 +291,38 @@ 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
+
+  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
+
+      case ActiveRecord::Base.connection.adapter_name
+      when 'PostgreSQL'
+        schema = 'public'
+      when 'Mysql2'
+        schema = ActiveRecord::Base.connection.current_database
+      when 'SQLite'
+        sql = "SELECT m.name AS relation_name, UPPER(m.type) AS table_type,
+          p.name AS column_name, p.type AS data_type,
+          CASE p.pk WHEN 1 THEN 'PRIMARY KEY' END AS const
+        FROM sqlite_master AS m
+          INNER JOIN pragma_table_info(m.name) AS p
+        WHERE m.name NOT IN ('ar_internal_metadata', 'schema_migrations')
+        ORDER BY m.name, p.cid"
+      else
+        puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
+      end
 
-    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, [
+      sql ||= ActiveRecord::Base.send(:sanitize_sql_array, [
         "SELECT t.table_name AS relation_name, t.table_type,
           c.column_name, c.data_type,
           COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
-          tc.constraint_type AS const, kcu.constraint_name AS key
+          tc.constraint_type AS const, kcu.constraint_name AS \"key\"
         FROM INFORMATION_SCHEMA.tables AS t
           LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
             AND t.table_name = c.table_name
@@ -290,59 +334,98 @@ module ActiveRecord::ConnectionHandling
             AND kcu.ordinal_position = c.ordinal_position
           LEFT OUTER JOIN INFORMATION_SCHEMA.table_constraints AS tc
             ON kcu.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+            AND kcu.TABLE_NAME = tc.TABLE_NAME
             AND kcu.CONSTRAINT_NAME = tc.constraint_name
         WHERE t.table_schema = ? -- COALESCE(current_setting('SEARCH_PATH'), 'public')
   --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
           AND t.table_name NOT IN ('pg_stat_statements', 'ar_internal_metadata', 'schema_migrations')
         ORDER BY 1, t.table_type DESC, c.ordinal_position", schema
       ])
-      ActiveRecord::Base.connection.execute(sql).each do |r|
-        # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
-
-        relation = relations[r['relation_name']]
-        relation[:isView] = true if r['table_type'] == 'VIEW'
-        col_name = r['column_name']
-        cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
-        key = case r['const']
-              when 'PRIMARY KEY'
-                relation[:pkey][r['key']] ||= []
-              when 'UNIQUE'
-                relation[:ukeys][r['key']] ||= []
-                # key = (relation[:ukeys] = Hash.new { |h, k| h[k] = [] }) if key.is_a?(Array)
-                # key[r['key']]
-              end
-        key << col_name if key
-        cols[col_name] = [r['data_type'], r['max_length'], r['measures']&.include?(col_name)]
-        # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
+
+      measures = []
+      case ActiveRecord::Base.connection.adapter_name
+      when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
+        ActiveRecord::Base.connection.execute(sql).each do |r|
+          # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
+          relation = relations[(relation_name = r['relation_name'])]
+          relation[:isView] = true if r['table_type'] == 'VIEW'
+          col_name = r['column_name']
+          key = case r['const']
+                when 'PRIMARY KEY'
+                  relation[:pkey][r['key'] || relation_name] ||= []
+                when 'UNIQUE'
+                  relation[:ukeys][r['key'] || "#{relation_name}.#{col_name}"] ||= []
+                  # key = (relation[:ukeys] = Hash.new { |h, k| h[k] = [] }) if key.is_a?(Array)
+                  # key[r['key']]
+                end
+          key << col_name if key
+          cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
+          cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name)]
+          # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
+        end
+      else # MySQL2 acts a little differently, bringing back an array for each row
+        ActiveRecord::Base.connection.execute(sql).each do |r|
+          # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
+          relation = relations[(relation_name = r[0])] # here relation represents a table or view from the database
+          relation[:isView] = true if r[1] == 'VIEW' # table_type
+          col_name = r[2]
+          key = case r[5] # constraint type
+                when 'PRIMARY KEY'
+                  # key
+                  relation[:pkey][r[6] || relation_name] ||= []
+                when 'UNIQUE'
+                  relation[:ukeys][r[6] || "#{relation_name}.#{col_name}"] ||= []
+                  # key = (relation[:ukeys] = Hash.new { |h, k| h[k] = [] }) if key.is_a?(Array)
+                  # key[r['key']]
+                end
+          key << col_name if key
+          cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
+          # 'data_type', 'max_length'
+          cols[col_name] = [r[3], r[4], measures&.include?(col_name)]
+          # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
+        end
       end
 
-      sql = ActiveRecord::Base.send(:sanitize_sql_array, [
-        "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
-            AND kcu1.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
-            AND kcu1.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-          INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu2
-            ON kcu2.CONSTRAINT_CATALOG = rc.UNIQUE_CONSTRAINT_CATALOG
-            AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
-            AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
-            AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION
-        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 { |fk| ::Brick._add_bt_and_hm(fk, relations) }
+      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 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
+              AND kcu1.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+              AND kcu1.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu2
+              ON kcu2.CONSTRAINT_CATALOG = rc.UNIQUE_CONSTRAINT_CATALOG
+              AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
+              AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+              AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION
+          WHERE kcu1.CONSTRAINT_SCHEMA = ? -- COALESCE(current_setting('SEARCH_PATH'), 'public')", schema
+          # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
+        ])
+      when 'SQLite'
+        sql = "SELECT m.name, fkl.\"from\", fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
+        FROM sqlite_master m
+          INNER JOIN pragma_foreign_key_list(m.name) fkl ON m.type = 'table'
+        ORDER BY m.name, fkl.seq"
+      else
+      end
+      if sql
+        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
 
-    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
 
     # 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

@@ -6,14 +6,32 @@ module Brick
     class Engine < ::Rails::Engine
       # 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)
+      ActiveSupport.on_load(:before_initialize) do |app|
+        ::Brick.enable_models = app.config.brick.fetch(:enable_models, true)
+        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, true)
+        ::Brick.enable_views = app.config.brick.fetch(:enable_views, true)
+        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true)
+        ::Brick.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)
+
+        # 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 = app.config.brick.fetch(:enable_views, true))
+        if ::Brick.enable_views?
           ActionView::LookupContext.class_exec do
             alias :_brick_template_exists? :template_exists?
             def template_exists?(*args, **options)
@@ -22,12 +40,12 @@ module Brick
                 # 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))
-                     )
-                   )
+                      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
@@ -43,34 +61,21 @@ module Brick
                 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
+                bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
                 # Weed out has_manys that go to an associative table
-                hms.select { |k, v| v.options[:through] }.each { |_k, hmt| hms.delete(hmt.options[:through]) }
-                show_obj_blurb = "<td><%= link_to \"#\{#{obj_name}.class.name\} ##\{#{obj_name}.id\}\", #{obj_name} %></td>\n"
-                hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>HM #{hm.first}</th>\n" }
+                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.last.foreign_key}: #{obj_name}.#{pk} }) %>
+  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
 </td>\n"
                 end
 
@@ -94,7 +99,7 @@ module Brick
           is_need_id_col = true %>
           </th><th>
         <% end %>
-      BT <%= bt[1].name %>
+      BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
     <% else
         is_first = false %>
       <%= col %>
@@ -104,26 +109,26 @@ module Brick
   <% 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 %>
-    <td></td>
+    <th></th>
   <% end %>
 #{hms_headers}
   </tr>
 
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>
-    <% if is_need_id_col %>
-      <td>#{show_obj_blurb}</td>
+    <% 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 %>
-    <% is_first = true; #{obj_name}.attributes.each do |k, val| %>
+    <% #{obj_name}.attributes.each do |k, val| %>
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+      <td>
       <% if (bt = bts[k]) %>
-        <td>
         <%= obj = bt[1].find_by(bt.last => val); link_to obj.brick_descrip, obj %>
       <% elsif is_first %>
-        <td>
         <%= is_first = false; link_to val, #{obj_name} %>
       <% else %>
-        <td>
         <%= val %>
       <% end %>
       </td>
@@ -134,13 +139,11 @@ module Brick
   <% end %>
 </table>
 
-<%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>
+#{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
 "
-                  # "<%= @#{@_brick_model.name.underscore.pluralize}.inspect %>"
                 when 'show'
                   "<%= @#{@_brick_model.name.underscore}.inspect %>"
                 end
-puts inline
                 # 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')
@@ -152,7 +155,7 @@ puts inline
           end
         end
 
-        if (::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true))
+        if ::Brick.enable_routes?
           ActionDispatch::Routing::RouteSet.class_exec do
             alias _brick_finalize_routeset! finalize!
             def finalize!(*args, **options)
@@ -161,8 +164,7 @@ puts inline
                 ::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|
+                  ::Brick.relations.each do |k, v|
                     unless existing_controllers.key?(controller_name = k.underscore.pluralize)
                       options = {}
                       options[:only] = [:index, :show] if v.key?(:isView)
@@ -176,20 +178,8 @@ puts inline
           end
         end
 
-        # Do not consider database views when auto-creating models
-        ::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)
-        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)
+        if (ars = ::Brick.config.additional_references)
           ars.each do |fk|
             ::Brick._add_bt_and_hm(fk[0..2])
           end
@@ -201,7 +191,7 @@ puts inline
           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?
+          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

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -76,7 +76,10 @@ end
 # is first established), and then automatically creates models, controllers, views,
 # and routes based on those available relations.
 require 'brick/config'
-require 'brick/frameworks/rails'
+if Gem::Specification.all_names.any? { |g| g.start_with?('rails-') }
+  require 'rails'
+  require 'brick/frameworks/rails'
+end
 module Brick
   class << self
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
@@ -87,6 +90,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
+          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)
@@ -156,8 +183,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 has 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
 
 
@@ -197,10 +244,7 @@ module Brick
   end
 end
 
-require 'brick/extensions'
 require 'brick/version_number'
-# require 'brick/serializers/json'
-# require 'brick/serializers/yaml'
 
 require 'active_record'
 # Major compatibility fixes for ActiveRecord < 4.2
@@ -426,18 +470,18 @@ ActiveSupport.on_load(:active_record) do
     end
   end
 
-  include ::Brick::Extensions
-
-  unless ::Brick::Extensions::IS_AMOEBA
-    # Add amoeba-compatible support
-    module ActiveRecord
-      class Base
-        def self.amoeba(*args)
-          puts "Amoeba called from #{name} with #{args.inspect}"
-        end
-      end
-    end
-  end
+  # include ::Brick::Extensions
+
+  # unless ::Brick::Extensions::IS_AMOEBA
+  #   # Add amoeba-compatible support
+  #   module ActiveRecord
+  #     class Base
+  #       def self.amoeba(*args)
+  #         puts "Amoeba called from #{name} with #{args.inspect}"
+  #       end
+  #     end
+  #   end
+  # end
 end
 
 # Do this earlier because stuff here gets mixed into JoinDependency::JoinAssociation and AssociationScope
@@ -526,3 +570,5 @@ if ActiveRecord.version < ::Gem::Version.new('5.2')
   end # module ActiveRecord
   # rubocop:enable Style/CommentedKeyword
 end
+
+require 'brick/extensions'

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.2
+  version: 1.0.5
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-13 00:00:00.000000000 Z
+date: 2022-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -156,6 +156,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.42.0
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement