brick 1.0.228 → 1.0.229

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ada376a5ef8d35110b7228a583cdcb18e5246fcfa52b975aff872c9a2ac7e37d
-  data.tar.gz: 7621c881fcacca08f8b9543371fbcb190c0513e5d8c8b6bc2c767a51a48ef43e
+  metadata.gz: a5484fa8f1c3c64e6d10340f54ca460668cfa176373b0d2322fe1ede86cfad8c
+  data.tar.gz: bda7b20486fb89f0b5775975957ea7f3b0de3b51a635e42e4a21dbec3b71478f
 SHA512:
-  metadata.gz: 8ccbeae9b7cf7874653de1666af8a708e77126248eadec4cd80d1766f33063f93a7b198aabdb02895e9a8456d89b63f36a15d6348a70a9b9ead928b7a29c1567
-  data.tar.gz: 7fc00087943b2b7fdab18783793057772f59a1e98896239a8cc4c4d91f7aa41201265931393201a399c3b3261186a7e56deb4d8703cb46676eafd5a10ab3fa22
+  metadata.gz: c6f01661b3423287dc4ce703790e04d292f902a14dc23e1e3b68a4891c9347adeb2083594717af1e0ca93404a6e7748e2f393885d4d37944b595757ee5a4b6b8
+  data.tar.gz: 6967a37c53be78011f1b0e7b5eb69ecf1a7779b1c0c312e2288a6ab701fdb1ab2724345957d178970df06ee26481bd1470e8fb5ede8d14e06d6ac0a4a6418248

data/lib/brick/extensions.rb

@@ -979,7 +979,8 @@ module ActiveRecord
           next
         end
 
-        tbl_alias = unique63("b_r_#{hm.name}", previous)
+        tbl_alias = "b_r_#{hm.name}"
+        tbl_alias = unique63(tbl_alias, previous) if is_postgres
         on_clause = []
         hm_selects = if !pri_key.is_a?(Array) # Probable standard key?
                        if fk_col.is_a?(Array) # Foreign is composite but not Primary?  OK, or choose the first part of the foreign key if nothing else
@@ -1031,19 +1032,28 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
       unless wheres.empty?
         # Rewrite the wheres to reference table and correlation names built out by AREL
         where_nots = {}
+        where_comparisons = []
         wheres2 = wheres.each_with_object({}) do |v, s|
           is_not = if v.first[-1] == '!'
                      v[0] = v[0][0..-2] # Take off ending ! from column name
                    end
-          if (v_parts = v.first.split('.')).length == 1
-            (is_not ? where_nots : s)[v.first] = v.last
+          tbl_and_col_name = if (v_parts = v.first.split('.')).length == 1
+                               []
+                             else
+                               [brick_links[v_parts[0..-2].join('.')].split('.').last]
+                             end
+          tbl_and_col_name << v_parts.last
+          if ['>', '<'].include?(first_char = v.last.first[0]) # Greater than or less than?
+            col_name = v.last.first[1..-1]
+            col_name = "'#{col_name}'" unless [:integer, :boolean, :decimal, :float].include?(klass.columns_hash[v.first].type)
+            where_comparisons << "#{tbl_and_col_name.join('.')} #{first_char} #{col_name}"
           else
-            tbl_name = brick_links[v_parts[0..-2].join('.')].split('.').last
-            (is_not ? where_nots : s)["#{tbl_name}.#{v_parts.last}"] = v.last
+            (is_not ? where_nots : s)[tbl_and_col_name.join('.')] = v.last
           end
         end
         if respond_to?(:where!)
           where!(wheres2) if wheres2.present?
+          where_comparisons.each { |wc| where!(wc) }
           if where_nots.present?
             self.where_clause += WhereClause.new(predicate_builder.build_from_hash(where_nots)).invert
           end
@@ -1106,8 +1116,7 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
 
     # Build out an AR relation that queries for a list of objects, and include all the appropriate JOINs to later apply DSL using #brick_descrip
     def brick_list
