brick 1.0.69 → 1.0.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7399b8731b349e5c2a053956c5e6aa9998eb5a2010b5a0e7c081e87f9cac843e
-  data.tar.gz: bc3f65bb32230c05c63f7ef585a825de315ce2979d03b8db6efc6df0d0a5c143
+  metadata.gz: e50dce8dd2821ec196836393569138d4e18c53a9ef1e3e910ddffa6bc3788824
+  data.tar.gz: 982b26f7ed3a14f69589b6c422b37a5ec42b210c095cf85ef0eeab151ea80c59
 SHA512:
-  metadata.gz: b8681ca78d035e6c727fcb6b60d17a5658841bb28e8a4f3dd7405563d5c7cb3e9739984cfe09ce741fd70d5334b949b786e929a1ce4232cf77568621c2813c9d
-  data.tar.gz: 39a9586ea23107b66ab3d461e93eed2defc459231b26d4b25961a7e2e4df9b04167ff620ac570ad07040681e19ad6b313969e822d6fdd8b492b5f4c1fded4c1c
+  metadata.gz: 2c0e76b3e092d35f57045f3dd106ae9b8c90b266df0a7c0c973824ed20c1ac41560f124420d164e4e9d170b9a386345f424f19bce01bf041c9ebb553c842e553
+  data.tar.gz: 6d257bbec4c364456be5167b55c2eb377d94cdd0485e56dfb699daf14f3dce7a46c94c91534ecbe9c8f090b564e8752de0c3b88cf7560e01ca9d8388a3ec9930

data/lib/brick/extensions.rb

@@ -99,13 +99,14 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false)
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, emit_dsl = false, is_polymorphic = false)
       build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
       build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
       members = []
       bracket_name = nil
       prefix = [prefix] unless prefix.is_a?(Array)
       if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        dsl2 = +''
         klass = nil
         dsl.each_char do |ch|
           if bracket_name
@@ -125,7 +126,15 @@ module ActiveRecord
                 end
                 translations[parts[0..-2].join('.')] = klass
               end
-              members << parts
+              if klass.column_names.exclude?(parts.last) &&
+                 (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
+                members += members2
+                dsl2 << dsl2a
+              else
+                dsl2 << "[#{bracket_name}]"
+                members << parts
+              end
               bracket_name = nil
             else
               bracket_name << ch
@@ -133,13 +142,20 @@ module ActiveRecord
           elsif ch == '['
             bracket_name = +''
             klass = self
+          else
+            dsl2 << ch
           end
         end
+        # Rewrite the DSL just in case it's different because we had to expand it
+        unless emit_dsl
+          # puts "Compare:\n  #{dsl}\n  #{dsl2}"
+          ::Brick.config.model_descrips[name] = dsl2
+        end
       else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
         x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
         x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
-      members
+      emit_dsl ? [members, dsl2] : members
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -169,9 +185,12 @@ module ActiveRecord
                           this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
                           break if this_obj.nil?
                         end
+                        if this_obj.is_a?(ActiveRecord::Base) && (obj_descrip = this_obj.class.brick_descrip(this_obj))
+                          this_obj = obj_descrip
+                        end
                         this_obj&.to_s || ''
                       end
-              is_brackets_have_content = true unless (datum).blank?
+              is_brackets_have_content = true unless datum.blank?
               output << (datum || '')
               bracket_name = nil
             else
@@ -244,7 +263,8 @@ module ActiveRecord
 
         # join_array will receive this relation name when calling #brick_parse_dsl
         _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
+                                     # Last two params here:  "false" is for don't emit DSL, and "true" is for yes, we are polymorphic
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, false, true) }
                                    else
                                      { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
                                    end
@@ -384,6 +404,7 @@ module ActiveRecord
     def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+      is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
@@ -408,15 +429,37 @@ module ActiveRecord
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         columns.each do |col|
-          col_alias = " AS _#{col.name}" if (col_name = col.name) == 'class'
+          if (col_name = col.name) == 'class'
+            col_alias = " AS #{col.name}_"
+          else
+            alias_name = nil
+            idx = 0
+            col_name.each_char do |c|
+              unless (c >= 'a' && c <= 'z') ||
+                 c == '_' ||
+                 (c >= 'A' && c <= 'Z') ||
+                 (c >= '0' && c <= '9')
+                (alias_name ||= col_name.dup)[idx] = 'x'
+              end
+              ++idx
+            end
+            col_alias = " AS #{alias_name}" if alias_name
+          end
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
-                     elsif is_postgres
+                     elsif is_postgres || is_mssql
                        # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
-                       cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col.name)&.first&.start_with?('xml')
+                       cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col_name)&.first&.start_with?('xml')
                        "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
