brick 1.0.52 → 1.0.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3d0b398d1d3926fa3e59281c976fe2f7a54bfc16de4f99683928ce71d7ace97
-  data.tar.gz: 344c0de3e8691583e9a940ee451ad29015d46b0cbc55756d3b36e10d9ce27edb
+  metadata.gz: 430a2dfa5ef0caee9b99bc341ccd42a9d29e8f1d54071284aa2469e1baa0c659
+  data.tar.gz: b36e18de169bd9032e6c383548ec30cce06eeb97a35e8c3e4f4da935aff8f603
 SHA512:
-  metadata.gz: e0cff4e30c30d33dd13bd5a6a4a888d52e0552fc692369c42a53846da00e9ce677ab48ba840ef1396728d339984e5f7ff35d9ce33ea60f8421b9fa19edc14575
-  data.tar.gz: 5971fcc802dd1732f71d3bcd015e4b616f7775028a10205c7e4b9b1fa41d13c0318f581c966c223e9a0661b8b9fa52e1197ae78c007144e93ec96de61b084663
+  metadata.gz: c51491575b9ee56c3789619bfc74a2d9c0525750687224e94e120cbae42fad8db1abda9d82978115d9266c55fa0c6f914ce273a3613915657d8a0cf4e7fe6aeb
+  data.tar.gz: a0646cfdc9a2c844fd1149968d0175346c48835c6245d7fe92d0126d60708cf76514704e29dc3f506d2e06e546c8c995bf7103d6ef42be481bb931b4d2bfa73f

data/lib/brick/extensions.rb

@@ -1116,6 +1116,11 @@ class Object
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
+          @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
+                           if (excl_parts = excl.split('.')).first == table_name
+                             s << excl_parts.last
+                           end
+                         end
           @_brick_bt_descrip = model._br_bt_descrip
           @_brick_hm_counts = model._br_hm_counts
           @_brick_join_array = join_array
@@ -1156,8 +1161,20 @@ class Object
           code << "  end\n"
           self.define_method :create do
             ::Brick.set_db_schema(params)
-            instance_variable_set("@#{singular_table_name}".to_sym,
-                                  model.send(:create, send(params_name_sym)))
+            if (is_json = request.content_type == 'application/json') && (col = params['_brick_exclude'])
+              session[:_brick_exclude] = ((session[:_brick_exclude]&.split(',') || []) + ["#{table_name}.#{col}"]).join(',')
+              render json: { result: ::Brick.exclude_column(table_name, col) }
+            elsif is_json && (col = params['_brick_unexclude'])
+              if (excls = ((session[:_brick_exclude]&.split(',') || []) - ["#{table_name}.#{col}"]).join(',')).empty?
+                session.delete(:_brick_exclude)
+              else
+                session[:_brick_exclude] = excls
+              end
+              render json: { result: ::Brick.unexclude_column(table_name, col) }
+            else
+              instance_variable_set("@#{singular_table_name}".to_sym,
+                                    model.send(:create, send(params_name_sym)))
+            end
           end
 
           if pk_col
@@ -1272,7 +1289,10 @@ module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
     conn = _brick_establish_connection(*args)
-    _brick_reflect_tables
+    begin
+      _brick_reflect_tables
+    rescue ActiveRecord::NoDatabaseError
+    end
     conn
   end
 
@@ -1296,16 +1316,21 @@ module ActiveRecord::ConnectionHandling
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
       is_postgres = nil
-      schema_sql = 'SELECT NULL AS table_schema;'
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
         is_postgres = true
+        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']
+          # Remove any system schemas
+          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
+        end
         if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
-           (sta = multitenancy[:schema_to_analyse]) != 'public')
+           (sta = multitenancy[:schema_to_analyse]) != 'public') &&
+           ::Brick.db_schemas.include?(sta)
           ::Brick.default_schema = schema = sta
           ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
         end
-        schema_sql = 'SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;'
       when 'Mysql2'
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
       when 'SQLite'
@@ -1322,16 +1347,7 @@ module ActiveRecord::ConnectionHandling
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
       end
 
-      unless (db_schemas = ActiveRecord::Base.execute_sql(schema_sql)).is_a?(Array)
-        db_schemas = db_schemas.to_a
-      end
-      unless db_schemas.empty?
-        ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
-          row = row.is_a?(String) ? row : row['table_schema']
-          # Remove any system schemas
-          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
-        end
-      end
+      ::Brick.db_schemas ||= []
 
       if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))

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

@@ -132,23 +132,24 @@ module Brick
                                end
                   case args.first
                   when 'index'
-                    hms_columns << if hm_assoc.macro == :has_many
-                                     if hm_fk_name
-                                       set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
-                                                   'nil'
-                                                 else
-                                                   # Postgres column names are limited to 63 characters
-                                                   attrib_name = "_br_#{assoc_name}_ct"[0..62]
-                                                   "#{obj_name}.#{attrib_name} || 0"
-                                                 end
-                                       "#{hm_assoc.name}: [#{assoc_name.inspect}, #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}]"
-                                     else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-                                       "#{hm_assoc.name}: [#{assoc_name.inspect}]"
-                                     end
-                                   else # has_one
-                                     # 0..62 because Postgres column names are limited to 63 characters
-                                     "#{hm_assoc.name}: [#{assoc_name.inspect}, nil, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}]"
+                    hm_entry = +"'#{hm_assoc.name}' => [#{assoc_name.inspect}"
+                    hm_entry << if hm_assoc.macro == :has_many
+                                   if hm_fk_name # %%% Can remove this check when multiple foreign keys to same destination becomes bulletproof
+                                     set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
+                                                 'nil'
+                                               else
+                                                 # Postgres column names are limited to 63 characters
+                                                 "#{obj_name}.#{"_br_#{assoc_name}_ct"[0..62]} || 0"
+                                               end
+                                     ", #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
                                    end
+                                 else # has_one
+                                   # 0..62 because Postgres column names are limited to 63 characters
+                                   ", 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
                                   "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
@@ -174,6 +175,9 @@ module Brick
                               end.html_safe
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
               css = +"<style>
+h1, h3 {
+  margin-bottom: 0;
+}
 #dropper {
   background-color: #eee;
 }
@@ -195,19 +199,41 @@ table {
   box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
 }
 
-table thead tr th, table tr th {
+tr th {
   background-color: #009879;
   color: #fff;
   text-align: left;
 }
-#headerTop th:hover, #headerTop th:hover {
+#headerTop tr th {
+  position: relative;
+}
+#headerTop tr th .exclude {
+  position: absolute;
+  display: none;
+  top: 0;
+  right: 0;
+}
+#headerTop tr th:hover {
   background-color: #18B090;
 }
-table thead tr th a, table tr th a {
+#exclusions {
+  font-size: 0.7em;
+}
+#exclusions div {
+  border: 1px solid blue;
+  display: inline-block;
+  cursor: copy;
+}
+#headerTop tr th:hover .exclude {
+  display: inline;
+  cursor: pointer;
+  color: red;
+}
+tr th a {
   color: #80FFB8;
 }
 
-table th, table td {
+tr th, tr td {
   padding: 0.2em 0.5em;
 }
 
@@ -253,6 +279,7 @@ a.big-arrow {
 }
 .dimmed {
   background-color: #C0C0C0;
+  text-align: center;
 }
 .orphan {
   color: red;
@@ -414,8 +441,19 @@ function setHeaderSizes() {
     for (var i = 0; i < row.childNodes.length; ++i) {
       node = row.childNodes[i];
       if (node.nodeType === 1) {
-        var style = tr.childNodes[i].style;
-        style.minWidth = style.maxWidth = getComputedStyle(node).width;
+        var th = tr.childNodes[i];
+        th.style.minWidth = th.style.maxWidth = getComputedStyle(node).width;
+        if (#{pk&.present? ? 'i > 0' : 'true'}) {
+          // Add <span> at the end
+          var span = document.createElement(\"SPAN\");
+          span.className = \"exclude\";
+          span.innerHTML = \"X\";
+          span.addEventListener(\"click\", function (e) {
+            e.stopPropagation();
+            doFetch(\"POST\", {_brick_exclude: this.parentElement.getAttribute(\"x-order\")});
+          });
+          th.appendChild(span);
+        }
       }
     }
     if (isEmpty) headerTop.appendChild(tr);
@@ -423,6 +461,18 @@ function setHeaderSizes() {
   grid.style.marginTop = \"-\" + getComputedStyle(headerTop).height;
   // console.log(\"end\");
 }
+function doFetch(method, payload, success) {
+  payload.authenticity_token = <%= session[:_csrf_token].inspect.html_safe %>;
+  if (!success) {
+    success = function (p) {p.text().then(function (response) {
+      var result = JSON.parse(response).result;
+      if (result) location.href = location.href;
+    });};
+  }
+  var options = {method: method, headers: {\"Content-Type\": \"application/json\"}};
+  if (payload) options.body = JSON.stringify(payload);
+  return fetch(location.href, options).then(success);
+}
 if (headerTop) {
   setHeaderSizes();
   window.addEventListener('resize', function(event) {
@@ -457,8 +507,8 @@ if (headerTop) {
     });
     btnImport.addEventListener(\"click\", function () {
       fetch(changeout(<%= #{path_obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'text/tab-separated-values' },
+        method: \"PATCH\",
+        headers: { \"Content-Type\": \"text/tab-separated-values\" },
         body: droppedTSV
       }).then(function (tsvResponse) {
         btnImport.style.display = \"none\";
@@ -536,6 +586,7 @@ if (headerTop) {
    if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
      description %><br><%
    end
+   # FILTER PARAMETERS
    if @_brick_params&.present? %>
   <% if @_brick_params.length == 1 # %%% Does not yet work with composite keys
        k, id = @_brick_params.first
@@ -547,38 +598,62 @@ if (headerTop) {
        end
      end %>
   (<%= link_to 'See all #{model_plural.split('::').last}', #{path_obj_name.pluralize}_path %>)
+<% end
+   # COLUMN EXCLUSIONS
+   if @_brick_excl&.present? %>
+  <div id=\"exclusions\">Excluded columns:
+  <% @_brick_excl.each do |excl| %>
+    <div class=\"colExclusion\"><%= excl %></div>
+  <% end %>
+  </div>
+  <script>
+    [... document.getElementsByClassName(\"colExclusion\")].forEach(function (excl) {
+      excl.addEventListener(\"click\", function () {
+        doFetch(\"POST\", {_brick_unexclude: this.innerHTML});
+      });
+    });
+  </script>
 <% end %>
-<br>
 <table id=\"headerTop\">
 <table id=\"#{table_name}\">
   <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%=
-     col_order = []
-     # Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name
-     hms_hdrs = {#{hms_headers.map do |hm|
-                    "#{hm.first.name}: [#{hm.first.name.inspect}, #{(hm.first.options[:through] && !hm.first.through_reflection).inspect}, #{hm.first.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
-                  end.join(', ')}}
-     (@#{table_name}.columns + hms_hdrs.values).each_with_object(+'') do |col, s|
-       if col.is_a?(ActiveRecord::ConnectionAdapters::Column)
-         next if (#{(pk || []).inspect}.include?(col_name = col.name) && col.type == :integer && !bts.key?(col_name)) ||
-                 ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
-
-         col_order << col_name
+     # 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 = []
+               hms_headers.map do |hm|
+                 hms_keys << (assoc_name = (assoc = hm.first).name.to_s)
+                 "#{assoc_name.inspect} => [#{(assoc.options[:through] && !assoc.through_reflection).inspect}, #{assoc.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
+               end.join(', ')}}
+     col_keys = @#{table_name}.columns.each_with_object([]) do |col, s|
+       col_name = col.name
+       next if @_brick_incl&.exclude?(col_name) ||
+               (#{(pk || []).inspect}.include?(col_name) && col.type == :integer && !bts.key?(col_name)) ||
+               ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
+
+       s << col_name
+       cols[col_name] = col
+     end
+     unless @_brick_sequence # If no sequence is defined, start with all inclusions
+       @_brick_sequence = col_keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
+     end
+     @_brick_sequence.reject! { |nm| @_brick_excl.include?(nm) } if @_brick_excl # Reject exclusions
+     @_brick_sequence.each_with_object(+'') do |col_name, s|
+       if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
+         s << '<th'
+         s << \" title=\\\"#\{col.comment}\\\"\" if col.respond_to?(:comment) && !col.comment.blank?
          s << if (bt = bts[col_name])
-                \"<th#\{' x-order=\"' + bt.first.to_s + '\"' unless bt[2]}>BT \" + # Allow sorting any BT except polymorphics
+                # Allow sorting for any BT except polymorphics
+                \"#\{' x-order=\"' + bt.first.to_s + '\"' unless bt[2]}>BT \" +
                 bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
-              else
-                # Currently we always allow click to sort on non-BT columns
-                \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col_name}\"
-              end + '</th>'
-       else # Currently we always allow click to sort on all HM columns (col is the hm array)
-         col_order << col.first # hm.name
-         s << \"<th#\{' x-order=\"' + col.first.to_s + '\"' if true}>\"
-         s << if col[1]
-                \"#\{col[3]} #\{col[4]}\" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-              else
-                \"#\{col[3]} #\{link_to(col[4], send(\"#\{col[2].name.underscore.tr('/', '_').pluralize}_path\"))}\"
-              end + '</th>'
+              else # Normal column
+                \"#\{' x-order=\"' + col_name + '\"' if true}>#\{col_name}\"
+              end
+       elsif col # HM column
+         s << \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col[2]} \"
+         s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1].name.underscore.tr('/', '_').pluralize}_path\"))}\")
+       else # Bad column name!
+         s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
        end
+       s << '</th>'
      end.html_safe
   %></tr></thead>
   <tbody>
@@ -586,16 +661,15 @@ if (headerTop) {
        hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
-    <% col_order.each do |col_name|
+    <% @_brick_sequence.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
-      <td><%
+      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name)%>><%
          if (bt = bts[col_name])
            if bt[2] # Polymorphic?
              bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
              base_class = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class.name.underscore
              poly_id = #{obj_name}.send(\"#\{bt.first\}_id\")
-             %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\",
-                           send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
+             %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\", send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
            else
              bt_txt = (bt_class = bt[1].first.first).brick_descrip(
                # 0..62 because Postgres column names are limited to 63 characters
@@ -604,15 +678,14 @@ if (headerTop) {
              bt_txt ||= \"<span class=\\\"orphan\\\">&lt;&lt; Orphaned ID: #\{val} >></span>\".html_safe if val
              bt_id = bt_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) } %>
           <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
-          <%#= Previously was:  bt_obj = bt[1].first.first.find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt[1].first.first.name.underscore\}_path\".to_sym, bt_obj.send(bt[1].first.first.primary_key.to_sym))) if bt_obj %>
-        <% end %>
-      <% elsif (hms_col = hms_cols[col_name])
+        <% end
+         elsif (hms_col = hms_cols[col_name])
            if hms_col.length == 1 %>
          <%= hms_col.first %>
         <% else
-             klass = (col = hms_hdrs[col_name])[2]
-             txt = if col[3] == 'HO'
-                     descrips = @_brick_bt_descrip[col_name][klass]
+             klass = (col = cols[col_name])[1]
+             txt = if col[2] == 'HO'
+                     descrips = @_brick_bt_descrip[col_name.to_sym][klass]
                      ho_txt = klass.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
                      ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
                      ho_id&.first ? link_to(ho_txt, send(\"#\{klass.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt
@@ -620,9 +693,11 @@ if (headerTop) {
                      \"#\{hms_col[1] || 'View'\} #\{hms_col.first}\"
                    end %>
          <%= link_to txt, send(\"#\{klass.name.underscore.tr('/', '_').pluralize}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
-        <% end %>
-      <% else
+        <% end
+         elsif cols.key?(col_name)
       %><%= hide_bcrypt(val) %><%
+         else # Bad column name!
+      %>?<%
          end
     %></td>
     <% end %>

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -190,6 +190,15 @@ module Brick
       [bts, hms]
     end
 
+    def exclude_column(table, col)
+      puts "Excluding #{table}.#{col}"
+      true
+    end
+    def unexclude_column(table, col)
+      puts "Unexcluding #{table}.#{col}"
+      true
+    end
+
     # Switches Brick auto-models on or off, for all threads
     # @api public
     def enable_models=(value)

data/lib/generators/brick/install_generator.rb

@@ -7,13 +7,13 @@ module Brick
   class InstallGenerator < ::Rails::Generators::Base
     # include ::Rails::Generators::Migration
 
-    source_root File.expand_path('templates', __dir__)
-    class_option(
-      :with_changes,
-      type: :boolean,
-      default: false,
-      desc: 'Store changeset (diff) with each version'
-    )
+    # source_root File.expand_path('templates', __dir__)
+    # class_option(
+    #   :with_changes,
+    #   type: :boolean,
+    #   default: false,
+    #   desc: 'Store changeset (diff) with each version'
+    # )
 
     desc 'Generates an initializer file for configuring Brick'
 

data/lib/generators/brick/migrations_generator.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'fancy_gets'
+
+module Brick
+  # Auto-generates migrations
+  class MigrationsGenerator < ::Rails::Generators::Base
+    include FancyGets
+    # include ::Rails::Generators::Migration
+
+    # SQL types that are the same as their migration data type name:  text, integer, bigint, date, boolean, decimal, float
+    SQL_TYPES = { 'character varying' => 'string',
+                  'character' => 'string', # %%% Need to put in "limit: 1"
+                  'xml' => 'text',
+                  'bytea' => 'binary',
+                  'timestamp without time zone' => 'timestamp',
+                  'timestamp with time zone' => 'timestamp',
+                  'time without time zone' => 'time',
+                  'time with time zone' => 'time',
+                  'double precision' => 'float', # might work with 'double'
+                  'smallint' => 'integer' } # %%% Need to put in "limit: 2"
+    # (Still need to find what "inet" and "json" data types map to.)
+
+    # # source_root File.expand_path('templates', __dir__)
+    # class_option(
+    #   :with_changes,
+    #   type: :boolean,
+    #   default: false,
+    #   desc: 'Add IMPORT_TEMPLATE to model'
+    # )
+
+    desc 'Auto-generates migrations for an existing database.'
+
+    def brick_migrations
+      # If Apartment is active, see if a default schema to analyse is indicated
+
+      # # Load all models
+      # Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+
+      if (tables = ::Brick.relations.reject { |k, v| v.key?(:isView) && v[:isView] == true }.map(&:first).sort).empty?
+        puts "No tables found in database #{ActiveRecord::Base.connection.current_database}."
+        return
+      end
+
+      key_type = (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
+      default_mig_path = (mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{::Rails.root}/db/migrate")
+      if Dir.exist?(mig_path)
+        if Dir["#{mig_path}/**/*.rb"].present?
+          puts "WARNING: migrations folder #{mig_path} appears to already have ruby files present."
+          mig_path2 = "#{::Rails.root}/tmp/brick_migrations"
+          if Dir.exist?(mig_path2)
+            if Dir["#{mig_path2}/**/*.rb"].present?
+              puts "As well, temporary folder #{mig_path2} also has ruby files present."
+              puts "Choose a destination -- all existing .rb files will be removed:"
+              mig_path2 = gets_list(list: ['Cancel operation!', "Append migration files into #{mig_path} anyway", mig_path, mig_path2])
+              return if mig_path2.start_with?('Cancel')
+
+              if mig_path2.start_with?('Append migration files into ')
+                mig_path2 = mig_path
+              else
+                Dir["#{mig_path2}/**/*.rb"].each { |rb| File.delete(rb) }
+              end
+            else
+              puts "Using temporary folder #{mig_path2} for created migration files.\n\n"
+            end
+          else
+            puts "Creating the temporary folder #{mig_path2} for created migration files.\n\n"
+            Dir.mkdir(mig_path2)
+          end
+          mig_path = mig_path2
+        else
+          puts "Using standard migration folder #{mig_path} for created migration files.\n\n"
+        end
+      else
+        puts "Creating standard ActiveRecord migration folder #{mig_path} to hold new migration files.\n\n"
+        Dir.mkdir(mig_path)
+      end
+
+      # Generate a list of tables that can be chosen
+      chosen = gets_list(list: tables, chosen: tables.dup)
+      # Start the timestamps back the same number of minutes from now as expected number of migrations to create
+      current_mig_time = Time.now - chosen.length.minutes
+      done = []
+      fks = {}
+      stuck = {}
+      # Start by making migrations for fringe tables (those with no foreign keys).
+      # Continue layer by layer, creating migrations for tables that reference ones already done, until
+      # no more migrations can be created.  (At that point hopefully all tables are accounted for.)
+      while (fringe = chosen.reject do |tbl|
+                        snags = ::Brick.relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
+                          v[:is_bt] && !v[:polymorphic] &&
+                          tbl != v[:inverse_table] && # Ignore self-referencing associations (stuff like "parent_id")
+                          !done.include?(v[:inverse_table])
+                        end
+                        stuck[tbl] = snags if snags&.present?
+                      end).present?
+        fringe.each do |tbl|
+          next unless (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
+
+          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ActiveRecord::Base.primary_key].flatten)
+          # In case things aren't as standard
+          if pkey_cols.empty?
+            pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type
+                          arpk
+                        elsif rpk.first
+                          rpk
+                        end
+          end
+          schema = if (tbl_parts = tbl.split('.')).length > 1
+                     if tbl_parts.first == 'public'
+                       tbl_parts.shift
+                       nil
+                     else
+                       tbl_parts.first
+                     end
+                   end
+          # %%% For the moment we're skipping polymorphics
+          fkey_cols = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
+          mig = +"class Create#{(full_table_name = tbl_parts.join('_')).camelize} < ActiveRecord::Migration#{ar_version}\n"
+          # Support missing primary key (by adding:  ,id: false)
+          # also integer / uuid / other non-standard data types for primary key
+          id_option = unless (pkey_col_first = relation[:cols][pkey_cols&.first]&.first) == key_type
+                        unless pkey_cols&.present?
+                          ', id: false'
+                        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}" : '')
+                        end
+                      end
+          # Refer to this table name as a symbol or dotted string as appropriate
+          tbl = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
+          mig << "  def change\n    return unless reverting? || !table_exists?(#{tbl})\n\n"
+          mig << "    create_schema :#{schema} unless schema_exists?(:#{schema})\n" if schema
+          mig << "    create_table #{tbl}#{id_option} do |t|\n"
+          possible_ts = [] # Track possible generic timestamps
+          add_fks = [] # Track foreign keys to add after table creation
+          relation[:cols].each do |col, col_type|
+            next if !id_option&.end_with?('id: false') && pkey_cols.include?(col)
+
+            # See if there are generic timestamps
+            if (sql_type = SQL_TYPES[col_type.first]) == 'timestamp' &&
+               ['created_at','updated_at'].include?(col)
+              possible_ts << [col, !col_type[3]]
+              next
+            end
+
+            sql_type ||= col_type.first
+            suffix = col_type[3] ? +', null: false' : +''
+            # Determine if this column is used as part of a foreign key
+            if fk = fkey_cols.find { |assoc| col == assoc[:fk] }
+              to_table = fk[:inverse_table].split('.')
+              to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
+              if fk[:fk] != "#{fk[:assoc_name].singularize}_id" # Need to do our own foreign_key tricks, not use references?
+                column = fk[:fk]
+                mig << "      t.#{sql_type} :#{column}#{suffix}\n"
+                add_fks << [to_table, column, ::Brick.relations[fk[:inverse_table]]]
+              else
+                suffix << ", type: :#{sql_type}" unless sql_type == key_type
+                mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table} }\n"
+              end
+            else
+              mig << emit_column(sql_type, col, suffix)
+            end
+          end
+          if possible_ts.length == 2 && # Both created_at and updated_at
+             # Rails 5 and later timestamps default to NOT NULL
+             (possible_ts.first.last == is_4x_rails && possible_ts.last.last == is_4x_rails)
+            mig << "\n      t.timestamps\n"
+          else # Just one or the other, or a nullability mismatch
+            possible_ts.each { |ts| emit_column('timestamp', ts.first, nil) }
+          end
+          mig << "    end\n"
+          add_fks.each do |add_fk|
+            is_commented = false
+            # add_fk[2] holds the inverse relation
+            unless (pk = add_fk[2][:pkey].values.flatten&.first)
+              is_commented = true
+              mig << "    # (Unable to create relationship because primary key is missing on table #{add_fk[0]})\n"
+              # No official PK, but if coincidentally there's a column of the same name, take a chance on it
+              pk = (add_fk[2][:cols].key?(add_fk[1]) && add_fk[1]) || '???'
+            end
+            #                                                            to_table               column
+            mig << "    #{'# ' if is_commented}add_foreign_key #{tbl}, #{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
+          end
+          mig << "  end\nend\n"
+          current_mig_time += 1.minute
+          File.open("#{mig_path}/#{current_mig_time.strftime('%Y%m%d%H%M00')}_create_#{full_table_name}.rb", "w") { |f| f.write mig }
+        end
+        done.concat(fringe)
+        chosen -= done
+      end
+      stuck_counts = Hash.new { |h, k| h[k] = 0 }
+      chosen.each do |leftover|
+        puts "Can't do #{leftover} because:\n  #{stuck[leftover].map do |snag|
+          stuck_counts[snag.last[:inverse_table]] += 1
+          snag.last[:assoc_name]
+        end.join(', ')}"
+      end
+      if mig_path.start_with?(cur_path = ::Rails.root.to_s)
+        pretty_mig_path = mig_path[cur_path.length..-1]
+      end
+      puts "*** Created #{done.length} migration files under #{pretty_mig_path || mig_path} ***"
+      if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
+        puts "-----------------------------------------"
+        puts "Unable to create migrations for #{stuck_sorted.length} tables#{
+          ".  Here's the top 5 blockers" if stuck_sorted.length > 5
+        }:"
+        pp stuck_sorted[0..4]
+      end
+    end
+
+  private
+
+    def emit_column(type, name, suffix)
+      "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
+    end
+  end
+end

data/lib/generators/brick/model_generator.rb

@@ -59,7 +59,6 @@ module Brick
         end
       end
       models.each do |m| # Find longest name in the list for future use to show lists on the right side of the screen
-        # Strangely this can't be inlined since it assigns to "len"
         if longest_length < (len = m.name.length)
           longest_length = len
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.52
+  version: 1.0.55
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-04 00:00:00.000000000 Z
+date: 2022-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -238,6 +238,7 @@ files:
 - lib/brick/version_number.rb
 - lib/generators/brick/USAGE
 - lib/generators/brick/install_generator.rb
+- lib/generators/brick/migrations_generator.rb
 - lib/generators/brick/model_generator.rb
 - lib/generators/brick/templates/add_object_changes_to_versions.rb.erb
 - lib/generators/brick/templates/create_versions.rb.erb