brick 1.0.51 → 1.0.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d0c2c69187f4d9b8eaa4a22777d3e517546bf355316012bf3e333064f8939b7
-  data.tar.gz: 33fcb2f6ca4373eba2db3a2891de392d9ef71ea693687328f72d23837cabdc46
+  metadata.gz: '09f9f2f9f7e21a96d29cdad815c069e52280ea068051f27a542541bcefd33e87'
+  data.tar.gz: 54e032633f930a43d1bc929d05d241367d9ebbdb8010f588b922d1111077524e
 SHA512:
-  metadata.gz: 7136cb61d19325c1916e9d2e8e6cd7ed6c1d6838c77a216c5275bf4cc0d3540eeabf5caae152b49b9f5cf0d5ea7307bebd98f2fdbc03e651310c1cfc6fbec436
-  data.tar.gz: 81007bc391e9871ab0bbe80fc5aaa440da2685e1abe16d65d09419e31e93529232757db173cf97ba78ad3e719af760cac2d83b57cb7d97fa488399d93d3d2f76
+  metadata.gz: 56cad221c2b20ac62839c1b7904c8acb9bc392b0779946bbe325c48c8ee5cf00b33413e070674343809ee851804e5f9bbec2d6469a148688c4aecbbcaee3e09d
+  data.tar.gz: 9757effb2a1d058ae4ccd259b59e0218e002928d90dadfd6ff3d0acd05fb12e27cfcfef30afa3964637e0e4f1e4246b410deba45fb01e452e20056df94820377

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
@@ -1124,9 +1129,7 @@ class Object
         is_pk_string = nil
         if (pk_col = model&.primary_key)
           code << "  def show\n"
-          code << (find_by_id = "    id = params[:id]&.split(/[\\/,_]/)
-    id = id.first if id.is_a?(Array) && id.length == 1
-    @#{singular_table_name} = #{model.name}.find(id)\n")
+          code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
@@ -1137,35 +1140,59 @@ class Object
                    params[:id]&.split(/[\/,_]/)
                  end
             id = id.first if id.is_a?(Array) && id.length == 1
-            instance_variable_set("@#{singular_table_name}".to_sym, model.find(id))
+            instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
           end
         end
 
         # By default, views get marked as read-only
-        unless is_swagger # model.readonly # (relation = relations[model.table_name]).key?(:isView)
-          code << "  # (Define :new, :create)\n"
+        # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          code << "  def new\n"
+          code << "    @#{singular_table_name} = #{model.name}.new\n"
+          code << "  end\n"
+          self.define_method :new do
+            ::Brick.set_db_schema(params)
+            instance_variable_set("@#{singular_table_name}".to_sym, model.new)
+          end
+
+          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
+
+          code << "  def create\n"
+          code << "    @#{singular_table_name} = #{model.name}.create(#{params_name})\n"
+          code << "  end\n"
+          self.define_method :create do
+            ::Brick.set_db_schema(params)
+            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 model.primary_key
+          if pk_col
             # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
             # end
 
             is_need_params = true
-            # code << "  # (Define :destroy)\n"
             code << "  def edit\n"
-            code << find_by_id
+            code << "    #{find_by_name}\n"
             code << "  end\n"
             self.define_method :edit do
               ::Brick.set_db_schema(params)
-              id = is_pk_string ? params[:id] : params[:id]&.split(/[\/,_]/)
-              id = id.first if id.is_a?(Array) && id.length == 1
-              instance_variable_set("@#{singular_table_name}".to_sym, model.find(id))
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
             end
 
             code << "  def update\n"
-            code << find_by_id
-            params_name = "#{singular_table_name}_params"
-            code << "    @#{singular_table_name}.update(#{params_name})\n"
+            code << "    #{find_by_name}.update(#{params_name})\n"
             code << "  end\n"
             self.define_method :update do
               ::Brick.set_db_schema(params)
@@ -1184,31 +1211,50 @@ class Object
               #   return
               end
 
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = find_obj))
+              obj.send(:update, send(params_name_sym))
+            end
+
+            code << "  def destroy\n"
+            code << "    #{find_by_name}.destroy\n"
+            code << "  end\n"
+            self.define_method :destroy do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj.send(:destroy))
+            end
+          end
+
+          code << "private\n" if pk_col || is_need_params
+
+          if pk_col
+            code << "  def find_#{singular_table_name}
+    id = params[:id]&.split(/[\\/,_]/)
+    @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+  end\n"
+            self.define_method :find_obj do
               id = is_pk_string ? params[:id] : params[:id]&.split(/[\/,_]/)
-              id = id.first if id.is_a?(Array) && id.length == 1
-              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(id)))
-              obj = obj.first if obj.is_a?(Array)
-              obj.send(:update, send(params_name = params_name.to_sym))
+              model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
             end
           end
 
           if is_need_params
-            code << "private\n"
             code << "  def #{params_name}\n"
-            permits = model.columns_hash.keys.map { |c| c.to_sym.inspect } +
-                      model.reflect_on_all_associations.each_with_object([]) do |assoc, s|
-                        s << "#{assoc.name.to_s.singularize}_ids: []" if assoc.macro == :has_many && assoc.options[:through]
-                      end
+            permits = model.columns_hash.keys.map(&:to_sym)
+            permits_txt = permits.map(&:inspect) +
+                          model.reflect_on_all_associations.select { |assoc| assoc.macro == :has_many && assoc.options[:through] }.map do |assoc|
+                            permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
+                            "#{assoc.name.to_s.singularize}_ids: []"
+                          end
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
-                             }).permit(#{permits.join(', ')})\n"
+                             }).permit(#{permits_txt.join(', ')})\n"
             code << "  end\n"
             self.define_method(params_name) do
-              params.require(require_name.to_sym).permit(model.columns_hash.keys)
+              params.require(require_name.to_sym).permit(permits)
             end
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
           end
-        end
+        # end
         code << "end # #{namespace_name}#{class_name}\n\n"
       end # class definition
       [built_controller, code]
@@ -1243,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
 

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

@@ -132,27 +132,24 @@ module Brick
                                end
                   case args.first
                   when 'index'
-                    hms_columns << if hm_assoc.macro == :has_many
+                    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
-                                                attrib_name = "_br_#{assoc_name}_ct"[0..62]
-                                                "#{obj_name}.#{attrib_name} || 0"
-                                              end
-                                     if hm_fk_name
-"<%= ct = #{set_ct}
-     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
-                                     else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-"#{assoc_name}\n"
-                                     end
-                                   else # has_one
-                                     # 0..62 because Postgres column names are limited to 63 characters
-"<%= descrips = @_brick_bt_descrip[#{hm.first.inspect}][ho_class = #{hm[1].klass.name}]
-     ho_txt = ho_class.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(\"#\{ho_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt %>\n"
+                                                 '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"
@@ -178,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;
 }
@@ -199,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;
 }
 
@@ -257,6 +279,7 @@ a.big-arrow {
 }
 .dimmed {
   background-color: #C0C0C0;
+  text-align: center;
 }
 .orphan {
   color: red;
@@ -285,8 +308,8 @@ input+svg.revert {
   color: #FFF;
 }
 </style>
-<% is_includes_dates = nil
 
+<% is_includes_dates = nil
 def is_bcrypt?(val)
   val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
 end
@@ -418,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);
@@ -427,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) {
@@ -461,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\";
@@ -540,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
@@ -551,55 +598,78 @@ 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 = []
-     @#{table_name}.columns.each do |col|
-       next if (#{(pk || []).inspect}.include?(col_name = col.name) && col.type == :integer && !bts.key?(col_name)) ||
+  <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 = []
+               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)
 
-       col_order << col_name
-    %><th<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %><%
-       if (bt = bts[col_name]) %>
-         <%= \" x-order=\\\"#\{bt.first}\\\"\".html_safe unless bt[2] # Allow sorting any BT except polymorphics
-         %>>BT <%
-         bt[1].each do |bt_pair| %><%=
-           bt_pair.first.bt_link(bt.first) %> <%
-         end %><%
-       else %><%= \" x-order=\\\"#\{col_name}\\\"\".html_safe if true # Currently we always allow click to sort
-         %>><%= col_name %><%
-       end
-    %></th><%
+       s << col_name
+       cols[col_name] = col
      end
-     # Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name
-  %>#{hms_headers.map do |h|
-        # Currently we always allow click to sort
-        "<th#{" x-order=\"#{h.first.name}\"" if true}>" +
-        if h.first.options[:through] && !h.first.through_reflection
-    "#{h[1]} #{h[2]} %></th>" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-        else
-    "#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
-        end
-      end.join
-  }</tr></thead>
-
+     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])
+                # 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 # 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>
-  <% @#{table_name}.each do |#{obj_name}| %>
+  <% @#{table_name}.each do |#{obj_name}|
+       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>
-      <% if (bt = bts[col_name]) %>
-        <% if bt[2] # Polymorphic?
+      <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
@@ -608,14 +678,29 @@ 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 %>
-      <% else %>
-        <%= hide_bcrypt(val) %>
-      <% end %>
-      </td>
+        <% end
+         elsif (hms_col = hms_cols[col_name])
+           if hms_col.length == 1 %>
+         <%= hms_col.first %>
+        <% else
+             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
+                   else
+                     \"#\{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
+         elsif cols.key?(col_name)
+      %><%= hide_bcrypt(val) %><%
+         else # Bad column name!
+      %>?<%
+         end
+    %></td>
     <% end %>
-    #{hms_columns.each_with_object(+'') { |hm_col, s| s << "<td>#{hm_col}</td>" }}
   </tr>
   <% end %>
   </tbody>

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 51
+    TINY = 54
 
     # 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,160 @@
+# 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, smallint, date, boolean, decimal, float
+    SQL_TYPES = { 'character varying' =>'string',
+                  'timestamp without time zone' =>'timestamp',
+                  'timestamp with time zone' =>'timestamp',
+                  'double precision' =>'float' } # might work with 'double'
+    # (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
+
+      ar_version = unless ActiveRecord.version < ::Gem::Version.new('5.0')
+                     arv = ActiveRecord.version.segments[0..1]
+                     arv.pop if arv&.last == 0
+                     "[#{arv.join('.')}]"
+                   end
+      default_mig_path = (mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{File.expand_path(__dir__)}/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 = "#{File.expand_path(__dir__)}/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!', "Add all migration files to #{mig_path} anyway", mig_path, mig_path2])
+              return if mig_path2.start_with?('Cancel')
+
+              if mig_path2.start_with?('Add all migration files to ')
+                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)
+      # Work from now back the same number of minutes as expected 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[tbl][:fks].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|
+          tbl = tbl[7..-1] if tbl.start_with?('public.') # %%% Provide better multitenancy support later
+          pkey_cols = ::Brick.relations[chosen.first][:pkey].values.flatten
+          # %%% For the moment we're skipping polymorphics
+          fkey_cols = ::Brick.relations[tbl][:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
+          mig = +"class Create#{table_name = tbl.camelize} < ActiveRecord::Migration#{ar_version}\n"
+          # %%% Support missing foreign key (by adding:  ,id: false)
+          # also bigint / uuid / other non-standard data type for primary key
+          mig << "  def change\n    create_table :#{tbl} do |t|\n"
+          possible_ts = [] # Track possible generic timestamps
+          (relation = ::Brick.relations[tbl])[:cols].each do |col, col_type|
+            next if 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
+              next
+            end
+
+            sql_type ||= col_type.first
+            # Determine if this column is used as part of a foreign key
+            if fk = fkey_cols.find { |assoc| col == assoc[:fk] }
+              mig << "      t.references :#{fk[:assoc_name]}#{", type: #{sql_type}" unless sql_type == 'integer'}\n"
+            else
+              mig << emit_column(sql_type, col)
+            end
+          end
+          if possible_ts.length == 2 # Both created_at and updated_at
+            mig << "\n      t.timestamps\n"
+          else # Just one or the other
+            possible_ts.each { |ts| emit_column('timestamp', ts) }
+          end
+          mig << "    end\n  end\nend\n"
+          current_mig_time += 1.minute
+          File.open("#{mig_path}/#{current_mig_time.strftime('%Y%m%d%H%M00')}_create_#{tbl}.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
+      pretty_mig_path = mig_path[cur_path.length] if mig_path.start_with?(cur_path = File.expand_path(__dir__))
+      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)
+      "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}\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.51
+  version: 1.0.54
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-02 00:00:00.000000000 Z
+date: 2022-08-08 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