brick 1.0.33 → 1.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bd78c8878b1ce8e8e58fb4d8463322269d2ac065c5ed12079dcc64360dc30d5
-  data.tar.gz: e6926fdc0ec59ad609be39361dbfe0ccea24c1b08a01ccf0a4ae8eb1aa9e2ba2
+  metadata.gz: 9d1e2f8b6ff7ca3fa7fcd129c33de3dfe6e674b6da154b9a64e094c65a3a152a
+  data.tar.gz: 30e39f62458a46854f56b2a6decbfe5ea42a4bb5325e81ed76f21400aae8e252
 SHA512:
-  metadata.gz: 5b6ac439519209c3097c2b2651ed66f319b9c04072d2cee7262aad6c4d9907d61b5b45ee1812c1f6cea1e5e1eed2082eb15953e4e3097c9c12b4f35a1f3af703
-  data.tar.gz: 5bb559ada7035abb062b0441578d5406e64f87b9f11fde1d5b3b880179098bafe9507a1a6cdd8e1af1cd1fb4defc1d339e0054896ca0e9c507ea831f24a0cb96
+  metadata.gz: 14c6bae09e34f53126e2003cbc7256c4b32f4a4219d42f1f7e94ca83211debf3704fa6c170cd6231d89e26eb168f282d1dea7eff7150ef1a013364aeb4eb65c3
+  data.tar.gz: 7f33aa5c89be2e8401f4cda0ea6cecb6e01639934a2df1e7b00bd88d065bf3cc9b748bebb1691d51c1b04114fba3b1739a7820c7614f4eb84d52494bd4cc769e

data/lib/brick/extensions.rb

@@ -163,6 +163,7 @@ module ActiveRecord
                         bracket_name.split('.').each do |part|
                           obj_name += ".#{part}"
                           this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
+                          break if this_obj.nil?
                         end
                         this_obj&.to_s || ''
                       end
@@ -308,6 +309,23 @@ module ActiveRecord
       # , is_add_bts, is_add_hms
     )
       is_add_bts = is_add_hms = true
+      is_distinct = nil
+      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&.column_names&.any?(ks.last)
+
+          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
+          is_distinct = true
+          distinct!
+        end
+        wheres[k] = v.split(',')
+      end
 
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
@@ -316,7 +334,9 @@ module ActiveRecord
           if (col_name = col.name) == 'class'
             col_alias = ' AS _class'
           end
-          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{col_alias}"
+          # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
+          cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col.name)&.first&.start_with?('xml')
+          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
         end
       end
 
@@ -342,22 +362,6 @@ module ActiveRecord
         end
       end
 
-      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&.column_names&.any?(ks.last)
-
-          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
-          distinct!
-        end
-        wheres[k] = v.split(',')
-      end
-
       if join_array.present?
         left_outer_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.
@@ -375,7 +379,9 @@ module ActiveRecord
             v1.map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
               field_tbl_name = (field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])).split('.').last
 
-              selects << "#{"\"#{field_tbl_name}\".\"#{sel_col.last}\""} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
+              # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
+              is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
+              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
               v1[idx] << col_alias
             end
 
@@ -571,11 +577,13 @@ Module.class_exec do
                [built_module, "module #{schema_name}; end\n"]
                #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
              elsif ::Brick.enable_models?
+               # Custom inheritable Brick base model?
+               class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
                # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
                # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
 
-               if self != Object || # Are we in some namespace? ...
-                  (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil)&.constantize) # ... or part of an auto-STI namespace?
+               if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+                  self != Object # ... or otherwise already in some namespace?
                  schema_name = [(singular_schema_name = name.underscore),
                                 (schema_name = singular_schema_name.pluralize),
                                 name,
@@ -588,7 +596,7 @@ Module.class_exec do
                if base_model
                  schema_name = name.underscore # For the auto-STI namespace models
                  table_name = base_model.table_name
-                 Object.send(:build_model, self, model_name, singular_table_name, table_name, relations, table_name)
+                 Object.send(:build_model, self, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
                else
                  # Adjust for STI if we know of a base model for the requested model name
                  # %%% Does not yet work with namespaced model names.  Perhaps prefix with plural_class_name when doing the lookups here.
@@ -603,7 +611,7 @@ Module.class_exec do
                  end
                  # Maybe, just maybe there's a database table that will satisfy this need
                  if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
-                   Object.send(:build_model, schema_name, model_name, singular_table_name, table_name, relations, matching)
+                   Object.send(:build_model, schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
                  end
                end
              end
@@ -631,12 +639,12 @@ class Object
 
   private
 
-    def build_model(schema_name, model_name, singular_table_name, table_name, relations, matching)
+    def build_model(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
       full_name = if (::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && schema_name == Apartment.default_schema)
                     relation = relations["#{schema_name}.#{matching}"]
-                    model_name
+                    inheritable_name || model_name
                   elsif schema_name.blank?
-                    model_name
+                    inheritable_name || model_name
                   else # Prefix the schema to the table name + prefix the schema namespace to the class name
                     schema_module = if schema_name.instance_of?(Module) # from an auto-STI namespace?
                                       schema_name
@@ -644,7 +652,7 @@ class Object
                                       matching = "#{schema_name}.#{matching}"
                                       (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.singularize.camelize))
                                     end
-                    "#{schema_module&.name}::#{model_name}"
+                    "#{schema_module&.name}::#{inheritable_name || model_name}"
                   end
 
       return if ((is_view = (relation ||= relations[matching]).key?(:isView)) && ::Brick.config.skip_database_views) ||
@@ -653,12 +661,14 @@ class Object
       # Are they trying to use a pluralised class name such as "Employees" instead of "Employee"?
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
         unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.camelize}::")
-          puts "Warning: Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\"."
+          puts "Warning: Class name for a model that references table \"#{matching
+               }\" should be \"#{ActiveSupport::Inflector.singularize(inheritable_name || model_name)}\"."
         end
         return
       end
 
-      if (base_model = ::Brick.sti_models[full_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_name]&.constantize)
+      full_model_name = full_name.split('::').tap { |fn| fn[-1] = model_name }.join('::')
+      if (base_model = ::Brick.sti_models[full_model_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_model_name]&.constantize)
         is_sti = true
       else
         base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
@@ -666,9 +676,21 @@ class Object
       hmts = nil
       code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
-        (schema_module || Object).const_set(model_name.to_sym, new_model_class)
+        (schema_module || Object).const_set((inheritable_name || model_name).to_sym, new_model_class)
+        if inheritable_name
+          new_model_class.define_singleton_method :inherited do |subclass|
+            super(subclass)
+            if subclass.name == model_name
+              puts "#{full_model_name} properly extends from #{full_name}"
+            else
+              puts "should be \"class #{model_name} < #{inheritable_name}\"\n           (not \"#{subclass.name} < #{inheritable_name}\")"
+            end
+          end
+          self.abstract_class = true
+          code << "  self.abstract_class = true\n"
+        end
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
-        code << "  self.table_name = '#{self.table_name = matching}'\n" unless table_name == matching
+        code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || table_name != matching
 
         # Override models backed by a view so they return true for #is_view?
         # (Dynamically-created controllers and view templates for such models will then act in a read-only way)
@@ -880,19 +902,19 @@ class Object
                        { 'url': 'https://{defaultHost}', 'variables': { 'defaultHost': { 'default': 'www.example.com' } } }
                      ]
                    }
-            json['paths'] = relations.each_with_object({}) do |v, s|
-              # next if v.last[:is_view]
-
+            json['paths'] = relations.inject({}) do |s, v|
               s["/api/v1/#{v.first}"] = {
                 'get': {
-                  'summary': 'list #{v.first}',
+                  'summary': "list #{v.first}",
                   'parameters': v.last[:cols].map { |k, v| { 'name' => k, 'schema': { 'type': v.first } } },
                   'responses': { '200': { 'description': 'successful' } }
                 }
               }
