brick 1.0.66 → 1.0.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7e8235e9e499424e41a8329f9056b4ab801fd7502889dfdafc527522f061ad3
-  data.tar.gz: 898b3f172cb9eb6594b382087394857d7ff471a833069bfe7e060f404bfd2d4c
+  metadata.gz: 7399b8731b349e5c2a053956c5e6aa9998eb5a2010b5a0e7c081e87f9cac843e
+  data.tar.gz: bc3f65bb32230c05c63f7ef585a825de315ce2979d03b8db6efc6df0d0a5c143
 SHA512:
-  metadata.gz: 0d0b88ac19a60e25ee48074e5ee67037c41d77b80a54ea22ad1813d22d4e3d233d253ed92a39e317f3faa86aac290ee51e0bed7ab178c583ca1d06b075bfaac1
-  data.tar.gz: a0d8f7683236868789c9262a08a8c615786afdd6ad93b1f330807d5acad5962ea2e2ea645a236e37926b42bfd09db00ec9d00fae15de90da8fe589bfbe493b65
+  metadata.gz: b8681ca78d035e6c727fcb6b60d17a5658841bb28e8a4f3dd7405563d5c7cb3e9739984cfe09ce741fd70d5334b949b786e929a1ce4232cf77568621c2813c9d
+  data.tar.gz: 39a9586ea23107b66ab3d461e93eed2defc459231b26d4b25961a7e2e4df9b04167ff620ac570ad07040681e19ad6b313969e822d6fdd8b492b5f4c1fded4c1c

data/lib/brick/extensions.rb

@@ -266,18 +266,27 @@ module ActiveRecord
       quoted_table_name = table_name.split('.').map { |x| "\"#{x}\"" }.join('.')
       order_by_txt = [] if is_do_txt
       ordering = [ordering] if ordering && !ordering.is_a?(Array)
-      order_by = ordering&.map do |ord_part| # %%% If a term is also used as an eqi-condition in the WHERE clause, it can be omitted from ORDER BY
+      order_by = ordering&.each_with_object([]) do |ord_part, s| # %%% If a term is also used as an eqi-condition in the WHERE clause, it can be omitted from ORDER BY
                    case ord_part
                    when String
                      ord_expr = ord_part.gsub('^^^', quoted_table_name)
                      order_by_txt&.<<("Arel.sql(#{ord_expr})")
-                     Arel.sql(ord_expr)
+                     s << Arel.sql(ord_expr)
                    else # Expecting only Symbol
-                     ord_part = "_br_#{ord_part}_ct" if _br_hm_counts.key?(ord_part)
-                     # Retain any reference to a bt_descrip as being a symbol
-                     # Was:  "#{quoted_table_name}.\"#{ord_part}\""
-                     order_by_txt&.<<(_br_bt_descrip.key?(ord_part) ? ord_part : ord_part.inspect)
-                     ord_part
+                     if _br_hm_counts.key?(ord_part)
+                       ord_part = "\"b_r_#{ord_part}_ct\""
+                     elsif !_br_bt_descrip.key?(ord_part) && !column_names.include?(ord_part.to_s)
+                       # Disallow ordering by a bogus column
+                       # %%% Note this bogus entry so that Javascript can remove any bogus _brick_order
+                       # parameter from the querystring, pushing it into the browser history.
+                       ord_part = nil
+                     end
+                     if ord_part
+                       # Retain any reference to a bt_descrip as being a symbol
+                       # Was:  "#{quoted_table_name}.\"#{ord_part}\""
+                       order_by_txt&.<<(_br_bt_descrip.key?(ord_part) ? ord_part : ord_part.inspect)
+                       s << ord_part
+                     end
                    end
                  end
       [order_by, order_by_txt]
@@ -373,6 +382,7 @@ module ActiveRecord
     end
 
     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_distinct = nil
       wheres = {}
@@ -401,10 +411,12 @@ module ActiveRecord
           col_alias = " AS _#{col.name}" if (col_name = col.name) == 'class'
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
-                     else
+                     elsif is_postgres
                        # 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')
                        "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
+                     else # Sqlite or Oracle
+                       "#{tbl_no_schema}.#{col_name}#{col_alias}"
                      end
         end
       end
@@ -430,13 +442,15 @@ module ActiveRecord
               # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
               is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
               # If it's not unique then also include the belongs_to association name before the column name