-      pks = klass.primary_key.is_a?(String) ? [klass.primary_key] : klass.primary_key
-      selects = pks.each_with_object([]) { |pk, s| s << pk unless s.include?(pk) }
+      selects = klass._pk_as_array.each_with_object([]) { |pk, s| s << pk unless s.include?(pk) }
       # Get foreign keys for anything marked to be auto-preloaded, or a self-referencing JOIN
       klass_cols = klass.column_names
       reflect_on_all_associations.each do |a|
@@ -1740,51 +1749,56 @@ class Object
       built_model = Class.new(base_model) do |new_model_class|
         (schema_module || Object).const_set(chosen_name, new_model_class) unless is_generator
         @_brick_relation = relation
-        # Enable Elasticsearch for this one?
-        access = ::Brick.elasticsearch_models&.is_a?(Hash) ? ::Brick.elasticsearch_models[name] : ::Brick.elasticsearch_models
-        @_brick_es_crud ||= case access
-                            when String
-                              access
-                            when :all, :full
-                              'icrud' # Auto-create index, and full CRUD
-                            else
-                              ''
-                            end
-        unless @_brick_es_crud.blank?
+        # Enable Elasticsearch based on the table name?
+        if (@_brick_es_crud = ::Brick.elasticsearch_models&.fetch(table_name, nil))
           include ::Elasticsearch::Model
-          code << "  include Elasticsearch::Model\n"
           if @_brick_es_crud.index('i') # Enable auto-creation of indexes on import?
             class << self
               alias _original_import import
               def import(options={}, &block)
-                self.__elasticsearch__.create_index! unless self.__elasticsearch__.index_exists?
+                unless self.__elasticsearch__.index_exists?
+                  self.__elasticsearch__.create_index!
+                  ::Brick.elasticsearch_existings << self.table_name
+                end
                 _original_import(options={}, &block)
               end
             end
           end
-          if @_brick_es_crud.index('c') || @_brick_es_crud.index('u') || @_brick_es_crud.index('d')
+          if ::Elasticsearch::Model.const_defined?('Callbacks') &&
+             @_brick_es_crud.index('c') || @_brick_es_crud.index('u') || @_brick_es_crud.index('d')
             include ::Elasticsearch::Model::Callbacks
-            code << "  include Elasticsearch::Model::Callbacks\n"
+            is_include_es_callbacks = true
+          end
+          # Create mappings for all text columns
+          mappings do
+            has_mappings = nil
+            new_model_class.columns.select { |col| [:string, :text].include?(col.type) }.each do |string_col|
+              unless has_mappings
+                code << "  include Elasticsearch::Model\n"
+                code << "  include Elasticsearch::Model::Callbacks\n" if is_include_es_callbacks
+                code << "  mappings do\n"
+                has_mappings = true
+              end
+              code << "    indexes :#{string_col.name}, type: #{string_col.type.to_s.inspect}\n"
+              indexes string_col.name.to_sym, type: string_col.type.to_s
+            end
+            code << "  end\n" if has_mappings
           end
           if @_brick_es_crud.index('r')
-            # Customer.__elasticsearch__.search('taco').to_a
+            class << self
+              # Search and hydrate records using only Elasticsearch data
+              define_method :search do |q|
+                self.__elasticsearch__.search(q).raw_response.body['hits']['hits'].map do |hit|
+                  obj = self.new(hit['_source'])
+                  obj.instance_variable_set(:@new_record, false) # Don't want to accidentally save a new one
+                  obj
+                end
+              rescue Elastic::Transport::Transport::Errors::NotFound => e
+                self.create_index! if @_brick_es_crud.index('i')
+                []
+              end
+            end
           end
-          # # Need some mappings for text columns
-          # mappings do
-          #   indexes :company_name, type: 'text'
-          #   indexes :country, type: 'text'
-          # end
-          # def self.search(q)
-          #   s = self.__elasticsearch__.search(q)
-          #   binding.pry
-          #   s.to_a
-          # #   class Elasticsearch::Model::Response::Response
-          # #     def to_a
-          # #   end
-          # # rescue Elastic::Transport::Transport::Errors::NotFound => e
-          # #   self.create_index!
-          # #   self.__elasticsearch__.search(q)
-          # end
         end
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
@@ -2272,6 +2286,39 @@ class Object
             render json: { data: result } # [ver, result]
           end
 