-                     else # Sqlite or Oracle
-                       "#{tbl_no_schema}.#{col_name}#{col_alias}"
+                     elsif col.type # Could be Sqlite or Oracle
+                       if col_alias
+                         "#{tbl_no_schema}.#{col_name}#{col_alias}"
+                       else
+                         "#{tbl_no_schema}.#{col_name}"
+                       end
+                     else # Oracle with a custom data type
+                       typ = col.sql_type
+                       "'<#{typ.end_with?('_TYP') ? typ[0..-5] : typ}>' AS #{col.name}"
                      end
         end
       end
@@ -449,6 +492,8 @@ module ActiveRecord
                            "`#{field_tbl_name}`.`#{sel_col.last}` AS `#{col_alias}`"
                          elsif is_postgres
                            "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+                         elsif is_mssql
+                           "\"#{field_tbl_name}\".\"#{sel_col.last}\" AS \"#{col_alias}\""
                          else
                            "#{field_tbl_name}.#{sel_col.last} AS \"#{col_alias}\""
                          end
@@ -462,7 +507,7 @@ module ActiveRecord
                 id_for_tables[v.first] << if id_part
                                             selects << if is_mysql
                                                          "#{"`#{tbl_name}`.`#{id_part}`"} AS `#{(id_alias = "br_fk_#{v.first}__#{id_part}")}`"
-                                                       elsif is_postgres
+                                                       elsif is_postgres || is_mssql
                                                          "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "br_fk_#{v.first}__#{id_part}")}\""
                                                        else
                                                          "#{"#{tbl_name}.#{id_part}"} AS \"#{(id_alias = "br_fk_#{v.first}__#{id_part}")}\""
@@ -506,7 +551,7 @@ module ActiveRecord
         pri_tbl_name = is_mysql ? "`#{pri_tbl.table_name}`" : "\"#{pri_tbl.table_name.gsub('.', '"."')}\""
         pri_tbl_name = if is_mysql
                          "`#{pri_tbl.table_name}`"
-                       elsif is_postgres
+                       elsif is_postgres || is_mssql
                          "\"#{pri_tbl.table_name.gsub('.', '"."')}\""
                        else
                          pri_tbl.table_name
@@ -525,12 +570,12 @@ module ActiveRecord
         end
         hm_table_name = if is_mysql
                           "`#{associative&.table_name || hm.klass.table_name}`"
-                        elsif is_postgres
+                        elsif is_postgres || is_mssql
                           "\"#{(associative&.table_name || hm.klass.table_name).gsub('.', '"."')}\""
                         else
                           associative&.table_name || hm.klass.table_name
                         end
-        group_bys = ::Brick.is_oracle ? selects : (1..selects.length).to_a
+        group_bys = ::Brick.is_oracle || is_mssql ? selects : (1..selects.length).to_a
         join_clause = "LEFT OUTER
 JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
           }) AS c_t_ FROM #{hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
@@ -661,7 +706,7 @@ Module.class_exec do
        )
       return possible
     end
-    class_name = args.first.to_s
+    class_name = ::Brick.namify(args.first.to_s)
     # self.name is nil when a model name is requested in an .erb file
     base_module = (self < ActiveRecord::Migration || !self.name) ? Object : self
     # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
@@ -773,7 +818,7 @@ class Object
           schema_name = Apartment.default_schema
         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?(schema_name ? "#{schema_name}.#{m}" : m) })
+        if (matching = [table_name, singular_table_name, plural_class_name, model_name, table_name.titleize].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
           build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
         end
       end
@@ -1340,7 +1385,7 @@ class Object
         # hm_assoc[:assoc_name] = new_alt_name
         [new_alt_name, true]
       else
-        assoc_name = hm_assoc[:inverse_table].pluralize
+        assoc_name = ::Brick.namify(hm_assoc[:inverse_table]).pluralize
         # hm_assoc[:assoc_name] = assoc_name
         [assoc_name, assoc_name.include?('.')]
       end
@@ -1383,12 +1428,20 @@ module ActiveRecord::ConnectionHandling
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
       is_postgres = nil
+      is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
       case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL'
-        is_postgres = true
+      when 'PostgreSQL', 'SQLServer'
+        is_postgres = !is_mssql
         db_schemas = ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;')
         ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
-          row = row.is_a?(String) ? row : row['table_schema']
+          row = case row
+                when String
+                  row
+                when Array
+                  row.first
+                else
+                  row['table_schema']
+                end
           # Remove any system schemas
           s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
         end
@@ -1404,7 +1457,7 @@ module ActiveRecord::ConnectionHandling
         # ActiveRecord::Base.connection.current_database will be something like "XEPDB1"
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.raw_connection.username
         ::Brick.db_schemas = {}
-        execute_oracle("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
+        ActiveRecord::Base.execute_sql("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
       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,
@@ -1437,7 +1490,7 @@ module ActiveRecord::ConnectionHandling
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
         # schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        ActiveRecord::Base.retrieve_schema_and_tables(sql, is_postgres, schema).each do |r|
+        ActiveRecord::Base.retrieve_schema_and_tables(sql, is_postgres, is_mssql, schema).each do |r|
           # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
           # is the default schema, usually 'public'.
           schema_name = if ::Brick.config.schema_behavior[:multitenant]
@@ -1464,10 +1517,12 @@ module ActiveRecord::ConnectionHandling
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
         end
       else # MySQL2 and OracleEnhanced act a little differently, bringing back an array for each row
-        schema_and_tables = if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
+        schema_and_tables = case ActiveRecord::Base.connection.adapter_name
+                            when 'OracleEnhanced'
                               sql =
-"SELECT c.owner AS schema, c.table_name AS relation_name, 'BASE_TABLE' AS table_type,
-  LOWER(c.column_name) AS column_name, c.data_type,
+"SELECT c.owner AS schema, c.table_name AS relation_name,
+  CASE WHEN v.owner IS NULL THEN 'BASE_TABLE' ELSE 'VIEW' END AS table_type,
+  c.column_name, c.data_type,
   COALESCE(c.data_length, c.data_precision) AS max_length,
   CASE ac.constraint_type WHEN 'P' THEN 'PRIMARY KEY' END AS const,
   ac.constraint_name AS \"key\",
@@ -1475,9 +1530,11 @@ module ActiveRecord::ConnectionHandling
 FROM all_tab_cols c
   LEFT OUTER JOIN all_cons_columns acc ON acc.owner = c.owner AND acc.table_name = c.table_name AND acc.column_name = c.column_name
   LEFT OUTER JOIN all_constraints ac ON ac.owner = acc.owner AND ac.table_name = acc.table_name AND ac.constraint_name = acc.constraint_name AND constraint_type = 'P'
+  LEFT OUTER JOIN all_views v ON c.owner = v.owner AND c.table_name = v.view_name
 WHERE c.owner IN (#{::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')})
+  AND c.table_name NOT IN (?, ?)
 ORDER BY 1, 2, c.internal_column_id, acc.position"
-                              execute_oracle(sql, *ar_tables)
+                              ActiveRecord::Base.execute_sql(sql, *ar_tables)
                             else
                               ActiveRecord::Base.retrieve_schema_and_tables(sql)
                             end
@@ -1527,9 +1584,9 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       # end
       # schema = ::Brick.default_schema # Reset back for this next round of fun
       case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL', 'Mysql2'
+      when 'PostgreSQL', 'Mysql2', 'SQLServer'
         sql = "SELECT kcu1.CONSTRAINT_SCHEMA, kcu1.TABLE_NAME, kcu1.COLUMN_NAME,
-                  kcu2.CONSTRAINT_SCHEMA AS primary_schema, kcu2.TABLE_NAME AS primary_table, kcu1.CONSTRAINT_NAME AS CONSTRAINT_SCHEMA_FK
+            kcu2.CONSTRAINT_SCHEMA AS primary_schema, kcu2.TABLE_NAME AS primary_table, kcu1.CONSTRAINT_NAME AS CONSTRAINT_SCHEMA_FK
           FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
             INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
               ON kcu1.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
@@ -1540,7 +1597,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
               AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
               AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME#{"
               AND kcu2.TABLE_NAME = kcu1.REFERENCED_TABLE_NAME
-              AND kcu2.COLUMN_NAME = kcu1.REFERENCED_COLUMN_NAME" unless is_postgres }
+              AND kcu2.COLUMN_NAME = kcu1.REFERENCED_COLUMN_NAME" unless is_postgres || is_mssql }
               AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION#{"
           WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
           # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
@@ -1567,16 +1624,14 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         WHERE ac.constraint_type = 'R'
           AND ac.owner IN (#{schemas})
           AND ac.r_owner IN (#{schemas})"
-        fk_references = ActiveRecord::Base.execute_oracle(sql)
-      else
-        binding.pry
+        fk_references = ActiveRecord::Base.execute_sql(sql)
       end
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       fk_references&.each do |fk|
         fk = fk.values unless fk.is_a?(Array)
         # Multitenancy makes things a little more general overall, except for non-tenanted tables
-        if apartment_excluded&.include?(fk[1].singularize.camelize)
+        if apartment_excluded&.include?(::Brick.namify(fk[1]).singularize.camelize)
           fk[0] = Apartment.default_schema
         elsif is_postgres && (fk[0] == 'public' || (is_multitenant && fk[0] == schema)) ||
               !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[0])
@@ -1621,29 +1676,35 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     ::Brick.load_additional_references if initializer_loaded
   end
 
-  def retrieve_schema_and_tables(sql = nil, is_postgres = nil, schema = nil)
+  def retrieve_schema_and_tables(sql = nil, is_postgres = nil, is_mssql = nil, schema = nil)
+    is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer' if is_mssql.nil?
     sql ||= "SELECT t.table_schema AS \"schema\", t.table_name AS relation_name, t.table_type,#{"
       pg_catalog.obj_description(
         ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass, 'pg_class'
       ) AS table_description," if is_postgres}
       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\",
+      kcu.constraint_type AS const, kcu.constraint_name AS \"key\",
       c.is_nullable
     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
-      LEFT OUTER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu ON
-        -- ON kcu.CONSTRAINT_CATALOG = t.table_catalog AND
+        LEFT OUTER JOIN
+        (SELECT kcu1.constraint_schema, kcu1.table_name, kcu1.ordinal_position,
+        tc.constraint_type, kcu1.constraint_name
+        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
+        INNER JOIN INFORMATION_SCHEMA.table_constraints AS tc
+          ON kcu1.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+          AND kcu1.TABLE_NAME = tc.TABLE_NAME
+          AND kcu1.CONSTRAINT_NAME = tc.constraint_name
+          AND tc.constraint_type != 'FOREIGN KEY' -- For MSSQL
+        ) AS kcu ON
+        -- kcu.CONSTRAINT_CATALOG = t.table_catalog AND
         kcu.CONSTRAINT_SCHEMA = c.table_schema
-        AND kcu.TABLE_NAME = c.table_name
-        AND kcu.position_in_unique_constraint IS NULL
+        AND kcu.TABLE_NAME = c.table_name#{"
+    --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}
         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 #{is_postgres ?
+    WHERE t.table_schema #{is_postgres || is_mssql ?
         "NOT IN ('information_schema', 'pg_catalog')"
         :
         "= '#{ActiveRecord::Base.connection.current_database.tr("'", "''")}'"}#{"
@@ -1663,16 +1724,6 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
     [ar_smtn, ar_imtn]
   end
-
-  def execute_oracle(*sql_args)
-    cursor = ActiveRecord::Base.execute_sql(*sql_args)
-    result = []
-    while row = cursor.fetch()
-      result << row
-    end
-    cursor.close
-    result
-  end
 end
 
 # ==========================================
@@ -1699,22 +1750,23 @@ module Brick
 
   class << self
     def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
-      bt_assoc_name = fk[2]
+      bt_assoc_name = ::Brick.namify(fk[2])
       unless is_polymorphic
         bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
-                          bt_assoc_name[0..-4]
+                          bt_assoc_name[-3] == '_' ? bt_assoc_name[0..-4] : bt_assoc_name[0..-3]
                         elsif bt_assoc_name.downcase.end_with?('id') && bt_assoc_name.exclude?('_')
                           bt_assoc_name[0..-3] # Make the bold assumption that we can just peel off any final ID part
                         else
                           "#{bt_assoc_name}_bt"
                         end
       end
-      bt_assoc_name = "_#{bt_assoc_name}" if bt_assoc_name == 'attribute'
+      bt_assoc_name = "#{bt_assoc_name}_" if bt_assoc_name == 'attribute'
 
       # %%% Temporary schema patch
       for_tbl = fk[1]
+      fk_namified = ::Brick.namify(fk[1])
       apartment = Object.const_defined?('Apartment') && Apartment
-      fk[0] = Apartment.default_schema if apartment && apartment.excluded_models.include?(for_tbl.singularize.camelize)
+      fk[0] = Apartment.default_schema if apartment && apartment.excluded_models.include?(fk_namified.singularize.camelize)
       fk[1] = "#{fk[0]}.#{fk[1]}" if fk[0] # && fk[0] != ::Brick.default_schema
       bts = (relation = relations.fetch(fk[1], nil))&.fetch(:fks) { relation[:fks] = {} }
 
@@ -1813,7 +1865,7 @@ module Brick
                   else
                     fk[1]
                   end
-        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: for_tbl.pluralize, alternate_name: bt_assoc_name,
+        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: fk_namified.pluralize, alternate_name: bt_assoc_name,
                                           inverse_table: inv_tbl, inverse: assoc_bt }
         assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }

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

@@ -49,8 +49,10 @@ module Brick
       # After we're initialized and before running the rest of stuff, put our configuration in place
       ActiveSupport.on_load(:after_initialize) do |app|
         assets_path = File.expand_path("#{__dir__}/../../../../vendor/assets")
-        (app.config.assets.precompile ||= []) << "#{assets_path}/images/brick_erd.png"
-        (app.config.assets.paths ||= []) << assets_path
+        if (app_config = app.config).respond_to?(:assets)
+          (app_config.assets.precompile ||= []) << "#{assets_path}/images/brick_erd.png"
+          (app.config.assets.paths ||= []) << assets_path
+        end
         # ====================================
         # Dynamically create generic templates
         # ====================================
@@ -565,7 +567,7 @@ erDiagram
      end %>
 <% end
    def dt_lookup(dt)
-     { 'integer' => 'int', }[dt] || dt.tr(' ', '_')
+     { 'integer' => 'int', }[dt] || dt&.tr(' ', '_') || 'int'
    end
    callbacks.merge({model_short_name => #{@_brick_model.name}}).each do |cb_k, cb_class|
      cb_relation = ::Brick.relations[cb_class.table_name]
@@ -581,8 +583,9 @@ erDiagram
          fk.each do |fk_part| %>
     <%= \"#\{dt_lookup(cols[fk_part].first)} #\{fk_part} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk_part) %><%
          end
-       else %>
-    <%= \"#\{dt_lookup(cols[fk].first)} #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk) %><%
+       else # %%% Does not yet accommodate polymorphic BTs
+    %>
+    <%= \"#\{dt_lookup(cols[fk]&.first)} #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk) %><%
        end
      end %>
   }
@@ -1087,9 +1090,9 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
       mermaid.initialize({
         startOnLoad: true,
         securityLevel: \"loose\",
+        er: { useMaxWidth: false },
         mermaid: {callback: function(objId) {
           var svg = document.getElementById(objId);
-          svg.removeAttribute(\"width\");
           var cb;
           for(cb in cbs) {
             var gErd = svg.getElementById(cb);

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -151,6 +151,20 @@ module Brick
       @pending_models ||= {}
     end
 
+    # Convert spaces to underscores if the second character and onwards is mixed case
+    def namify(name)
+      if name.include?(' ')
+        # All uppers or all lowers?
+        if name[1..-1] =~ /^[A-Z0-9_]+$/ || name[1..-1] =~ /^[a-z0-9_]+$/
+          name.titleize.tr(' ', '_')
+        else # Mixed uppers and lowers -- just remove existing spaces
+          name.tr(' ', '')
+        end
+      else
+        name
+      end
+    end
+
     def get_bts_and_hms(model)
       bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
         next if !const_defined?(a.name.to_s.singularize.camelize) && ::Brick.config.exclude_tables.include?(a.plural_name)
@@ -469,9 +483,10 @@ In config/initializers/brick.rb appropriate entries would look something like:
         # %%% 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 |rel_name, v|
-          rel_name = rel_name.split('.').map(&:underscore)
+          rel_name = rel_name.split('.').map { |x| ::Brick.namify(x).underscore }
           schema_names = rel_name[0..-2]
           schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
+          # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
           k = rel_name.last
           unless existing_controllers.key?(controller_name = k.pluralize)
             options = {}
@@ -545,7 +560,11 @@ ActiveSupport.on_load(:active_record) do
         class << self
           def execute_sql(sql, *param_array)
             param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
-            connection.execute(send(:sanitize_sql_array, [sql] + param_array))
+            if ['OracleEnhanced', 'SQLServer'].include?(ActiveRecord::Base.connection.adapter_name)
+              connection.exec_query(send(:sanitize_sql_array, [sql] + param_array)).rows
+            else
+              connection.execute(send(:sanitize_sql_array, [sql] + param_array))
+            end
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.69
+  version: 1.0.71
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-12 00:00:00.000000000 Z
+date: 2022-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: fancy_gets
   requirement: !ruby/object:Gem::Requirement
@@ -264,5 +264,5 @@ requirements: []
 rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
-summary: Import and Export Data
+summary: Create a Rails app from data alone
 test_files: []