+              # next if v.last[:isView]
+
               s["/api/v1/#{v.first}/{id}"] = {
                 'patch': {
-                  'summary': 'update a #{v.first.singularize}',
+                  'summary': "update a #{v.first.singularize}",
                   'parameters': v.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
                     { 'name' => k, 'schema': { 'type': v.first } }
                   end,
@@ -918,6 +940,7 @@ class Object
                 #     }
                 #   ],
               }
+              s
             end
             # binding.pry
             render inline: json.to_json, content_type: request.format
@@ -1090,12 +1113,14 @@ module ActiveRecord::ConnectionHandling
       when 'Mysql2'
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
       when 'SQLite'
+        # %%% Retrieve internal ActiveRecord table names like this:
+        # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
         sql = "SELECT m.name AS relation_name, UPPER(m.type) AS table_type,
           p.name AS column_name, p.type AS data_type,
           CASE p.pk WHEN 1 THEN 'PRIMARY KEY' END AS const
         FROM sqlite_master AS m
           INNER JOIN pragma_table_info(m.name) AS p
-        WHERE m.name NOT IN ('ar_internal_metadata', 'schema_migrations')
+        WHERE m.name NOT IN (?, ?)
         ORDER BY m.name, p.cid"
       else
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
@@ -1123,6 +1148,9 @@ module ActiveRecord::ConnectionHandling
         end
       end
 
+      # %%% Retrieve internal ActiveRecord table names like this:
+      # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
+      # For if it's not SQLite -- so this is the Postgres and MySQL version
       sql ||= "SELECT t.table_schema AS schema, t.table_name AS relation_name, t.table_type,
           c.column_name, c.data_type,
           COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
@@ -1144,13 +1172,13 @@ module ActiveRecord::ConnectionHandling
         WHERE t.table_schema NOT IN ('information_schema', 'pg_catalog')#{"
           AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }
   --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
-          AND t.table_name NOT IN ('pg_stat_statements', 'ar_internal_metadata', 'schema_migrations')
+          AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
         ORDER BY 1, t.table_type DESC, c.ordinal_position"
       measures = []
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
         # schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        ActiveRecord::Base.execute_sql(sql).each do |r|
+        ActiveRecord::Base.execute_sql(sql, ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name).each do |r|
           # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
           # is the default schema, usually 'public'.
           schema_name = if ::Brick.config.schema_behavior[:multitenant]
@@ -1259,11 +1287,25 @@ module ActiveRecord::ConnectionHandling
       end
     end
 
-    puts "\nClasses that can be built from tables:"
-    relations.select { |_k, v| !v.key?(:isView) }.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
-    unless (views = relations.select { |_k, v| v.key?(:isView) }).empty?
+    apartment = Object.const_defined?('Apartment') && Apartment
+    tables = []
+    views = []
+    relations.each do |k, v|
+      name_parts = k.split('.')
+      if v.key?(:isView)
+        views
+      else
+        name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
+        tables
+      end << name_parts.map { |x| x.singularize.camelize }.join('::')
+    end
+    unless tables.empty?
+      puts "\nClasses that can be built from tables:"
+      tables.sort.each { |x| puts x }
+    end
+    unless views.empty?
       puts "\nClasses that can be built from views:"
-      views.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
+      views.sort.each { |x| puts x }
     end
 
     ::Brick.load_additional_references if initializer_loaded
@@ -1306,7 +1348,8 @@ module Brick
       end
       # %%% Temporary schema patch
       for_tbl = fk[1]
-      fk[0] = Apartment.default_schema if Object.const_defined?('Apartment') && Apartment.excluded_models.include?(for_tbl.singularize.camelize)
+      apartment = Object.const_defined?('Apartment') && Apartment
+      fk[0] = Apartment.default_schema if apartment && apartment.excluded_models.include?(for_tbl.singularize.camelize)
       fk[1] = "#{fk[0]}.#{fk[1]}" if fk[0] # && fk[0] != ::Brick.default_schema
       bts = (relation = relations.fetch(fk[1], nil))&.fetch(:fks) { relation[:fks] = {} }
 
@@ -1321,7 +1364,7 @@ module Brick
                         is_schema = if ::Brick.config.schema_behavior[:multitenant]
                                       # If Apartment gem lists the primary table as being associated with a non-tenanted model
                                       # then use 'public' schema for the primary table
-                                      if Object.const_defined?('Apartment') && Apartment.excluded_models.include?(fk[4].singularize.camelize)
+                                      if apartment&.excluded_models.include?(fk[4].singularize.camelize)
                                         fk[3] = Apartment.default_schema
                                         true
                                       end
@@ -1398,7 +1441,7 @@ module Brick
         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
-        inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && fk[0] == Apartment.default_schema
+        inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && apartment && fk[0] == Apartment.default_schema
                     for_tbl
                   else
                     fk[1]

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

@@ -124,8 +124,15 @@ module Brick
               schema_options = ::Brick.db_schemas.keys.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
               # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
               # environment or whatever, then get either the controllers or routes list instead
-              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).sort
-                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>" }.html_safe
+              apartment_default_schema = ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && Apartment.default_schema
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).map do |tbl|
+                                if (tbl_parts = tbl.split('.')).first == apartment_default_schema
+                                  tbl = tbl_parts.last
+                                end
+                                tbl
+                              end.sort.each_with_object(+'') do |v, s|
+                                s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
+                              end.html_safe
               css = +"<style>
 #dropper {
   background-color: #eee;
@@ -238,9 +245,10 @@ end %>"
                 poly_cols = #{poly_cols.inspect} %>"
               end
 
-              # %%% When doing schema select, if there's an ID then remove it, or if we're on a new page go to index
+              # %%% When doing schema select, if we're on a new page go to index
               script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
+var tblSelect = document.getElementById(\"tbl\");
 var brickSchema;
 if (schemaSelect) {
   brickSchema = changeout(location.href, \"_brick_schema\");
@@ -250,7 +258,8 @@ if (schemaSelect) {
   schemaSelect.value = brickSchema || \"public\";
   schemaSelect.focus();
   schemaSelect.addEventListener(\"change\", function () {
-    location.href = changeout(location.href, \"_brick_schema\", this.value);
+    // If there's an ID then remove it (trim after selected table)
+    location.href = changeout(location.href, \"_brick_schema\", this.value, tblSelect.value);
   });
 }
 [... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
@@ -265,7 +274,6 @@ if (schemaSelect) {
   });
 });
 
-var tblSelect = document.getElementById(\"tbl\");
 if (tblSelect) {
   tblSelect.value = changeout(location.href)[0];
   if (tblSelect.selectedIndex < 0) tblSelect.value = changeout(location.href)[1];
@@ -277,7 +285,7 @@ if (tblSelect) {
   });
 }
 
-function changeout(href, param, value) {
+function changeout(href, param, value, trimAfter) {
   var hrefParts = href.split(\"?\");
   if (param === undefined || param === null) {
     hrefParts = hrefParts[0].split(\"://\");
@@ -288,6 +296,11 @@ function changeout(href, param, value) {
     else
       return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
   }
+  if (trimAfter) {
+    var pathParts = hrefParts[0].split(\"/\");
+    while (pathParts.lastIndexOf(trimAfter) != pathParts.length - 1) pathParts.pop();
+    hrefParts[0] = pathParts.join(\"/\");
+  }
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
   params = params.reduce(function (s, v) { var parts = v.split(\"=\"); s[parts[0]] = parts[1]; return s; }, {});
   if (value === undefined) return params[param];
@@ -566,7 +579,7 @@ function changeout(href, param, value) {
       s << "<table id=\"#{hm_name}\">
         <tr><th>#{hm[3]}</th></tr>
         <% collection = @#{obj_name}.#{hm_name}
-        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
+        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection].compact
         if collection.empty? %>
           <tr><td>(none)</td></tr>
         <% else %>
@@ -600,6 +613,7 @@ function changeout(href, param, value) {
 
         # Just in case it hadn't been done previously when we tried to load the brick initialiser,
         # go make sure we've loaded additional references (virtual foreign keys and polymorphic associations).
+        # (This should only happen if for whatever reason the initializer file was not exactly config/initializers/brick.rb.)
         ::Brick.load_additional_references
       end
     end

data/lib/brick/version_number.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.33
+  version: 1.0.34
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-21 00:00:00.000000000 Z
+date: 2022-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord