brick 1.0.59 → 1.0.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db41c2288f8bba8f3cb9c5d2d87bacd4806d1f2401ca9709f85de1886b0db377
-  data.tar.gz: 42b0a7b285a3328ce922daa442e15bf994a382ad0bfc5ed8fe4370ae6b779fbb
+  metadata.gz: ae6fe72ae3ec1d2ba6318f1bb6cb4964b29a1479e3b76e2cb560537cc6a6ff6c
+  data.tar.gz: 608fbd2c50c31dd4eff33a4d7c8a19786c53518e9fc1ff38059bf47ca254b6ba
 SHA512:
-  metadata.gz: b8baacad02f8ba5c0d9bfe11182d8297c817ba46bef250e172f55a0ff949591abcadda790aecc2614515468a4da468415a8a0e62fd2a60232177dcd3cd63ca03
-  data.tar.gz: e84d2573ec0f95b01dfebf681cec409ec66a1e6052abbb59ebd3130728cad71015c51087f484c55e8e30f3b9a3736d3d9262b7d8cdebf23e5ab702035c0dcbfa
+  metadata.gz: 0b0c3fcc243cde60b35f2cf07277a53c413b1b805d9a31cf00f4d89676b7eaf0d79ba1ea22bc33190ff8df55eab96e62b0c986f1894dc11e55b8358dbae7cc57
+  data.tar.gz: 32d9c0e8bba6f2a477ed85347680113ab92d1ed52ce044d97bacf734d33fa7c9e7f62bc87ab01b2a027e1f41c62afe802f3601e14f7bdc9d8026b03050337c23

data/lib/brick/extensions.rb

@@ -373,6 +373,7 @@ module ActiveRecord
     end
 
     def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+      is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
@@ -397,12 +398,14 @@ module ActiveRecord
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         columns.each do |col|
-          if (col_name = col.name) == 'class'
-            col_alias = ' AS _class'
-          end
-          # 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')
-          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
+          col_alias = ' AS _class' if (col_name = col.name) == 'class'
+          selects << if is_mysql
+                       "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
+                     else
+                       # 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}"
+                     end
         end
       end
 
@@ -430,7 +433,11 @@ module ActiveRecord
               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('__')}"
               end
-              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+              selects << if is_mysql
+                           "`#{field_tbl_name}`.`#{sel_col.last}` AS `#{col_alias}`"
+                         else
+                           "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+                         end
               used_col_aliases[col_alias] = nil
               v1[idx] << col_alias
             end
@@ -439,7 +446,11 @@ module ActiveRecord
               # Accommodate composite primary key by allowing id_col to come in as an array
               ((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 << "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+                                            selects << if is_mysql
+                                                         "#{"`#{tbl_name}`.`#{id_part}`"} AS `#{(id_alias = "_brfk_#{v.first}__#{id_part}")}`"
+                                                       else
+                                                         "#{"\"#{tbl_name}\".\"#{id_part}\""} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+                                                       end
                                             id_alias
                                           end
               end
@@ -990,6 +1001,17 @@ class Object
       self.send(macro, assoc_name, **options)
     end
 
+    def default_ordering(table_name, pk)
+      case (order_tbl = ::Brick.config.order[table_name]) && (order_default = order_tbl[:_brick_default])
+      when Array
+        order_default.map { |od_part| order_tbl[od_part] || od_part }
+      when Symbol
+        order_tbl[order_default] || order_default
+      else
+        pk.map(&:to_sym) # If it's not a custom ORDER BY, just use the key
+      end
+    end
+
     def build_controller(namespace, class_name, plural_class_name, model, relations)
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
@@ -1077,27 +1099,9 @@ class Object
           # Normal (non-swagger) request
 
           # %%% Allow params to define which columns to use for order_by
-          ordering = if (order_tbl = ::Brick.config.order[table_name])
-                       case (order_default = order_tbl[:_brick_default])
-                       when Array
-                         order_default.map { |od_part| order_tbl[od_part] || od_part }
-                       when Symbol
-                         order_tbl[order_default] || order_default
-                       else
-                         pk
-                       end
-                     else
-                       pk # If it's not a custom ORDER BY, just use the key
-                     end
-          order_by, order_by_txt = model._brick_calculate_ordering(ordering)
-          if (order_params = params['_brick_order']&.split(',')&.map(&:to_sym)) # Overriding the default by providing a querystring param?
-            order_by, _ = model._brick_calculate_ordering(order_params, true) # Don't do the txt part
-          end
-
-          code << "  def index\n"
-          code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
-          code << "    @#{table_name}.brick_select(params)\n"
-          code << "  end\n"
+          # Overriding the default by providing a querystring param?
+          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
 
           ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
@@ -1128,8 +1132,15 @@ class Object
           @_brick_bt_descrip = model._br_bt_descrip
           @_brick_hm_counts = model._br_hm_counts
           @_brick_join_array = join_array
+          @_brick_erd = params['_brick_erd']&.to_i
         end
 
+        _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk))
+        code << "  def index\n"
+        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
+        code << "    @#{table_name}.brick_select(params)\n"
+        code << "  end\n"
+
         is_pk_string = nil
         if (pk_col = model&.primary_key)
           code << "  def show\n"
@@ -1316,7 +1327,7 @@ module ActiveRecord::ConnectionHandling
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
-      # Only for Postgres?  (Doesn't work in sqlite3)
+      # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
       is_postgres = nil
@@ -1351,7 +1362,7 @@ module ActiveRecord::ConnectionHandling
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
       end
 
-      ::Brick.db_schemas ||= []
+      ::Brick.db_schemas ||= {}
 
       if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
@@ -1367,41 +1378,11 @@ module ActiveRecord::ConnectionHandling
       # %%% Retrieve internal ActiveRecord table names like this:
       # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
       # For if it's not SQLite -- so this is the Postgres and MySQL version
-      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\",
-          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
-            kcu.CONSTRAINT_SCHEMA = c.table_schema
-            AND kcu.TABLE_NAME = c.table_name
-            AND kcu.position_in_unique_constraint IS NULL
-            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 NOT IN ('information_schema', 'pg_catalog')#{"
-          AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }
-  --          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, c.ordinal_position"
       measures = []
       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'
-        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).each do |r|
+        ActiveRecord::Base.retrieve_schema_and_tables(sql, is_postgres, 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]
@@ -1428,23 +1409,23 @@ module ActiveRecord::ConnectionHandling
           # 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.execute_sql(sql).each do |r|
-          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
+        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
+          relation[:isView] = true if r[2] == 'VIEW' # table_type
+          col_name = r[3]
+          key = case r[6] # constraint type
                 when 'PRIMARY KEY'
                   # key
-                  relation[:pkey][r[6] || relation_name] ||= []
+                  relation[:pkey][r[7] || relation_name] ||= []
                 when 'UNIQUE'
-                  relation[:ukeys][r[6] || "#{relation_name}.#{col_name}"] ||= []
+                  relation[:ukeys][r[7] || "#{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)]
+          cols[col_name] = [r[4], r[5], measures&.include?(col_name)]
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
         end
       end
@@ -1480,9 +1461,11 @@ module ActiveRecord::ConnectionHandling
             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.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.ORDINAL_POSITION = kcu1.ORDINAL_POSITION#{"
-          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }"
+          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && 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
@@ -1498,12 +1481,14 @@ module ActiveRecord::ConnectionHandling
           # 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 fk[0] == 'public' || (is_multitenant && fk[0] == 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 fk[3] == 'public' || (is_multitenant && fk[3] == 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)
@@ -1537,6 +1522,43 @@ module ActiveRecord::ConnectionHandling
 
     ::Brick.load_additional_references if initializer_loaded
   end
+
+  def retrieve_schema_and_tables(sql = nil, is_postgres = nil, schema = 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\",
+      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
+        kcu.CONSTRAINT_SCHEMA = c.table_schema
+        AND kcu.TABLE_NAME = c.table_name
+        AND kcu.position_in_unique_constraint IS NULL
+        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 ?
+        "NOT IN ('information_schema', 'pg_catalog')"
+        :
+        "= '#{ActiveRecord::Base.connection.current_database.tr("'", "''")}'"}#{"
+      AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }
+  --          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"
+    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)
+  end
 end
 
 # ==========================================

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

@@ -47,7 +47,10 @@ module Brick
       end
 
       # After we're initialized and before running the rest of stuff, put our configuration in place
-      ActiveSupport.on_load(:after_initialize) do
+      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
         # ====================================
         # Dynamically create generic templates
         # ====================================
@@ -150,7 +153,6 @@ module Brick
                                    ", nil, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
                                  end
                     hm_entry << ']'
-                    puts hm_entry
                     hms_columns << hm_entry
                   when 'show', 'update'
                     hm_stuff << if hm_fk_name
@@ -180,6 +182,30 @@ module Brick
 h1, h3 {
   margin-bottom: 0;
 }
+#resourceName {
+}
+#imgErd {
+  background-image:url(assets/brick_erd.png);
+  background-size: 100% 100%;
+  width: 2.2em;
+  height: 2.2em;
+  cursor: pointer;
+}
+#mermaidErd {
+  position: relative;
+  display: none;
+}
+#mermaidErd .exclude {
+  position: absolute;
+  color: red;
+  top: 0;
+  right: 0;
+  cursor: pointer;
+}
+.relatedModel {
+  cursor: pointer;
+}
+
 #dropper {
   background-color: #eee;
 }
@@ -197,6 +223,8 @@ table {
   border-collapse: collapse;
   font-size: 0.9em;
   font-family: sans-serif;
+}
+table.shadow {
   min-width: 400px;
   box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
 }
@@ -214,6 +242,7 @@ tr th {
   display: none;
   top: 0;
   right: 0;
+  cursor: pointer;
 }
 #headerTop tr th:hover {
   background-color: #18B090;
@@ -246,7 +275,7 @@ tr th, tr td {
   color: #80B8D2;
 }
 
-table tbody tr {
+table.shadow tbody tr {
   border-bottom: thin solid #dddddd;
 }
 
@@ -254,7 +283,7 @@ table tbody tr:nth-of-type(even) {
   background-color: #f3f3f3;
 }
 
-table tbody tr:last-of-type {
+table.shadow tbody tr:last-of-type {
   border-bottom: 2px solid #009879;
 }
 
@@ -328,6 +357,28 @@ def hide_bcrypt(val, max_len = 200)
     end
     val
   end
+end
+def display_value(col_type, val)
+  case col_type
+  when 'geometry'
+    if Object.const_defined?('RGeo')
+      @is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2' if @is_mysql.nil?
+      if @is_mysql
+        # MySQL's \"Internal Geometry Format\" is like WKB, but with an initial 4 bytes that indicates the SRID.
+        srid = val[..3].unpack('I')
+        val = val[4..]
+      end
+      RGeo::WKRep::WKBParser.new.parse(val)
+    else
+      '(Add RGeo gem to parse geometry detail)'
+    end
+  else
+    if col_type
+      hide_bcrypt(val)
+    else
+      '?'
+    end
+  end
 end %>"
 
               if ['index', 'show', 'update'].include?(args.first)
@@ -417,10 +468,11 @@ function changeout(href, param, value, trimAfter) {
     hrefParts[0] = pathParts.join(\"/\");
   }
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
-  params = params.reduce(function (s, v) { var parts = v.split(\"=\"); s[parts[0]] = parts[1]; return s; }, {});
+  params = params.reduce(function (s, v) { var parts = v.split(\"=\"); if (parts[1] !== null) s[parts[0]] = parts[1]; return s; }, {});
   if (value === undefined) return params[param];
   params[param] = value;
-  return hrefParts[0] + \"?\" + Object.keys(params).reduce(function (s, v) { s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
+  var finalParams = Object.keys(params).reduce(function (s, v) { if (params[v] !== null) s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
+  return hrefParts[0] + (finalParams.length > 0 ? \"?\" + finalParams : \"\");
 }
 
 // Snag first TR for sticky header
@@ -584,7 +636,10 @@ if (headerTop) {
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
-<h1>#{model_plural = model_name.pluralize}</h1>#{template_link}<%
+<table id=\"resourceName\"><tr>
+  <td><h1>#{model_plural = model_name.pluralize}</h1></td>
+  <td id=\"imgErd\" title=\"Show ERD\"></td>
+</tr></table>#{template_link}<%
    if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
      description %><br><%
    end
@@ -615,9 +670,41 @@ if (headerTop) {
       });
     });
   </script>
+<% end
+   if true # @_brick_erd
+%><div id=\"mermaidErd\" class=\"mermaid\">
+erDiagram
+<% model_short_name = #{@_brick_model.name.split('::').last.inspect}
+   callbacks = {}
+   @_brick_bt_descrip.each do |bt|
+     bt_full_name = bt[1].first.first.name
+     callbacks[bt_name = bt_full_name.split('::').last] = bt_full_name
+     # binding.pry
+    %>  <%= \"#\{model_short_name} #\{'||'}--#\{
+        'o{'} #\{bt_name} : \\\"#\{
+        bt.first unless bt.first.to_s == bt[1].first.first.name.underscore.singularize.tr('/', '_')
+        }\\\"\".html_safe %>
+<% end %>
+<% @_brick_hm_counts.each do |hm|
+     hm_full_name = hm.last.klass.name
+     callbacks[hm_name = hm_full_name.split('::').last] = hm_full_name
+    %>  <%= \"#\{model_short_name} #\{'}o'}--#\{
+        '||'} #\{hm_name} : \\\"#\{
+        hm.first unless hm.first.to_s == hm_full_name.underscore.pluralize.tr('/', '_')
+        }\\\"\".html_safe %>
 <% end %>
-<table id=\"headerTop\">
-<table id=\"#{table_name}\">
+<% callbacks.keys.each do |cb|
+ %>  <%= cb %> {
+    int id
+  }
+<% end
+ # callback < %= cb_k % > erdClick
+ %>
+</div>
+<% end
+
+%><table id=\"headerTop\"></table>
+<table id=\"#{table_name}\" class=\"shadow\">
   <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%=
      # Consider getting the name from the association -- hm.first.name -- if a more \"friendly\" alias should be used for a screwy table name
      cols = {#{hms_keys = []
@@ -683,7 +770,7 @@ if (headerTop) {
         <% end
          elsif (hms_col = hms_cols[col_name])
            if hms_col.length == 1 %>
-         <%= hms_col.first %>
+        <%=  hms_col.first %>
         <% else
              klass = (col = cols[col_name])[1]
              txt = if col[2] == 'HO'
@@ -696,8 +783,8 @@ if (headerTop) {
                    end %>
          <%= link_to txt, send(\"#\{klass.name.underscore.tr('/', '_').pluralize}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
         <% end
-         elsif cols.key?(col_name)
-      %><%= hide_bcrypt(val) %><%
+         elsif (col = cols[col_name])
+    %><%=  display_value(col&.type || col&.sql_type, val) %><%
          else # Bad column name!
       %>?<%
          end
@@ -720,7 +807,7 @@ if (headerTop) {
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Status</h1>
-<table id=\"status\"><thead><tr>
+<table id=\"status\" class=\"shadow\"><thead><tr>
   <th>Resource</th>
   <th>Table</th>
   <th>Migration</th>
@@ -754,7 +841,7 @@ if (headerTop) {
                %></td>
   <tr>
 <% end %>
-</tbody><table>
+</tbody></table>
 #{script}"
 
                        when 'orphans'
@@ -796,7 +883,7 @@ end
     # path_options << { '_brick_schema':  } if
     # url = send(:#{model_name.underscore}_path, obj.#{pk})
     form_for(obj.becomes(#{model_name})) do |f| %>
-  <table>
+  <table class=\"shadow\">
   <% has_fields = false
     @#{obj_name}.attributes.each do |k, val|
       col = #{model_name}.columns_hash[k] %>
@@ -853,7 +940,7 @@ end
     <% else
     html_options = {}
     html_options[:class] = 'dimmed' unless val
-    case (col_type = #{model_name}.column_for_attribute(k).type)
+    case (col_type = col.type || col.sql_type)
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
           <%= hide_bcrypt(val, 1000) %>
@@ -883,6 +970,8 @@ end
           # If it's not yet enabled then:  create extension ltree;
           val %>
       <% when :binary, :primary_key %>
+      <% else %>
+        <%= display_value(col_type, val) %>
       <% end %>
     <% end %>
     </td>
@@ -903,7 +992,7 @@ end
     if (pk = hm.first.klass.primary_key)
       hm_singular_name = (hm_name = hm.first.name.to_s).singularize.underscore
       obj_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "#{hm_singular_name}.#{pk_part}" }.join(', ')
-      s << "<table id=\"#{hm_name}\">
+      s << "<table id=\"#{hm_name}\" class=\"shadow\">
         <tr><th>#{hm[3]}</th></tr>
         <% collection = @#{obj_name}.#{hm_name}
         collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection].compact
@@ -938,7 +1027,61 @@ flatpickr(\".datetimepicker\", {enableTime: true});
 flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
 </script>
 <% end %>
+
+<% if true # @_brick_erd
+%>
 <script>
+  var imgErd = document.getElementById(\"imgErd\");
+  var mermaidErd = document.getElementById(\"mermaidErd\");
+  var mermaidCode;
+  var cbs = {<%= callbacks.map { |k, v| \"#\{k}: \\\"#\{v.underscore.pluralize}\\\"\" }.join(', ').html_safe %>};
+  imgErd.addEventListener(\"click\", showErd);
+  function showErd() {
+    imgErd.style.display = \"none\";
+    mermaidErd.style.display = \"inline-block\";
+    if (mermaidCode) return; // Cut it short if we've already rendered the diagram
+
+    mermaidCode = document.createElement(\"SCRIPT\");
+    mermaidCode.setAttribute(\"src\", \"https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js\");
+    mermaidCode.addEventListener(\"load\", function () {
+      mermaid.initialize({
+        startOnLoad: true,
+        securityLevel: \"loose\",
+        mermaid: {callback: function(objId) {
+          var svg = document.getElementById(objId);
+          var cb;
+          for(cb in cbs) {
+            var gErd = svg.getElementById(cb);
+            gErd.setAttribute(\"class\", \"relatedModel\");
+            gErd.addEventListener(\"click\",
+              function (evt) {
+                location.href = changeout(changeout(location.href, null, cbs[this.id]), \"_brick_erd\", \"1\");
+              }
+            );
+          }
+        }}
+      });
+      mermaid.contentLoaded();
+      // Add <span> at the end
+      var span = document.createElement(\"SPAN\");
+      span.className = \"exclude\";
+      span.innerHTML = \"X\";
+      span.addEventListener(\"click\", function (e) {
+        e.stopPropagation();
+        imgErd.style.display = \"table-cell\";
+        mermaidErd.style.display = \"none\";
+        window.history.pushState({}, '', changeout(location.href, '_brick_erd', null));
+      });
+      mermaidErd.appendChild(span);
+    });
+    document.body.appendChild(mermaidCode);
+  }
+  <%= \"  showErd();\n\" if (@_brick_erd || 0) > 0
+%></script>
+
+<% end
+
+%><script>
 <% # Make column headers sort when clicked
    # %%% Create a smart javascript routine which can do this client-side %>
 [... document.getElementsByTagName(\"TH\")].forEach(function (th) {

data/lib/brick/version_number.rb

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

data/lib/generators/brick/migrations_generator.rb

@@ -21,7 +21,7 @@ module Brick
                   'timestamp with time zone' => 'timestamp',
                   'time without time zone' => 'time',
                   'time with time zone' => 'time',
-                  'double precision' => 'float', # might work with 'double'
+                  'double precision' => 'float',
                   'smallint' => 'integer' } # %%% Need to put in "limit: 2"
     # (Still need to find what "inet" and "json" data types map to.)
 

data/lib/generators/brick/models_generator.rb

@@ -32,6 +32,7 @@ module Brick
       end
       models = ::Brick.relations.keys.map do |tbl|
         tbl_parts = tbl.split('.')
+        tbl_parts.shift if [::Brick.default_schema, 'public'].include?(tbl_parts.first)
         tbl_parts[-1] = tbl_parts[-1].singularize
         tbl_parts.join('/').camelize
       end - existing_models.map(&:name)
@@ -54,7 +55,7 @@ module Brick
       chosen = gets_list(list: models, chosen: models.dup)
       relations = ::Brick.relations
       chosen.each do |model_name|
-        # If we're in a schema then make sure the module file exists
+        # %%% If we're in a schema then make sure the module file exists
         base_module = if (model_parts = model_name.split('::')).length > 1
                         "::#{model_parts.first}".constantize
                       else
@@ -68,7 +69,7 @@ module Brick
           dir << "/#{path_part}"
           Dir.mkdir(dir) unless Dir.exists?(dir)
         end
-        File.open("#{dir}/#{path.last}.rb", 'w') { |f| f.write code }
+        File.open("#{dir}/#{path.last}.rb", 'w') { |f| f.write code } unless code.blank?
       end
       puts "\n*** Created #{chosen.length} model files under app/models ***"
     end

metadata

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