-              if used_col_aliases.key?(col_alias = "_brfk_#{v.first}__#{sel_col.last}")
-                col_alias = "_brfk_#{v.first}__#{v1[idx][-2..-1].map(&:to_s).join('__')}"
+              if used_col_aliases.key?(col_alias = "br_fk_#{v.first}__#{sel_col.last}")
+                col_alias = "br_fk_#{v.first}__#{v1[idx][-2..-1].map(&:to_s).join('__')}"
               end
               selects << if is_mysql
                            "`#{field_tbl_name}`.`#{sel_col.last}` AS `#{col_alias}`"
-                         else
+                         elsif is_postgres
                            "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+                         else
+                           "#{field_tbl_name}.#{sel_col.last} AS \"#{col_alias}\""
                          end
               used_col_aliases[col_alias] = nil
               v1[idx] << col_alias
@@ -447,9 +461,11 @@ module ActiveRecord
               ((id_col = k1.primary_key).is_a?(Array) ? id_col : [id_col]).each do |id_part|
                 id_for_tables[v.first] << if id_part
                                             selects << if is_mysql
-                                                         "#{"`#{tbl_name}`.`#{id_part}`"} AS `#{(id_alias = "_brfk_#{v.first}__#{id_part}")}`"
+                                                         "#{"`#{tbl_name}`.`#{id_part}`"} AS `#{(id_alias = "br_fk_#{v.first}__#{id_part}")}`"
+                                                       elsif is_postgres
+                                                         "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "br_fk_#{v.first}__#{id_part}")}\""
                                                        else
-                                                         "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+                                                         "#{"#{tbl_name}.#{id_part}"} AS \"#{(id_alias = "br_fk_#{v.first}__#{id_part}")}\""
                                                        end
                                             id_alias
                                           end
@@ -479,9 +495,22 @@ module ActiveRecord
                        end
         next unless count_column # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
 
-        tbl_alias = is_mysql ? "`_br_#{hm.name}`" : "\"_br_#{hm.name}\""
+        tbl_alias = if is_mysql
+                      "`b_r_#{hm.name}`"
+                    elsif is_postgres
+                      "\"b_r_#{hm.name}\""
+                    else
+                      "b_r_#{hm.name}"
+                    end
         pri_tbl = hm.active_record
         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
+                         "\"#{pri_tbl.table_name.gsub('.', '"."')}\""
+                       else
+                         pri_tbl.table_name
+                       end
         on_clause = []
         if fk_col.is_a?(Array) # Composite key?
           fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl_name}.#{pri_tbl.primary_key[idx]}" }
@@ -494,22 +523,29 @@ module ActiveRecord
           selects << poly_type
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
-        hm_table_name = is_mysql ? "`#{associative&.table_name || hm.klass.table_name}`" : "\"#{(associative&.table_name || hm.klass.table_name).gsub('.', '"."')}\""
+        hm_table_name = if is_mysql
+                          "`#{associative&.table_name || hm.klass.table_name}`"
+                        elsif is_postgres
+                          "\"#{(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
         join_clause = "LEFT OUTER
 JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
-          }) AS _ct_ FROM #{hm_table_name} GROUP BY #{(1..selects.length).to_a.join(', ')}) AS #{tbl_alias}"
+          }) AS c_t_ FROM #{hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
       where!(wheres) unless wheres.empty?
       # Must parse the order_by and see if there are any symbols which refer to BT associations
-      # as they must be expanded to find the corresponding _br_model__column naming for each.
+      # as they must be expanded to find the corresponding b_r_model__column naming for each.
       if order_by.present?
         final_order_by = *order_by.each_with_object([]) do |v, s|
           if v.is_a?(Symbol)
             # Add the ordered series of columns derived from the BT based on its DSL
             if (bt_cols = klass._br_bt_descrip[v])
               bt_cols.values.each do |v1|
-                v1.each { |v2| s << v2.last if v2.length > 1 }
+                v1.each { |v2| s << "\"#{v2.last}\"" if v2.length > 1 }
               end
             else
               s << v
@@ -657,9 +693,12 @@ Module.class_exec do
                full_class_name = +''
                full_class_name << "::#{self.name}" unless self == Object
                full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
-               if (plural_class_name == 'BrickSwagger' ||
-                  ((::Brick.config.add_status || ::Brick.config.add_orphans) && plural_class_name == 'BrickGem') ||
-                  model = self.const_get(full_class_name))
+               if plural_class_name == 'BrickSwagger' ||
+                  (
+                    (::Brick.config.add_status || ::Brick.config.add_orphans) &&
+                    plural_class_name == 'BrickGem'
+                  ) ||
+                  model = self.const_get(full_class_name)
                  # 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.
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
@@ -1017,6 +1056,7 @@ class Object
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
+      is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
 
       namespace_name = "#{namespace.name}::" if namespace
@@ -1033,7 +1073,7 @@ class Object
           self.define_method :orphans do
             instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params)))
           end
-          return [new_controller_class, code + ' # BrickGem controller']
+          return [new_controller_class, code + "end # BrickGem controller\n"]
         when 'BrickSwagger'
           is_swagger = true # if request.format == :json)
         end
@@ -1122,7 +1162,13 @@ class Object
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
           counts = model._br_hm_counts.each_with_object([]) do |v, s|
-            s << (is_mysql ? "`_br_#{v.first}`._ct_ AS \"_br_#{v.first}_ct\"" : "\"_br_#{v.first}\"._ct_ AS \"_br_#{v.first}_ct\"")
+            s << if is_mysql
+                   "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
+                 elsif is_postgres
+                   "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
+                 else
+                   "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
+                 end
           end
           instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
           if namespace && (idx = lookup_context.prefixes.index(table_name))
@@ -1193,6 +1239,8 @@ class Object
             else
               instance_variable_set("@#{singular_table_name}".to_sym,
                                     model.send(:create, send(params_name_sym)))
+              index
+              render :index
             end
           end
 
@@ -1352,15 +1400,18 @@ module ActiveRecord::ConnectionHandling
         end
       when 'Mysql2'
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
+      when 'OracleEnhanced'
+        # 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 }
       when 'SQLite'
-        # %%% Retrieve internal ActiveRecord table names like this:
-        # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
         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 (?, ?)
+        WHERE m.name NOT IN ('sqlite_sequence', ?, ?)
         ORDER BY m.name, p.cid"
       else
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
@@ -1412,9 +1463,31 @@ module ActiveRecord::ConnectionHandling
           cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name), r['is_nullable'] == 'NO']
           # 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.retrieve_schema_and_tables(sql).each do |r|
-          relation = relations[(relation_name = r[1])] # here relation represents a table or view from the database
+      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'
+                              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,
+  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\",
+  CASE c.nullable WHEN 'Y' THEN 'YES' ELSE 'NO' END AS is_nullable
+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'
+WHERE c.owner IN (#{::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')})
+ORDER BY 1, 2, c.internal_column_id, acc.position"
+                              execute_oracle(sql, *ar_tables)
+                            else
+                              ActiveRecord::Base.retrieve_schema_and_tables(sql)
+                            end
+        schema_and_tables.each do |r|
+          next if r[1].index('$') # Oracle can have goofy table names with $
+
+          if (relation_name = r[1]) =~ /^[A-Z_]+$/
+            relation_name.downcase!
+          end
+          relation = relations[relation_name] # here relation represents a table or view from the database
           relation[:isView] = true if r[2] == 'VIEW' # table_type
           col_name = r[3]
           key = case r[6] # constraint type
@@ -1471,32 +1544,53 @@ module ActiveRecord::ConnectionHandling
               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
+        fk_references = ActiveRecord::Base.execute_sql(sql)
       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"
+        fk_references = ActiveRecord::Base.execute_sql(sql)
+      when 'OracleEnhanced'
+        schemas = ::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')
+        sql =
+        "SELECT -- fk
+               ac.owner AS constraint_schema, acc_fk.table_name, LOWER(acc_fk.column_name),
+               -- referenced pk
+               ac.r_owner AS primary_schema, acc_pk.table_name AS primary_table, acc_fk.constraint_name AS constraint_schema_fk
+               -- , LOWER(acc_pk.column_name)
+        FROM all_cons_columns acc_fk
+          INNER JOIN all_constraints ac ON acc_fk.owner = ac.owner
+            AND acc_fk.constraint_name = ac.constraint_name
+          INNER JOIN all_cons_columns acc_pk ON ac.r_owner = acc_pk.owner
+            AND ac.r_constraint_name = acc_pk.constraint_name
+        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
       end
-      if sql
-        # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        ActiveRecord::Base.execute_sql(sql).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)
-            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])
-            fk[0] = nil
-          end
-          if apartment_excluded&.include?(fk[4].singularize.camelize)
-            fk[3] = Apartment.default_schema
-          elsif is_postgres && (fk[3] == 'public' || (is_multitenant && fk[3] == schema)) ||
-                !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[3])
-            fk[3] = nil
-          end
-          ::Brick._add_bt_and_hm(fk, relations)
+      ::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)
+          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])
+          fk[0] = nil
+        end
+        if apartment_excluded&.include?(fk[4].singularize.camelize)
+          fk[3] = Apartment.default_schema
+        elsif is_postgres && (fk[3] == 'public' || (is_multitenant && fk[3] == schema)) ||
+              !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[3])
+          fk[3] = nil
         end
+        fk[1].downcase! if ::Brick.is_oracle && fk[1] =~ /^[A-Z_]+$/
+        fk[4].downcase! if ::Brick.is_oracle && fk[4] =~ /^[A-Z_]+$/
+        ::Brick._add_bt_and_hm(fk, relations)
       end
     end
 
@@ -1557,13 +1651,27 @@ module ActiveRecord::ConnectionHandling
   --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
       AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
     ORDER BY 1, t.table_type DESC, 2, c.ordinal_position"
+    ActiveRecord::Base.execute_sql(sql, *ar_tables)
+  end
+
+  def ar_tables
     ar_smtn = if ActiveRecord::Base.respond_to?(:schema_migrations_table_name)
                 ActiveRecord::Base.schema_migrations_table_name
               else
                 'schema_migrations'
               end
     ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
-    ActiveRecord::Base.execute_sql(sql, ar_smtn, ar_imtn)
+    [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
 

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

@@ -96,16 +96,15 @@ module Brick
 
             alias :_brick_find_template :find_template
             def find_template(*args, **options)
-              unless (model_name = (
-                       @_brick_model ||
-                       (ActionView.version < ::Gem::Version.new('5.0') && args[1].is_a?(Array) ? set_brick_model(args) : nil)
-                     )&.name) ||
+              unless (model_name = @_brick_model&.name) ||
                      (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
-                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']])
+                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
+                     # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
+                     (model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name)
                 return _brick_find_template(*args, **options)
               end
 
-              unless is_status || is_orphans
+            if @_brick_model
                 pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
                 obj_name = model_name.split('::').last.underscore
                 path_obj_name = model_name.underscore.tr('/', '_')
@@ -146,7 +145,7 @@ module Brick
                                                  'nil'
                                                else
                                                  # Postgres column names are limited to 63 characters
-                                                 "#{obj_name}.#{"_br_#{assoc_name}_ct"[0..62]} || 0"
+                                                 "#{obj_name}.#{"b_r_#{assoc_name}_ct"[0..62]} || 0"
                                                end
                                      ", #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
                                    end
@@ -156,7 +155,7 @@ module Brick
                                  end
                     hm_entry << ']'
                     hms_columns << hm_entry
-                  when 'show', 'update'
+                  when 'show', 'new', 'update'
                     hm_stuff << if hm_fk_name
                                   "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
                                 else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
@@ -179,6 +178,7 @@ module Brick
                               end.keys.sort.each_with_object(+'') do |v, s|
                                 s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
                               end.html_safe
+              table_options << '<option value="brick_status">(Status)</option>'.html_safe if ::Brick.config.add_status
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
               css = +"<style>
 h1, h3 {
@@ -275,7 +275,7 @@ tr th, tr td {
   color: #80B8D2;
 }
 
-table.shadow tbody tr {
+table.shadow > tbody > tr {
   border-bottom: thin solid #dddddd;
 }
 
@@ -283,7 +283,7 @@ table tbody tr:nth-of-type(even) {
   background-color: #f3f3f3;
 }
 
-table.shadow tbody tr:last-of-type {
+table.shadow > tbody > tr:last-of-type {
   border-bottom: 2px solid #009879;
 }
 
@@ -300,14 +300,6 @@ a.big-arrow {
   font-size: 2.5em;
   text-decoration: none;
 }
-.wide-input {
-  display: block;
-  overflow: hidden;
-}
-.wide-input input[type=text] {
-  display: inline-block;
-  width: 90%;
-}
 .dimmed {
   background-color: #C0C0C0;
   text-align: center;
@@ -324,9 +316,6 @@ svg.revert {
   display: none;
   margin-left: 0.25em;
 }
-.wide-input > svg.revert {
-  float: right;
-}
 input+svg.revert {
   top: 0.5em;
 }
@@ -379,9 +368,10 @@ def display_value(col_type, val)
       '?'
     end
   end
-end %>"
+end
+callbacks = {} %>"
 
-              if ['index', 'show', 'update'].include?(args.first)
+              if ['index', 'show', 'new', 'update'].include?(args.first)
                 poly_cols = []
                 css << "<% bts = { #{
                   bt_items = bts.each_with_object([]) do |v, s|
@@ -537,17 +527,18 @@ if (headerTop) {
 }
 </script>"
 
-              erd_markup = "<div id=\"mermaidErd\" class=\"mermaid\">
+              erd_markup = if @_brick_model
+                             "<div id=\"mermaidErd\" class=\"mermaid\">
 erDiagram
 <% model_short_name = #{@_brick_model.name.split('::').last.inspect}
-   callbacks = {}
    @_brick_bt_descrip&.each do |bt|
      bt_class = bt[1].first.first
      callbacks[bt_name = bt_class.name.split('::').last] = bt_class
      is_has_one = #{@_brick_model.name}.reflect_on_association(bt.first).inverse_of&.macro == :has_one ||
                   ::Brick.config.has_ones&.fetch('#{@_brick_model.name}', nil)&.key?(bt.first.to_s)
     %>  <%= \"#\{model_short_name} #\{is_has_one ? '||' : '}o'}--|| #\{bt_name} : \\\"#\{
-        bt.first unless bt.first.to_s == bt[1].first.first.name.underscore.singularize.tr('/', '_')
+        bt_underscored = bt[1].first.first.name.underscore.singularize
+        bt.first unless bt.first.to_s == bt_underscored.split('/').last # Was:  bt_underscored.tr('/', '_')
         }\\\"\".html_safe %>
 <% end
    last_through = nil
@@ -557,14 +548,15 @@ erDiagram
 
      callbacks[hm_name = hm_class.name.split('::').last] = hm_class
      if (through = hm.last.options[:through]&.to_s) # has_many :through  (HMT)
-       callbacks[through.singularize.camelize] = (through_assoc = hm.last.source_reflection).active_record
+       through_name = (through_assoc = hm.last.source_reflection).active_record.name.split('::').last
+       callbacks[through_name] = through_assoc.active_record
        if last_through == through # Same HM, so no need to build it again, and for clarity just put in a blank line
 %><%=    \"\n\"
 %><%   else
-%>  <%= \"#\{model_short_name} ||--o{ #\{through_assoc.active_record.name}\".html_safe %> : \"\"
+%>  <%= \"#\{model_short_name} ||--o{ #\{through_name}\".html_safe %> : \"\"
 <%       last_through = through
        end
-%>    <%= \"#\{through_assoc.active_record.name} }o--|| #\{hm_name}\".html_safe %> : \"\"
+%>    <%= \"#\{through_name} }o--|| #\{hm_name}\".html_safe %> : \"\"
     <%= \"#\{model_short_name} }o..o{ #\{hm_name} : \\\"#\{hm.first}\\\"\".html_safe %><%
      else # has_many
 %>  <%= \"#\{model_short_name} ||--o{ #\{hm_name} : \\\"#\{
@@ -572,21 +564,25 @@ erDiagram
           }\\\"\".html_safe %><%
      end %>
 <% end
+   def dt_lookup(dt)
+     { 'integer' => 'int', }[dt] || dt.tr(' ', '_')
+   end
    callbacks.merge({model_short_name => #{@_brick_model.name}}).each do |cb_k, cb_class|
      cb_relation = ::Brick.relations[cb_class.table_name]
      pkeys = cb_relation[:pkey]&.first&.last
      fkeys = cb_relation[:fks]&.values&.each_with_object([]) { |fk, s| s << fk[:fk] if fk.fetch(:is_bt, nil) }
+     cols = cb_relation[:cols]
  %>  <%= cb_k %> {<%
      pkeys&.each do |pk| %>
-    <%= \"int #\{pk} \\\"PK#\{' fk' if fkeys&.include?(pk)}\\\"\".html_safe %><%
+    <%= \"#\{dt_lookup(cols[pk].first)} #\{pk} \\\"PK#\{' fk' if fkeys&.include?(pk)}\\\"\".html_safe %><%
      end %><%
      fkeys&.each do |fk|
        if fk.is_a?(Array)
          fk.each do |fk_part| %>
-    <%= \"int #\{fk_part} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk_part) %><%
+    <%= \"#\{dt_lookup(cols[fk_part].first)} #\{fk_part} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk_part) %><%
          end
        else %>
-    <%= \"int #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk) %><%
+    <%= \"#\{dt_lookup(cols[fk].first)} #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk) %><%
        end
      end %>
   }
@@ -595,6 +591,7 @@ erDiagram
  %>
 </div>
 "
+                           end
               inline = case args.first
                        when 'index'
                          obj_pk = if pk&.is_a?(Array) # Composite primary key?
@@ -690,7 +687,7 @@ erDiagram
 </script>
 <script async defer src=\"https://apis.google.com/js/api.js\" onload=\"gapiLoaded()\"></script>
 "
-                         end
+                         end # DutyFree data export and import
 # %%% Instead of our current "for Janet Leverling (Employee)" kind of link we previously had this code that did a "where x = 123" thing:
 #   (where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %>)
 +"#{css}
@@ -829,6 +826,7 @@ erDiagram
 #{script}"
 
                        when 'status'
+                         if is_status
 # Status page - list of all resources and 5 things they do or don't have present, and what is turned on and off
 # Must load all models, and then find what table names are represented
 # Easily could be multiple files involved (STI for instance)
@@ -852,7 +850,7 @@ erDiagram
   @resources.each do |r|
   %>
   <tr>
-  <td><%= link_to(r[0], \"/#\{r[0].tr('.', '/')}\") %></td>
+  <td><%= link_to(r[0], \"/#\{r[0].underscore.tr('.', '/')}\") %></td>
   <td<%= if r[1]
            ' class=\"orphan\"' unless ::Brick.relations.key?(r[1])
          else
@@ -873,6 +871,7 @@ erDiagram
 <% end %>
 </tbody></table>
 #{script}"
+                         end
 
                        when 'orphans'
                          if is_orphans
@@ -890,7 +889,7 @@ erDiagram
 #{script}"
                          end
 
-                       when 'show', 'update'
+                       when 'show', 'new', 'update'
 +"#{css}
 
 <svg id=\"revertTemplate\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"
@@ -958,38 +957,41 @@ end
     <% end %>
     </th>
     <td>
+    <table><tr><td>
     <% dt_pickers = { datetime: 'datetimepicker', timestamp: 'datetimepicker', time: 'timepicker', date: 'datepicker' }
+    html_options = {}
+    html_options[:class] = 'dimmed' unless val
+    is_revert = true
     if bt
-      html_options = { prompt: \"Select #\{bt_name\}\" }
-      html_options[:class] = 'dimmed' unless val %>
+      html_options[:prompt] = \"Select #\{bt_name\}\" %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
       <%= if (bt_obj = bt_class&.find_by(bt_pair[1] => val))
             link_to('⇛', send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' })
           elsif val
             \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
-          end %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
+          end %>
     <% else
-    html_options = {}
-    html_options[:class] = 'dimmed' unless val
-    case (col_type = col.type || col.sql_type)
+      case (col_type = col.type || col.sql_type)
       when :string, :text %>
-        <% if is_bcrypt?(val) # || .readonly? %>
+        <% if is_bcrypt?(val) # || .readonly?
+             is_revert = false %>
           <%= hide_bcrypt(val, 1000) %>
         <% else %>
-          <div class=\"wide-input\"><%= f.text_field(k.to_sym, html_options) %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg></div>
+          <%= f.text_field(k.to_sym, html_options) %>
         <% end %>
       <% when :boolean %>
-        <%= f.check_box k.to_sym %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
+        <%= f.check_box k.to_sym %>
       <% when :integer, :decimal, :float %>
         <%= if col_type == :integer
               f.text_field k.to_sym, { pattern: '\\d*', class: 'check-validity' }
             else
               f.number_field k.to_sym
-            end %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
+            end %>
       <% when *dt_pickers.keys
            is_includes_dates = true %>
-        <%= f.text_field k.to_sym, { class: dt_pickers[col_type] } %><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
-      <% when :uuid %>
+        <%= f.text_field k.to_sym, { class: dt_pickers[col_type] } %>
+      <% when :uuid
+           is_revert = false %>
         <%=
           # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
           # If it's not yet enabled then:  create extension \"uuid-ossp\";
@@ -1000,11 +1002,18 @@ end
           # In Postgres labels of data stored in a hierarchical tree-like structure
           # If it's not yet enabled then:  create extension ltree;
           val %>
-      <% when :binary, :primary_key %>
+      <% when :binary, :primary_key
+           is_revert = false %>
       <% else %>
-        <%= display_value(col_type, val) %>
+        <%= display_value(col_type, val)
+           is_revert = false %>
+      <% end
+       end
+       if is_revert
+         %></td>
+         <td><svg class=\"revert\" width=\"1.5em\" viewBox=\"0 0 512 512\"><use xlink:href=\"#revertPath\" /></svg>
       <% end %>
-    <% end %>
+      </td></tr></table>
     </td>
     </tr>
   <% end
@@ -1066,7 +1075,7 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
   var mermaidErd = document.getElementById(\"mermaidErd\");
   var mermaidCode;
   var cbs = {<%= callbacks.map { |k, v| \"#\{k}: \\\"#\{v.name.underscore.pluralize}\\\"\" }.join(', ').html_safe %>};
-  imgErd.addEventListener(\"click\", showErd);
+  if (imgErd) imgErd.addEventListener(\"click\", showErd);
   function showErd() {
     imgErd.style.display = \"none\";
     mermaidErd.style.display = \"inline-block\";
@@ -1087,7 +1096,9 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
             gErd.setAttribute(\"class\", \"relatedModel\");
             gErd.addEventListener(\"click\",
               function (evt) {
-                location.href = changeout(changeout(location.href, -1, cbs[this.id]), \"_brick_erd\", \"1\");
+                location.href = changeout(changeout(
+                  changeout(location.href, '_brick_order', null), // Remove any ordering
+                -1, cbs[this.id]), \"_brick_erd\", \"1\");
               }
             );
           }
@@ -1127,9 +1138,12 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
   var origVal = getInpVal(),
       prevVal = origVal;
   var revert;
-  if ((revert = ((inp.tagName === \"SELECT\" && inp.nextElementSibling.nextElementSibling) ||
-       inp.nextElementSibling ||
-       inp.parentElement.nextElementSibling)) && revert.tagName.toLowerCase() === \"svg\")
+  if (inp.getAttribute(\"type\") == \"hidden\" || inp.getAttribute(\"type\") == \"submit\") return;
+
+  var svgTd = null;
+  if ((revert = ((inp.tagName === \"SELECT\" && (svgTd = inp.parentElement.nextElementSibling) && svgTd.firstElementChild) ||
+                 ((svgTd = inp.parentElement.nextElementSibling) && svgTd.firstElementChild))
+     ) && revert.tagName.toLowerCase() === \"svg\")
     revert.addEventListener(\"click\", function (e) {
       if (inp.type === \"checkbox\")
         inp.checked = origVal;
@@ -1160,7 +1174,7 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
       prevVal = getInpVal();
     }
     // Show or hide the revert button
-    if (revert) revert.style.display = getInpVal() === origVal ? \"none\" : \"inline-block\";
+    if (revert) revert.style.display = getInpVal() === origVal ? \"none\" : \"block\";
   });
   function getInpVal() {
     return inp.type === \"checkbox\" ? inp.checked : inp.value;
@@ -1180,6 +1194,13 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
             # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
             prepend ::Brick::RouteSet
           end
+          # Do the root route before the Rails Welcome one would otherwise take precedence
+          unless (route = ::Brick.config.default_route_fallback).blank? ||
+                 ::Rails.application.routes.named_routes.send(:routes)[:root]
+            ::Rails.application.routes.append do
+              send(:root, "#{route}#{'#index' unless route.index('#')}")
+            end
+          end
         end
 
         # Just in case it hadn't been done previously when we tried to load the brick initialiser,

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -123,7 +123,7 @@ module Brick
   end
 
   class << self
-    attr_accessor :default_schema, :db_schemas
+    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle
 
     def set_db_schema(params)
       schema = params['_brick_schema'] || 'public'
@@ -461,11 +461,11 @@ In config/initializers/brick.rb appropriate entries would look something like:
 
   module RouteSet
     def finalize!
+      return super if ::Brick.routes_done
+
+      ::Brick.routes_done = true
       existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
       ::Rails.application.routes.append do
-        unless ::Brick.config.default_route_fallback.blank? || ::Rails.application.routes.named_routes.send(:routes)[:root]
-          send(:root, "#{::Brick.config.default_route_fallback}#index")
-        end
         # %%% 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|

data/lib/generators/brick/install_generator.rb

@@ -279,8 +279,8 @@ module Brick
 # # 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 = '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

data/lib/generators/brick/migrations_generator.rb

@@ -22,7 +22,16 @@ module Brick
                   'time without time zone' => 'time',
                   'time with time zone' => 'time',
                   'double precision' => 'float',
-                  'smallint' => 'integer' } # %%% Need to put in "limit: 2"
+                  'smallint' => 'integer', # %%% Need to put in "limit: 2"
+                  # Sqlite data types
+                  'TEXT' => 'text',
+                  '' => 'string',
+                  'INTEGER' => 'integer',
+                  'REAL' => 'float',
+                  'BLOB' => 'binary',
+                  'TIMESTAMP' => 'timestamp',
+                  'DATETIME' => 'timestamp'
+                }
     # (Still need to find what "inet" and "json" data types map to.)
 
     desc 'Auto-generates migration files for an existing database.'
@@ -38,7 +47,8 @@ module Brick
         return
       end
 
-      key_type = (ActiveRecord.version < ::Gem::Version.new('5.1') ? 'integer' : 'bigint')
+      is_sqlite = ActiveRecord::Base.connection.adapter_name == 'SQLite'
+      key_type = ((is_sqlite || ActiveRecord.version < ::Gem::Version.new('5.1')) ? 'integer' : 'bigint')
       is_4x_rails = ActiveRecord.version < ::Gem::Version.new('5.0')
       ar_version = "[#{ActiveRecord.version.segments[0..1].join('.')}]" unless is_4x_rails
       is_insert_versions = true
@@ -142,21 +152,20 @@ module Brick
           # if this one has come in as bigint or integer.
           pk_is_also_fk = fkey_cols.any? { |assoc| pkey_cols&.first == assoc[:fk] } ? pkey_cols&.first : nil
           # Support missing primary key (by adding:  ,id: false)
-          id_option = if pk_is_also_fk || (pkey_col_first = relation[:cols][pkey_cols&.first]&.first) != key_type
-                        if pk_is_also_fk || !pkey_cols&.present?
-                          ', id: false'
+          id_option = if pk_is_also_fk || !pkey_cols&.present?
+                        ', id: false'
+                      elsif ((pkey_col_first = relation[:cols][pkey_cols&.first]&.first) &&
+                             (pkey_col_first = SQL_TYPES[pkey_col_first] || pkey_col_first) != key_type)
+                        case pkey_col_first
+                        when 'integer'
+                          ', id: :serial'
+                        when 'bigint'
+                          ', id: :bigserial'
                         else
-                          case pkey_col_first
-                          when 'integer'
-                            ', id: :serial'
-                          when 'bigint'
-                            ', id: :bigserial'
-                          else
-                            ", id: :#{SQL_TYPES[pkey_col_first] || pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
-                          end +
-                            (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '') +
-                            (!is_4x_rails && (comment = relation&.fetch(:description, nil))&.present? ? ", comment: #{comment.inspect}" : '')
-                        end
+                          ", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
+                        end +
+                          (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '') +
+                          (!is_4x_rails && (comment = relation&.fetch(:description, nil))&.present? ? ", comment: #{comment.inspect}" : '')
                       end
           # Find the ActiveRecord class in order to see if the columns have comments
           unless is_4x_rails
@@ -208,7 +217,7 @@ module Brick
                 mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table} }\n"
               end
             else
-              next if !id_option&.end_with?('id: false') && pkey_cols.include?(col)
+              next if !id_option&.end_with?('id: false') && pkey_cols&.include?(col)
 
               # See if there are generic timestamps
               if sql_type == 'timestamp' && ['created_at','updated_at'].include?(col)
@@ -244,7 +253,7 @@ module Brick
             mig << "    #{'# ' if is_commented}add_foreign_key #{tbl_code}, #{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
           end
           mig << "  end\n"
-          versions_to_create << migration_file_write(mig_path, "create_#{tbl_parts.join('_')}", current_mig_time += 1.minute, ar_version, mig)
+          versions_to_create << migration_file_write(mig_path, "create_#{tbl_parts.map(&:underscore).join('_')}", current_mig_time += 1.minute, ar_version, mig)
         end
         done.concat(fringe)
         chosen -= done

metadata

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