+          self.define_method :search do
+            # TODO: Make sure at least one index is actually present which allows for reading before attempting
+            if (q = params['qry'] || params['_brick_es']) # Elasticsearch query?
+              @indexes = ::Brick.elasticsearch_existings
+              hits = Elasticsearch::Model.client.search({index: @indexes.join(','), q: q, size: 100})
+              model_infos = {}
+              # Number of indexes used:  hits.body['_shards']['total']
+              @count = hits.body['hits']['total']['value']
+              @results = hits.body['hits']['hits'].map do |x|
+                klass = ::Brick.relations[x['_index']][:class_name].constantize
+                model_info = model_infos[klass] ||= [
+                  klass.primary_key,
+                  klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
+                ]
+                obj = klass.new(x['_source'])
+                [
+                  klass.name,
+                  obj.send(model_info.first),
+                  obj.brick_descrip(
+                    model_info.last&.first&.map { |col2| obj.send(col2.last) },
+                    obj.send(klass.primary_key)
+                  ),
+                  send("#{klass._brick_index(:singular)}_path".to_sym, obj),
+                  x['_score']
+                ]
+              end
+              respond_to do |format|
+                format.js { render json: { result: @results } }
+                format.any {}
+              end
+            end
+          end
+
           return [new_controller_class, code + "end # BrickGem controller\n"]
         when 'BrickOpenapi'
           is_openapi = true
@@ -2584,7 +2631,26 @@ class Object
               render json: { result: ::Brick.unexclude_column(table_name, col) }
             elsif is_json && (q = params['_brick_es']) # Elasticsearch
               # Make sure that the index is actually present and we allow reading before attempting
-              es_result = model.__elasticsearch__.search(q).to_a if (es_perms = model.instance_variable_get(:@_brick_es_crud)).index('r')
+              if (es_perms = model.instance_variable_get(:@_brick_es_crud) ||
+                             # If a perms instance variable is missing for this model, get the perms ...
+                             (set = true && ::Brick.elasticsearch_models&.fetch(model.table_name, nil))
+                 ) && (
+                  # ... then set it on the model
+                  (set && model.instance_variable_set(:@_brick_es_crud, es_perms)) || es_perms
+                 )&.index('r')
+                es_result = begin
+                              model.__elasticsearch__.search(q)
+                            rescue Elastic::Transport::Transport::Errors::NotFound => e
+                              if @_brick_es_crud.index('i')
+                                self.__elasticsearch__.create_index!
+                                # model.import
+                                ::Brick.elasticsearch_existings << self.table_name
+                                model.__elasticsearch__.search(q)
+                              else
+                                []
+                              end
+                            end
+              end
               render json: { result: es_result }
             else
               real_model = model.real_model(params)

data/lib/brick/rails/engine.rb

@@ -671,7 +671,9 @@ window.addEventListener(\"popstate\", linkSchemas);
             def find_template(*args, **options)
               find_template_err = nil
               unless (model_name = @_brick_model&.name) ||
-                     (is_search = ::Brick.config.add_search && args[0..1] == ['search', ['brick_gem']]) ||
+                     (is_search = ::Brick.config.add_search && args[0..1] == ['search', ['brick_gem']] &&
+                                  ::Brick.elasticsearch_existings&.length&.positive?
+                     ) ||
                      (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
                      (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
                      (is_crosstab = args[0..1] == ['crosstab', ['brick_gem']])
@@ -792,7 +794,7 @@ window.addEventListener(\"popstate\", linkSchemas);
                                 b[0] = '' if b[0].is_a?(Symbol)
                                 a.first <=> b.first
                               end.each_with_object(+'') do |rel, s|
-                                next if rel.first.blank? || rel.last[:cols].empty? ||
+                                next if rel.first.is_a?(Symbol) || rel.first.blank? || rel.last[:cols].empty? ||
                                         ::Brick.config.exclude_tables.include?(rel.first)
 
                                 # %%% When table_name_prefixes are use then during rendering empty non-TNP
@@ -805,7 +807,7 @@ window.addEventListener(\"popstate\", linkSchemas);
                               end.html_safe
               # Options for special Brick pages
               prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
-              [['Search', ::Brick.config.add_search],
+              [['Search', is_search],
                ['Status', ::Brick.config.add_status],
                ['Orphans', is_orphans],
                ['Crosstab', is_crosstab]].each do |table_option, show_it|
@@ -1084,13 +1086,14 @@ end
 <% end
    # SEARCH BOX
    if @_brick_es&.index('r') # Must have at least Elasticsearch Read access %>
-  <input type=\"text\" id=\"esSearch\"><a href=\"\">S</a>
+  <input type=\"text\" id=\"esSearch\" class=\"dimmed\">
   <script>
-    var esSearch = document.getElementById(\"esSearch\")
+    var esSearch = document.getElementById(\"esSearch\");
+    var usedTerms = {};
     var isEsFiltered = false;
     esSearch.addEventListener(\"input\", function () {
       var gridTrs;
-      if (this.value.length > 2) { # At least 3 letters in the search term
+      if (this.value.length > 2 && usedTerms[this.value] !== null) { // At least 3 letters in the search term
         var es = doFetch(\"POST\", {_brick_es: this.value},
           function (p) {p.text().then(function (response) {
             var result = JSON.parse(response).result;
@@ -1111,13 +1114,16 @@ end
                 if (!isHit) row.style.display = \"none\";
               }
               isEsFiltered = true;
+              esSearch.className = \"\";
             } else {
               if (isEsFiltered) { // Show all rows and gray the search box
+                usedTerms[this.value] = null; // No results for this term
                 gridTrs = [... grid.querySelectorAll(\"tr\")];
                 for (var i = 1; i < gridTrs.length; ++i) {
                   gridTrs[i].style.display = \"table-row\";
                 }
               }
+              esSearch.className = \"dimmed\";
             }
           });}
         );
@@ -1127,6 +1133,7 @@ end
           for (var i = 1; i < gridTrs.length; ++i) {
             gridTrs[i].style.display = \"table-row\";
           }
+          esSearch.className = \"dimmed\";
         }
       }
     });
@@ -1211,21 +1218,28 @@ end
 +"#{css}
 <p class=\"flashNotice\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
-<select id=\"tbl\">#{table_options}</select>
-<h1>Search</h1>
+<select id=\"tbl\">#{table_options}</select><br><br>
+<form method=\"get\">
+  <input type=\"text\" name=\"qry\"><input type=\"submit\", value=\"Search\">
+</form>
+<% if @results.present? %>
+<div id=\"rowCount\"><b><%= @count %> results from: </b><%= @indexes.sort.join(', ') %></div>
+<% end %>
 <table id=\"resourceName\" class=\"shadow\"><thead><tr>
   <th>Resource</th>
   <th>Description</th>
-  <th>ID</th>
+  <th>Score</th>
 </tr></thead>
 <tbody>
-<% # @results.each do |r| %>
+<% @results&.each do |r| %>
   <tr>
-  <td><%= %></td>
-  <td<%=  %></td>
-  <td<%=  %></td>
+  <td><%= link_to (r[3]) do %><%= r[0] %><br>
+      <%= r[1] %><% end %>
+  </td>
+  <td><%= r[2] %></td>
+  <td><%= '%.3f' % r[4] %></td>
   </tr>
-<% # end %>
+<% end %>
 </tbody></table>
 #{script}"
                          end
@@ -1645,9 +1659,13 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
    # %%% Create a smart javascript routine which can do this client-side %>
 [... document.getElementsByTagName(\"TH\")].forEach(function (th) {
   th.addEventListener(\"click\", function (e) {
-    var xOrder;
-    if (xOrder = this.getAttribute(\"x-order\"))
+    var xOrder,
+        currentOrder;
+    if (xOrder = this.getAttribute(\"x-order\")) {
+      if ((currentOrder = changeout(location.href, \"_brick_order\")) === xOrder)
+        xOrder = \"-\" + xOrder;
       location.href = changeout(location.href, \"_brick_order\", xOrder);
+    }
   });
 });
 document.querySelectorAll(\"input, select\").forEach(function (inp) {

data/lib/brick/reflect_tables.rb

@@ -28,7 +28,8 @@ module Brick
             def method_missing(name, *args, &block)
               _original_method_missing(name, *args, &block)
             rescue Elastic::Transport::Transport::Errors::NotFound => e
-              if (missing_index = args.last&.fetch(:defined_params, nil)&.fetch(:index, nil))
+              if (missing_index = args.last&.fetch(:defined_params, nil)&.fetch(:index, nil)) &&
+                 ::Brick.elasticsearch_models&.fetch(missing_index, nil)&.include?('i')
                 self.indices.create({ index: missing_index,
                                       body: { settings: {}, mappings: { properties: {} } } })
                 puts "Auto-creating missing index \"#{missing_index}\""
@@ -39,7 +40,7 @@ module Brick
             end
           end
         end
-        if ::Elasticsearch.const_defined?('Model')
+        if ::Elasticsearch.const_defined?('Model') && ::Brick.elasticsearch_models
           # By setting the environment variable ELASTICSEARCH_URL then you can specify an Elasticsearch/Opensearch host
           host = (client = ::Elasticsearch::Model.client).transport.hosts.first
           es_uri = URI.parse("#{host[:protocol]}://#{host[:host]}:#{host[:port]}")
@@ -47,34 +48,19 @@ module Brick
           begin
             cluster_info = client.info.body
             if (es_ver = cluster_info['version'])
-              ::Brick.elasticsearch_models = :all
               puts "Found Elasticsearch gem and #{'local ' unless es_uri}#{es_ver['distribution'].titleize} #{es_ver['number']} installation#{" at #{es_uri}" if es_uri}."
-              puts "Enable Elasticsearch support by either setting \"::Brick.elasticsearch_models = :all\" or by picking specific models by name."
-
-              # # Auto-create when trying to import and there is a missing index
-              # ::Elasticsearch::Model::Importing.class_exec do
-              # end
+              if ::Brick.elasticsearch_models.empty?
+                puts "Enable Elasticsearch support by either setting \"::Brick.elasticsearch_models = :all\" or by picking specific models by name."
+              end
+            else
+              ::Brick.elasticsearch_models = nil
             end
           rescue StandardError => e # Errno::ECONNREFUSED
+            ::Brick.elasticsearch_models = nil
             puts "Found Elasticsearch gem, but could not connect to #{'local ' unless es_uri}Elasticsearch/Opensearch server#{" at #{es_uri}" if es_uri}."
           end
-        # require 'net/http'
-        #   begin
-        #     es_uri = ENV['ELASTICSEARCH_URL']
-        #     binding.pry
-        #     cluster_info = JSON.parse(Net::HTTP.get(URI.parse(es_uri || 'http://localhost:9200')))
-        #     if (es_ver = cluster_info['version'])
-        #       ::Brick.elasticsearch_models = :all
-        #       puts "Found Elasticsearch gem and #{'local ' unless es_uri}#{es_ver['distribution'].titleize} #{es_ver['number']} installation#{" at #{es_uri}" if es_uri}."
-        #       puts "Enable Elasticsearch support by either setting \"::Brick.elasticsearch_models = :all\" or by picking specific models by name."
-        #     end
-        #   rescue StandardError => e
-        #   end
         end
       end
-      # client = Elasticsearch::Client.new(host: 'https://my-elasticsearch-host.example')
-      # client.ping
-      # client.search(q: 'test')
 
       # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
       # the default DEFERRED mode.
@@ -527,6 +513,38 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         end
       end
 
+      if ems = ::Brick.elasticsearch_models # ['comments']
+        access = case ems
+                 when Hash, String # Hash is a list of resource names and ES permissions such as 'r' or 'icr'
+                   ems
+                 when :all
+                   'crud' # All CRUD
+                 when :full
+                   'icrud' # Also able to auto-create indexes
+                 else
+                   ''
+                 end
+        # Rewriting this to have all valid indexes and their perms
+        ::Brick.elasticsearch_models = unless access.blank?
+          # Find all existing indexes
+          client = Elastic::Transport::Client.new
+          ::Brick.elasticsearch_existings = client.perform_request('GET', '_aliases').body.each_with_object([]) do |entry, s|
+            s << entry.first if relations.include?(entry.first)
+            entry.last.fetch('aliases', nil)&.each { |k, _v| s << k if relations.include?(k) }
+          end
+          # Add this either if...
+          if access.is_a?(String) # ...they have permissions over absolutely anything,
+            relations.each_with_object({}) { |rel, s| s[rel.first] = access unless rel.first.is_a?(Symbol) }
+          else # or there are specific permissions for each resource, so find the matching indexes
+            client = Elastic::Transport::Client.new
+            ::Brick.elasticsearch_existings.each_with_object({}) do |index, s|
+              perms = access.is_a?(String) ? access : access[index] || '' # Look up permissions from above
+              s[index] = perms unless perms.blank?
+            end
+          end
+        end
+      end
+
       if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first)
         puts "Now switching back to \"#{orig_schema}\" schema."
         ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", orig_schema)

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -111,7 +111,7 @@ module Brick
                   :established_drf,
                   :is_oracle, :is_eager_loading, :auto_models, :initializer_loaded,
                   :table_name_lookup,
-                  :elasticsearch_models,
+                  :elasticsearch_models, :elasticsearch_existings,
                   :routes_done
     ::Brick.auto_models = []
 
@@ -292,6 +292,10 @@ to instead be this:
             s.first[bt_key] = [a.name, a.klass]
           end
         else # This gets all forms of has_many and has_one
+          if a.scope&.arity&.> 0
+            puts "Skipping HM column \"#{a.name}\" because it has a scope which requires #{a.scope.arity} #{'argument'.pluralize(a.scope.arity)}"
+            next
+          end
           if through # has_many :through or has_one :through
             is_invalid_source = nil
             begin

data/lib/generators/brick/install_generator.rb

@@ -346,7 +346,18 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
 
   # # FULL TEXT SEARCH
+  # # You can enable Elasticsearch support by adding the elasticsearch-model and elasticsearch-rails gems, and either
+  # # having a copy of Opensearch or Elasticsearch locally installed on the same machine listening on port 9200, or by
+  # # setting the ELASTICSEARCH_URL environment variable to point to the URI of a search machine.
+  # # With that configured, you can pick specific table names and permissions for search and update by putting them in
+  # # a hash like this:
+  # Brick.elasticsearch_models = { 'notes' => 'crud', 'issues' => 'cru', 'orders' => 'r' }
+  # # or to blanketly enable all models to have auto-updating CRUD behaviour when there are ActiveRecord changes, use:
   # Brick.elasticsearch_models = :all
+  # # As well there is another permission available -- the 'i' permission -- which will auto-create an index if it
+  # # is missing.  If you set 'icrud' for a model it will auto-create an index, or to always do this for all models
+  # # then you can specify \"full control\" like this:
+  # Brick.elasticsearch_models = :full
 
   # # ERD SETTINGS
 
@@ -377,18 +388,19 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
 
   # # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 
-  # # For multi-tenant databases that use a separate schema for each tenant, a single representative database schema
-  # # can be analysed to determine the range of polymorphic classes that can be used for each association.  Hopefully
-  # # the schema chosen is one loaded with existing data that is representative of all possible polymorphic
-  # # associations.
+  # # MULTITENANCY VIA THE ROS-APARTMENT GEM
+
+  # # If you are using the ros-apartment gem along with Postgres then you can have automatic detection of polymorphic
+  # # type names (model class names listed in a column such as imageable_type) by choosing a schema that is loaded up
+  # # with data that represents the full range of the various polymorphic has_many classes that should be associated.
   # Brick.schema_behavior = :namespaced
 #{Brick.config.schema_behavior.present? ? "  Brick.schema_behavior = { multitenant: { schema_to_analyse: #{
   Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil).inspect}" :
 "  # Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering'"
 } } }
 #{"
-  # # Note that if you have a real polymorphic model configured then it is better to set the list of classes up in the
-  # # model file itself with a line like:
+  # # Note that for each polymorphic model configured then it is better to set the list of classes up in the model
+  # # file itself with a line like:
   # delegated_type :commentable, type: ['Post', 'Comment']" if ActiveRecord::Base.respond_to?(:delegated_type)}
 
   # # DEFAULT ROOT ROUTE

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.228
+  version: 1.0.229
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-19 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord