brick 1.0.20 → 1.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41b64e2d571540382ce5ecd497f1e1413fde20119d46f1b24e1fae5af428fb45
-  data.tar.gz: 1c26ccf7b8df54fd121546e8daeeb9508561328186af46aea8ba1bd819524532
+  metadata.gz: 24731ac9bd56261179224610406247cc4438c61e411aa3fe96205b2e97fc8cb8
+  data.tar.gz: 785d12e36fcf788c05cff3a02ca2ec17fc418b0ea15b54cb6923c83c6f362d3b
 SHA512:
-  metadata.gz: e103d061b74402f3fe0b944d06b30c20f053166c706a54f15753afc8cb0c703ae71f83bd88191f985a37180cb9bdafdba918178174df08f58f683a723fcfb73a
-  data.tar.gz: 13a7dce7f4f5789a0d7a0c6cae4adcaf2f44d22d0f59c355d75102a7f08292d80c781f8d33be121801d375fd33fed8bcdf4ef6b56108ef8f4ab4110c1f49e296
+  metadata.gz: '090a3c4d1b3cb4761799e05adf5caa0c83f60cf985f97ed6856beb05620014e9e7401689719209488092c6c4a7605e53781cdb71ad9e7ec204ccaddca0d92cca'
+  data.tar.gz: 8d1f9512c948359e7d73cd7cc32302f226df7e3e744fab562e01e16170830be28d0e2e15bcd7b437f66ed79e366b0ff33b7f578e4c76ffde1dd62cdcec059069

data/lib/brick/config.rb

@@ -74,6 +74,20 @@ module Brick
       @mutex.synchronize { @exclude_hms = skips }
     end
 
+    # Skip showing counts for these specific has_many associations when building auto-generated #index views
+    def skip_index_hms
+      @mutex.synchronize { @skip_index_hms || {} }
+    end
+
+    def skip_index_hms=(skips)
+      @mutex.synchronize do
+        @skip_index_hms ||= skips.each_with_object({}) do |v, s|
+                              class_name, assoc_name = v.split('.')
+                              (s[class_name] ||= {})[assoc_name.to_sym] = nil
+                            end
+      end
+    end
+
     # Associations to treat as a has_one
     def has_ones
       @mutex.synchronize { @has_ones }

data/lib/brick/extensions.rb

@@ -26,18 +26,13 @@
 
 # colour coded origins
 
-# Drag something like TmfModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = section / etc
+# Drag something like HierModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = section / etc
 
 # Support for Postgres / MySQL enums (add enum to model, use model enums to make a drop-down in the UI)
 
 # Currently quadrupling up routes
 
 
-# From the North app:
-# undefined method `built_in_role_path' when referencing show on a subclassed STI:
-#  http://localhost:3000/roles/3?_brick_schema=cust1
-
-
 # ==========================================================
 # Dynamically create model or controller classes when needed
 # ==========================================================
@@ -166,16 +161,36 @@ module ActiveRecord
       if is_brackets_have_content
         output
       elsif pk_alias
-        if (id = obj.send(pk_alias))
-          "#{klass.name} ##{id}"
+        id = []
+        pk_alias.each do |pk_alias_part|
+          if (pk_part = obj.send(pk_alias_part))
+            id << pk_part
+          end
+        end
+        if id.present?
+          "#{klass.name} ##{id.join(', ')}"
         end
-      # elsif klass.primary_key
-      #   "#{klass.name} ##{obj.send(klass.primary_key)}"
       else
         obj.to_s
       end
     end
 
+    def self.bt_link(assoc_name)
+      model_underscore = name.underscore
+      assoc_name = CGI.escapeHTML(assoc_name.to_s)
+      model_path = Rails.application.routes.url_helpers.send("#{model_underscore.pluralize}_path".to_sym)
+      link = Class.new.extend(ActionView::Helpers::UrlHelper).link_to(name, model_path)
+      model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+    end
+
+    def self.brick_import_template
+      template = constants.include?(:IMPORT_TEMPLATE) ? self::IMPORT_TEMPLATE : suggest_template(false, false, 0)
+      # Add the primary key to the template as being unique (unless it's already there)
+      template[:uniques] = [pk = primary_key.to_sym]
+      template[:all].unshift(pk) unless template[:all].include?(pk)
+      template
+    end
+
   private
 
     def self._brick_get_fks
@@ -267,27 +282,6 @@ module ActiveRecord
       # , is_add_bts, is_add_hms
     )
       is_add_bts = is_add_hms = true
-      wheres = {}
-      has_hm = false
-      params.each do |k, v|
-        case (ks = k.split('.')).length
-        when 1
-          next unless klass._brick_get_fks.include?(k)
-        when 2
-          assoc_name = ks.first.to_sym
-          # Make sure it's a good association name and that the model has that column name
-          next unless (assoc = klass.reflect_on_association(assoc_name))&.klass&.columns&.map(&:name)&.include?(ks.last)
-
-          # So that we can map an association name to any special alias name used in an AREL query
-          ans = (assoc.klass._assoc_names[assoc_name] ||= [])
-          ans << assoc.klass unless ans.include?(assoc.klass)
-          # There is some potential for duplicates when there is an HM-based where in play.  De-duplicate if so.
-          has_hm ||= assoc.macro == :has_many
-          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
-        end
-        wheres[k] = v.split(',')
-      end
-      # distinct! if has_hm
 
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
@@ -301,56 +295,101 @@ module ActiveRecord
       if is_add_bts || is_add_hms
         bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
         bts.each do |_k, bt|
-          # join_array[bt.first] = nil # Store this relation name in our special collection for .joins()
+          # join_array will receive this relation name when calling #brick_parse_dsl
           bt_descrip[bt.first] = [bt.last, bt.last.brick_parse_dsl(join_array, bt.first, translations)]
         end
+        skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
         hms.each do |k, hm|
-          join_array[k] = nil # Store this relation name in our special collection for .joins()
-          hm_counts[k] = nil # Placeholder that will be filled in once we know the proper table alias
+          next if skip_klass_hms.key?(k)
+
+          hm_counts[k] = hm
         end
       end
-      where!(wheres) unless wheres.empty?
+
+      wheres = {}
+      params.each do |k, v|
+        case (ks = k.split('.')).length
+        when 1
+          next unless klass._brick_get_fks.include?(k)
+        when 2
+          assoc_name = ks.first.to_sym
+          # Make sure it's a good association name and that the model has that column name
+          next unless klass.reflect_on_association(assoc_name)&.klass&.columns&.any? { |col| col.name == ks.last }
+
+          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
+        end
+        wheres[k] = v.split(',')
+      end
+
       if join_array.present?
         left_outer_joins!(join_array) # joins!(join_array)
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
         (rel_dupe = dup)._arel_alias_names
         core_selects = selects.dup
-        groups = []
         chains = rel_dupe._brick_chains
-        id_for_tables = {}
+        id_for_tables = Hash.new { |h, k| h[k] = [] }
+        field_tbl_names = Hash.new { |h, k| h[k] = {} }
         bt_columns = bt_descrip.each_with_object([]) do |v, s|
-          tbl_name = chains[v.last.first].first
-          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(tbl_name)
-            groups << (unaliased = "#{tbl_name}.#{id_col}")
-            selects << "#{unaliased} AS \"#{(id_alias = id_for_tables[tbl_name] = "_brfk_#{v.first}__#{id_col}")}\""
-            v.last << id_alias
+          tbl_name = field_tbl_names[v.first][v.last.first] ||= shift_or_first(chains[v.last.first])
+          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(v.first) # was tbl_name
+            # Accommodate composite primary key by allowing id_col to come in as an array
+            (id_col.is_a?(Array) ? id_col : [id_col]).each do |id_part|
+              selects << "#{"#{tbl_name}.#{id_part}"} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+              id_for_tables[v.first] << id_alias
+            end
+            v.last << id_for_tables[v.first]
           end
           if (col_name = v.last[1].last&.last)
+            field_tbl_name = nil
             v.last[1].map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
-              groups << (unaliased = "#{tbl_name = chains[sel_col.first].first}.#{sel_col.last}")
+              field_tbl_name ||= field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])
               # col_name is weak when there are multiple, using sel_col.last instead
-              tbl_name2 = tbl_name.start_with?('public.') ? tbl_name[7..-1] : tbl_name
-              selects << "#{unaliased} AS \"#{(col_alias = "_brfk_#{tbl_name2}__#{sel_col.last}")}\""
+              selects << "#{"#{field_tbl_name}.#{sel_col.last}"} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
               v.last[1][idx] << col_alias
             end
           end
         end
-        group!(core_selects + groups) if hm_counts.any? #  + bt_columns
         join_array.each do |assoc_name|
           # %%% Need to support {user: :profile}
           next unless assoc_name.is_a?(Symbol)
 
-          klass = reflect_on_association(assoc_name)&.klass
-          table_alias = chains[klass].length > 1 ? chains[klass].shift : chains[klass].first
+          table_alias = shift_or_first(chains[klass = reflect_on_association(assoc_name)&.klass])
           _assoc_names[assoc_name] = [table_alias, klass]
         end
-        # Copy entries over
-        hm_counts.keys.each do |k|
-          hm_counts[k] = _assoc_names[k]
+      end
+      # Add derived table JOIN for the has_many counts
+      hm_counts.each do |k, hm|
+        associative = nil
+        count_column = if hm.options[:through]
+                         fk_col = (associative = associatives[hm.name]).foreign_key
+                         hm.foreign_key
+                       else
+                         fk_col = hm.foreign_key
+                         hm.klass.primary_key || '*'
+                       end
+        tbl_alias = "_br_#{hm.name}"
+        pri_tbl = hm.active_record
+        if fk_col.is_a?(Array) # Composite key?
+          on_clause = []
+          fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_tbl.primary_key[idx]}" }
+          joins!("LEFT OUTER
+JOIN (SELECT #{fk_col.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name} GROUP BY #{(1..fk_col.length).to_a.join(', ')}) AS #{tbl_alias}
+  ON #{on_clause.join(' AND ')}")
+        else
+          joins!("LEFT OUTER
+JOIN (SELECT #{fk_col}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name} GROUP BY 1) AS #{tbl_alias}
+  ON #{tbl_alias}.#{fk_col} = #{pri_tbl.table_name}.#{pri_tbl.primary_key}")
         end
       end
+      where!(wheres) unless wheres.empty?
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
+
+  private
+
+    def shift_or_first(ary)
+      ary.length > 1 ? ary.shift : ary.first
+    end
   end
 
   module Inheritance
@@ -549,27 +588,30 @@ class Object
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
           hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
             # The key in each hash entry (fk.first) is the constraint name
-            assoc_name = (assoc = fk.last)[:assoc_name]
-            inverse_assoc_name = assoc[:inverse]&.fetch(:assoc_name, nil)
+            inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
             options = {}
             singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
             macro = if assoc[:is_bt]
                       # Try to take care of screwy names if this is a belongs_to going to an STI subclass
-                      if (primary_class = assoc.fetch(:primary_class, nil)) &&
-                         (sti_inverse_assoc = primary_class.reflect_on_all_associations.find { |a| a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key })
-                        assoc_name = sti_inverse_assoc.options[:inverse_of].to_s || assoc_name
-                      end
+                      assoc_name = if (primary_class = assoc.fetch(:primary_class, nil)) &&
+                                      sti_inverse_assoc = primary_class.reflect_on_all_associations.find do |a|
+                                        a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key
+                                      end
+                                     sti_inverse_assoc.options[:inverse_of]&.to_s || assoc_name
+                                   else
+                                     assoc[:assoc_name]
+                                   end
                       need_class_name = singular_table_name.underscore != assoc_name
                       need_fk = "#{assoc_name}_id" != assoc[:fk]
                       if (inverse = assoc[:inverse])
                         inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], inverse)
                         if (has_ones = ::Brick.config.has_ones&.fetch(inverse[:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
                           inverse_assoc_name = if has_ones[singular_inv_assoc_name]
-                                                need_inverse_of = true
-                                                has_ones[singular_inv_assoc_name]
-                                              else
-                                                singular_inv_assoc_name
-                                              end
+                                                 need_inverse_of = true
+                                                 has_ones[singular_inv_assoc_name]
+                                               else
+                                                 singular_inv_assoc_name
+                                               end
                         end
                       end
                       :belongs_to
@@ -580,12 +622,12 @@ class Object
                       need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
                       # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
                       if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
-                        assoc_name = if has_ones[singular_assoc_name]
-                                      need_class_name = true
-                                      has_ones[singular_assoc_name]
-                                    else
-                                      singular_assoc_name
-                                    end
+                        assoc_name = if (custom_assoc_name = has_ones[singular_assoc_name])
+                                       need_class_name = custom_assoc_name != singular_assoc_name
+                                       custom_assoc_name
+                                     else
+                                       singular_assoc_name
+                                     end
                         :has_one
                       else
                         :has_many
@@ -622,31 +664,34 @@ class Object
           end
           hmts.each do |hmt_fk, fks|
             fks.each do |fk|
-              source = nil
-              this_hmt_fk = if fks.length > 1
-                              singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
-                              source = fk.last
-                              through = fk.first[:alternate_name].pluralize
-                              "#{singular_assoc_name}_#{hmt_fk}"
-                            else
-                              source = fk.last unless hmt_fk.singularize == fk.last
-                              through = fk.first[:assoc_name].pluralize
-                              hmt_fk
-                            end
-              code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
+              through = fk.first[:assoc_name]
+              hmt_name = if fks.length > 1
+                           if fks[0].first[:inverse][:assoc_name] == fks[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
+                             "#{hmt_fk}_through_#{fk.first[:assoc_name]}"
+                           else # Use BT names to provide uniqueness
+                             through = fk.first[:alternate_name].pluralize
+                             singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
+                             "#{singular_assoc_name}_#{hmt_fk}"
+                           end
+                         else
+                           hmt_fk
+                         end
+              source = fk.last unless hmt_name.singularize == fk.last
+              code << "  has_many :#{hmt_name}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
               options = { through: assoc_name }
               options[:source] = source.to_sym if source
-              self.send(:has_many, this_hmt_fk.to_sym, **options)
-            end
-          end
-          # Not NULLables
-          relation[:cols].each do |col, datatype|
-            if (datatype[3] && ar_pks.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
-               ::Brick.config.not_nullables.include?("#{matching}.#{col}")
-              code << "  validates :#{col}, presence: true\n"
-              self.send(:validates, col.to_sym, { presence: true })
+              self.send(:has_many, hmt_name.to_sym, **options)
             end
           end
+          # # Not NULLables
+          # # %%% For the minute we've had to pull this out because it's been troublesome implementing the NotNull validator
+          # relation[:cols].each do |col, datatype|
+          #   if (datatype[3] && ar_pks.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
+          #      ::Brick.config.not_nullables.include?("#{matching}.#{col}")
+          #     code << "  validates :#{col}, not_null: true\n"
+          #     self.send(:validates, col.to_sym, { not_null: true })
+          #   end
+          # end
         end
         code << "end # model #{model_name}\n\n"
       end # class definition
@@ -665,14 +710,26 @@ class Object
         code << "    @#{table_name} = #{model.name}#{model.primary_key ? ".order(#{model.primary_key.inspect})" : '.all'}\n"
         code << "    @#{table_name}.brick_select(params)\n"
         code << "  end\n"
+        self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
           ::Brick.set_db_schema(params)
-          ar_relation = model.all # model.primary_key ? model.order(model.primary_key) : model.all
+          if request.format == :csv # Asking for a template?
+            require 'csv'
+            exported_csv = CSV.generate(force_quotes: false) do |csv_out|
+              model.df_export(model.brick_import_template).each { |row| csv_out << row }
+            end
+            render inline: exported_csv, content_type: request.format
+            return
+          elsif request.format == :js # Asking for JSON?
+            render inline: model.df_export(model.brick_import_template).to_json, content_type: request.format
+            return
+          end
+
+          ar_relation = model.primary_key ? model.order("#{model.table_name}.#{model.primary_key}") : model.all
           @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
-          counts = hm_counts.each_with_object([]) { |v, s| s << "COUNT(DISTINCT #{v.last.first}.#{v.last.last.primary_key}) AS _br_#{v.first}_ct" }
-          puts counts.inspect
+          counts = hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
           # *selects, 
           instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
           # binding.pry
@@ -705,6 +762,22 @@ class Object
             code << "  end\n"
             self.define_method :update do
               ::Brick.set_db_schema(params)
+
+              if request.format == :csv # Importing CSV?
+                require 'csv'
+                # See if internally it's likely a TSV file (tab-separated)
+                tab_counts = []
+                5.times { tab_counts << request.body.readline.count("\t") unless request.body.eof? }
+                request.body.rewind
+                separator = "\t" if tab_counts.length > 0 && tab_counts.uniq.length == 1 && tab_counts.first > 0
+                result = model.df_import(CSV.parse(request.body, { col_sep: separator || :auto }), model.brick_import_template)
+                # render inline: exported_csv, content_type: request.format
+                return
+              # elsif request.format == :js # Asking for JSON?
+              #   render inline: model.df_export(true).to_json, content_type: request.format
+              #   return
+              end
+
               instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(params[:id].split(','))))
               obj = obj.first if obj.is_a?(Array)
               obj.send(:update, send(params_name = params_name.to_sym))
@@ -730,7 +803,8 @@ class Object
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
       if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
-        [ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name]), true]
+        plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
+        [hm_assoc[:alternate_name] == name.underscore ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural, true]
       else
         [ActiveSupport::Inflector.pluralize(hm_assoc[:inverse_table]), nil]
       end
@@ -987,18 +1061,16 @@ module Brick
 
       return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
 
-      cnstr_name = "hm_#{cnstr_name}"
-      if (assoc_hm = hms.fetch(cnstr_name, nil))
+      if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
         assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
         assoc_hm[:inverse] = assoc_bt
       else
-        assoc_hm = hms[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
       end
       assoc_bt[:inverse] = assoc_hm
-      # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
     end
   end
 end

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

@@ -64,6 +64,14 @@ module Brick
               is_template_exists
             end
 
+            def path_keys(fk_name, obj_name, pk)
+              if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
+                fk_name.zip(pk.map { |pk_part| "#{obj_name}.#{pk_part}" })
+              else
+                [[fk_name, "#{obj_name}.#{pk}"]]
+              end.map { |x| "#{x.first}: #{x.last}"}.join(', ')
+            end
+
             alias :_brick_find_template :find_template
             def find_template(*args, **options)
               return  _brick_find_template(*args, **options) unless @_brick_model
@@ -72,29 +80,36 @@ module Brick
               pk = @_brick_model.primary_key
               obj_name = model_name.underscore
               table_name = model_name.pluralize.underscore
+              template_link = nil
               bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
-              hms_columns = +'' # Used for 'index'
+              hms_columns = [] # Used for 'index'
+              skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
               hms_headers = hms.each_with_object([]) do |hm, s|
-                hm_assoc = hm.last
+                hm_stuff = [(hm_assoc = hm.last), "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}", (assoc_name = hm.first)]
+                hm_fk_name = if hm_assoc.options[:through]
+                               associative = associatives[hm_assoc.name]
+                               "'#{associative.name}.#{associative.foreign_key}'"
+                             else
+                               hm_assoc.foreign_key
+                             end
                 if args.first == 'index'
-                  hm_fk_name = if hm_assoc.options[:through]
-                                 associative = associatives[hm_assoc.name]
-                                 "'#{associative.name}.#{associative.foreign_key}'"
-                               else
-                                 hm_assoc.foreign_key
-                               end
                   hms_columns << if hm_assoc.macro == :has_many
-"<td>
-  <%= ct = #{obj_name}._br_#{hm.first}_ct
-      link_to \"#\{ct\} #{hm.first}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless ct.zero? %>
-</td>\n"
+                                   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
+"<%= ct = #{set_ct}
+     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
                                  else # has_one
-"<td>
-  <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
-</td>\n"
+"<%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>\n"
                                  end
+                elsif args.first == 'show'
+                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_fk_name, "@#{obj_name}&.first&", pk)} }) %>\n"
                 end
-                s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
+                s << hm_stuff
               end
 
               schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
@@ -103,6 +118,13 @@ module Brick
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
                               .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
               css = +"<style>
+#dropper {
+  background-color: #eee;
+}
+#btnImport {
+  display: none;
+}
+
 table {
   border-collapse: collapse;
   margin: 25px 0;
@@ -114,9 +136,12 @@ table {
 
 table thead tr th, table tr th {
   background-color: #009879;
-  color: #ffffff;
+  color: #fff;
   text-align: left;
 }
+table thead tr th a, table tr th a {
+  color: #80FFB8;
+}
 
 table th, table td {
   padding: 0.2em 0.5em;
@@ -125,6 +150,9 @@ table th, table td {
 .show-field {
   background-color: #004998;
 }
+.show-field a {
+  color: #80B8D2;
+}
 
 table tbody tr {
   border-bottom: thin solid #dddddd;
@@ -177,10 +205,10 @@ def hide_bcrypt(val)
 end %>"
 
               if ['index', 'show', 'update'].include?(args.first)
-                # Example:  <% bts = { "site_id" => [:site, Site, "id"], "study_id" => [:study, Study, "id"], "study_country_id" => [:study_country, StudyCountry, "id"], "user_id" => [:user, User, "id"], "role_id" => [:role, Role, "id"] } %>
                 css << "<% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} } %>"
               end
 
+              # %%% When doing schema select, if there's an ID then remove it, or if we're on a new page go to index
               script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
 var brickSchema;
@@ -237,11 +265,106 @@ function changeout(href, param, value) {
 </script>"
               inline = case args.first
                        when 'index'
+                         obj_pk = if pk&.is_a?(Array) # Composite primary key?
+                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]"
+                                  elsif pk
+                                    "#{obj_name}.#{pk}"
+                                  end
+                         if Object.const_defined?('DutyFree')
+                           template_link = "
+  <%= link_to 'CSV', #{table_name}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
+  <div id=\"dropper\" contenteditable=\"true\"></div>
+  <input type=\"button\" id=\"btnImport\" value=\"Import\">"
+                         end
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
-<h1>#{model_name.pluralize}</h1>
+<h1>#{model_name.pluralize}</h1>#{template_link}
+<script>
+var dropperDiv = document.getElementById(\"dropper\");
+var btnImport = document.getElementById(\"btnImport\");
+var droppedTSV;
+if (dropperDiv) { // Other interesting events: blur keyup input
+  dropperDiv.addEventListener(\"paste\", function (evt) {
+    droppedTSV = evt.clipboardData.getData('text/plain');
+    var html = evt.clipboardData.getData('text/html');
+    var tbl = html.substring(html.indexOf(\"<tbody>\") + 7, html.lastIndexOf(\"</tbody>\"));
+    console.log(tbl);
+    btnImport.style.display = droppedTSV.length > 0 ? \"block\" : \"none\";
+  });
+  btnImport.addEventListener(\"click\", function () {
+    fetch(changeout(<%= #{obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'text/tab-separated-values' },
+      body: droppedTSV
+    }).then(function (tsvResponse) {
+      btnImport.style.display = \"none\";
+      console.log(\"toaster\", tsvResponse);
+    });
+  });
+}
+var sheetUrl;
+var spreadsheetId;
+var sheetsLink = document.getElementById(\"sheetsLink\");
+function gapiLoaded() {
+  // Have a click on the sheets link to bring up the sign-in window.  (Must happen from some kind of user click.)
+  sheetsLink.addEventListener(\"click\", async function (evt) {
+    evt.preventDefault();
+    await gapi.load(\"client\", function () {
+      gapi.client.init({ // Load the discovery doc to initialize the API
+        clientId: \"487319557829-fgj4u660igrpptdji7ev0r5hb6kh05dh.apps.googleusercontent.com\",
+        scope: \"https://www.googleapis.com/auth/spreadsheets https://www.googleapis.com/auth/drive.file\",
+        discoveryDocs: [\"https://sheets.googleapis.com/$discovery/rest?version=v4\"]
+      }).then(function () {
+        gapi.auth2.getAuthInstance().isSignedIn.listen(updateSignInStatus);
+        updateSignInStatus(gapi.auth2.getAuthInstance().isSignedIn.get());
+      });
+    });
+  });
+}
+
+async function updateSignInStatus(isSignedIn) {
+  if (isSignedIn) {
+    console.log(\"turds!\");
+    await gapi.client.sheets.spreadsheets.create({
+      properties: {
+        title: #{table_name.inspect},
+      },
+      sheets: [
+        // sheet1, sheet2, sheet3
+      ]
+    }).then(function (response) {
+      sheetUrl = response.result.spreadsheetUrl;
+      spreadsheetId = response.result.spreadsheetId;
+      sheetsLink.setAttribute(\"href\", sheetUrl); // response.result.spreadsheetUrl
+      console.log(\"x1\", sheetUrl);
+
+      // Get JSON data
+      fetch(changeout(<%= #{table_name}_path(format: :js).inspect.html_safe %>, \"_brick_schema\", brickSchema)).then(function (response) {
+        response.json().then(function (data) {
+          gapi.client.sheets.spreadsheets.values.append({
+            spreadsheetId: spreadsheetId,
+            range: \"Sheet1\",
+            valueInputOption: \"RAW\",
+            insertDataOption: \"INSERT_ROWS\"
+          }, {
+            range: \"Sheet1\",
+            majorDimension: \"ROWS\",
+            values: data,
+          }).then(function (response2) {
+//            console.log(\"beefcake\", response2);
+          });
+        });
+      });
+    });
+    window.open(sheetUrl, '_blank');
+  }
+}
+</script>
+<script async defer src=\"https://apis.google.com/js/api.js\" onload=\"gapiLoaded()\"></script>
+
+
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
 <table id=\"#{table_name}\">
   <thead><tr>#{'<th></th>' if pk}
@@ -249,26 +372,27 @@ function changeout(href, param, value) {
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
-      BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
+      BT <%= bt[1].bt_link(bt.first) %>
     <% else %>
       <%= col %>
     <% end %>
     </th>
   <% end %>
-  #{hms_headers.map { |h| "<th>#{h.last}</th>\n" }.join}
+  <%# 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 { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.pluralize}_path) %></th>\n" }.join}
   </tr></thead>
 
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk}
+    <td><%= link_to '⇛', #{obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% #{obj_name}.attributes.each do |k, val| %>
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && k.end_with?('_ct')) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%# binding.pry if bt.first == :user %>
-        <% bt_txt = bt[1].brick_descrip(#{obj_name}, @_brick_bt_descrip[bt.first][1].map { |z| #{obj_name}.send(z.last) }, @_brick_bt_descrip[bt.first][2]) %>
-        <% bt_id_col = @_brick_bt_descrip[bt.first][2]; bt_id = #{obj_name}.send(bt_id_col) if bt_id_col %>
+        <%# binding.pry # Postgres column names are limited to 63 characters %>
+        <% bt_txt = bt[1].brick_descrip(#{obj_name}, @_brick_bt_descrip[bt.first][1].map { |z| #{obj_name}.send(z.last[0..62]) }, @_brick_bt_descrip[bt.first][2]) %>
+        <% bt_id_col = @_brick_bt_descrip[bt.first][2]; bt_id = #{obj_name}.send(*bt_id_col) if bt_id_col&.present? %>
         <%= bt_id ? link_to(bt_txt, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
         <%#= Previously was:  bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
       <% else %>
@@ -276,7 +400,7 @@ function changeout(href, param, value) {
       <% end %>
       </td>
     <% end %>
-#{hms_columns}
+    <td>#{hms_columns.join('</td><td>')}</td>
     <!-- td>X</td -->
   </tr>
   </tbody>
@@ -294,12 +418,13 @@ function changeout(href, param, value) {
 <%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
 <% if obj %>
   <%= # path_options = [obj.#{pk}]
-   # path_options << { '_brick_schema':  } if 
+   # path_options << { '_brick_schema':  } if
    # url = send(:#{model_name.underscore}_path, obj.#{pk})
-   form_for(obj) do |f| %>
+   form_for(obj.becomes(#{model_name})) do |f| %>
   <table>
   <% @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
+    <%# %%% Accommodate composite keys %>
     <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
     <% if (bt = bts[k])
@@ -308,9 +433,10 @@ function changeout(href, param, value) {
       # %%% Only do this if the user has permissions to edit this bt field
       if bt.length < 4
         bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
-        bt[1].order(:#{pk}).each { |obj| option_detail << [obj.brick_descrip, obj.#{pk}] }
+        # %%% Accommodate composite keys for obj.pk at the end here
+        bt[1].order(bt[1].primary_key).each { |obj| option_detail << [obj.brick_descrip, obj.send(bt[1].primary_key)] }
       end %>
-      BT <%= \"#\{bt.first\}-\" unless bt_name.underscore == bt.first.to_s %><%= bt_name %>
+      BT <%= bt[1].bt_link(bt.first) %>
     <% else %>
       <%= k %>
     <% end %>
@@ -346,21 +472,24 @@ function changeout(href, param, value) {
   </table>
   <% end %>
 
-  #{hms_headers.map do |hm|
-    next unless (pk = hm.first.klass.primary_key)
-
-  "<table id=\"#{hm_name = hm.first.name.to_s}\">
-    <tr><th>#{hm.last}</th></tr>
-    <% collection = @#{obj_name}.first.#{hm_name}
-    collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
-    if collection.empty? %>
-      <tr><td>(none)</td></tr>
-    <% else %>
-      <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
-        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
-      <% end %>
-    <% end %>
-  </table>" end.join}
+  #{hms_headers.each_with_object(+'') do |hm, s|
+    if (pk = hm.first.klass.primary_key)
+      s << "<table id=\"#{hm_name = hm.first.name.to_s}\">
+        <tr><th>#{hm[3]}</th></tr>
+        <% collection = @#{obj_name}.first.#{hm_name}
+        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
+        if collection.empty? %>
+          <tr><td>(none)</td></tr>
+        <% else %>
+          <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
+          <% end %>
+        <% end %>
+      </table>"
+    else
+      s
+    end
+  end}
 <% end %>
 #{script}"
 

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -103,11 +103,8 @@ module Brick
 
     def get_bts_and_hms(model)
       bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
-        # So that we can map an association name to any special alias name used in an AREL query
-        ans = (model._assoc_names[a.name] ||= [])
         next if !const_defined?(a.name.to_s.singularize.camelize) && ::Brick.config.exclude_tables.include?(a.plural_name)
 
-        ans << a.klass unless ans.include?(a.klass)
         case a.macro
         when :belongs_to
           s.first[a.foreign_key] = [a.name, a.klass]
@@ -129,9 +126,7 @@ module Brick
           skip_hms[hmt.last.name] = nil
         end
       end
-      skip_hms.each do |k, _v|
-        puts hms.delete(k).inspect
-      end
+      skip_hms.each { |k, _v| hms.delete(k) }
       [bts, hms, associatives]
     end
 
@@ -240,6 +235,12 @@ module Brick
       end
     end
 
+    # Skip showing counts for these specific has_many associations when building auto-generated #index views
+    # @api public
+    def skip_index_hms=(value)
+      Brick.config.skip_index_hms = value
+    end
+
     # Associations to treat as a has_one
     # @api public
     def has_ones=(hos)
@@ -421,9 +422,7 @@ ActiveSupport.on_load(:active_record) do
               end
 
               result = result.map do |attributes|
-                values = klass.initialize_attributes(attributes).values
-
-                columns.zip(values).map do |column, value|
+                columns.zip(klass.initialize_attributes(attributes).values).map do |column, value|
                   column.type_cast(value)
                 end
               end

data/lib/generators/brick/install_generator.rb

@@ -111,11 +111,16 @@ module Brick
 # # to be the primary key.)
 #{bar}
 
-# # Skip creating a has_many association for these
+# # Skip creating a has_many association for these (only retain the belongs_to built from this additional_reference).
 # # (Uses the same exact three-part format as would define an additional_reference)
 # # Say for instance that we didn't care to display the favourite colours that users have:
 # Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
 
+# # Skip showing counts for these specific has_many associations when building auto-generated #index views.
+# # When there are related tables with a significant number of records, this can lessen the load on the database
+# # considerably, sometimes fixing what might appear to be an index page that just \"hangs\" for no apparent reason.
+Brick.skip_index_hms = ['User.litany_of_woes']
+
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
 # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
 # # using the primary model name and the association name which you instead want to have treated as a \"has_one\":

metadata

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