brick 1.0.96 → 1.0.98

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0061ad25b22deee43d1939b6541257924a61a67b3b8b004fb6a0072302746ca2
-  data.tar.gz: 99968b9de834f73c60842bf5da03b5bddd750f1ff8c3ac1dac294078f0eb2358
+  metadata.gz: d4285ef6fb81d75bd90ceffc7d66c7fa096f04fb998da590f291f28fc9dfb45d
+  data.tar.gz: 2d031b156fd9c82d19af9b7818387eaecdd8cfadf939cbcf3b3b479474a77b54
 SHA512:
-  metadata.gz: 4958e2b0c18522be75134ab29df481213594189b4addd6ef9368ae8677aba603cbb278176c57c51217a49c0042e98927cb33465995bc4aae01f3af59b2d64f15
-  data.tar.gz: 1d486886f30ce384edc7d84a441617906b26b001c7c3562558289eedfd4b0c12e2a860c587f71acb6e6727649a3756223f1240c07f4e1013029cfe5b67a9c117
+  metadata.gz: 5967ede119f86cd92f88abb0f43bd2049eda4272c14ae7fa1c3f9ecc54c813c4c227be2d99aaa501363e42ef34a3eb5d0a0924ac4e540ab668e40a9a9d28311e
+  data.tar.gz: ab01005e485b9335c67ba48bb01a13db78fed3ce31293122fae8fbf1317b3bc0c3197adb087ec4b125e2ff7153e52fb55d8b7fc675b1e7759233cf8d42769ac7

data/lib/brick/extensions.rb

@@ -540,7 +540,11 @@ module ActiveRecord
             tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(tbl_name)
             field_tbl_name = nil
             v1.map { |x| [x[0..-2].map(&:to_s).join('.'), x.last] }.each_with_index do |sel_col, idx|
-              field_tbl_name = rel_dupe.brick_links[sel_col.first].split('.').last
+              # %%% Strangely in Rails 7.1 on a slower system then very rarely brick_link comes back nil...
+              brick_link = rel_dupe.brick_links[sel_col.first]
+              field_tbl_name = brick_link&.split('.')&.last ||
+                # ... so here's a best-effort guess for what the table name might be.
+                rel_dupe.klass.reflect_on_association(sel_col.first).klass.table_name
               # If it's Oracle, quote any AREL aliases that had been applied
               field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(field_tbl_name)
 
@@ -825,80 +829,9 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
 end
 
 if Object.const_defined?('ActionView')
+  require 'brick/frameworks/rails/form_tags'
   module ActionView::Helpers::FormTagHelper
-    def link_to_brick(*args, **kwargs)
-      return unless ::Brick.config.mode == :on
-
-      text = (args.first.is_a?(String) && args.first) || args[1]
-      klass_or_obj = ((args.first.is_a?(ActiveRecord::Relation) ||
-                       args.first.is_a?(ActiveRecord::Base) ||
-                       args.first.is_a?(Class)) &&
-                      args.first) ||
-                     @_brick_model
-      # If not provided, do a best-effort to automatically determine the resource class or object
-      filter_parts = []
-      klass_or_obj ||= begin
-                         klass, sti_type = ::Brick.ctrl_to_klass(controller_path)
-                         if klass
-                           type_col = klass.inheritance_column # Usually 'type'
-                           filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
-                           path_params = request.path_parameters.dup
-                           path_params.delete(:controller)
-                           path_params.delete(:action)
-                           pk = (klass.primary_key || ActiveRecord::Base.primary_key).to_sym
-                           # Used to also have this but it's a bit too permissive to identify a primary key:  (path_params.length == 1 && path_params.values.first) ||
-                           if ((id = (path_params[pk] || path_params[:id] || path_params["#{klass.name.underscore}_id".to_sym])) && (obj = klass.find_by(pk => id))) ||
-                              (['show', 'edit', 'update', 'destroy'].include?(action_name) && (obj = klass.first))
-                             obj
-                           else
-                             # %%% If there is a HMT that refers to some ___id then try to identify an appropriate filter
-                             # %%% If there is a polymorphic association that might relate to stuff in the path_params,
-                             # try to identify an appropriate ___able_id and ___able_type filter
-                             ((klass.column_names - [pk.to_s]) & path_params.keys.map(&:to_s)).each do |path_param|
-                               filter_parts << "#{path_param}=#{path_params[path_param.to_sym]}"
-                             end
-                             klass
-                           end
-                         end
-                       rescue
-                       end
-      if klass_or_obj
-        if klass_or_obj.is_a?(ActiveRecord::Relation)
-          klass_or_obj.where_values_hash.each do |whr|
-            filter_parts << "#{whr.first}=#{whr.last}" if whr.last && !whr.last.is_a?(Array)
-          end
-          klass_or_obj = klass_or_obj.klass
-          type_col = klass_or_obj.inheritance_column
-          if klass_or_obj.column_names.include?(type_col) && klass_or_obj.name != klass_or_obj.base_class.name
-            filter_parts << "#{type_col}=#{klass_or_obj.name}"
-          end
-        elsif klass_or_obj.is_a?(ActiveRecord::Base) && klass_or_obj.new_record?
-          klass_or_obj = klass_or_obj.class
-        end
-        filter = "?#{filter_parts.join('&')}" if filter_parts.present?
-        if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
-           (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
-          lt_args = [text || "Index for #{klass_or_obj.name.pluralize}",
-                    "#{send("#{klass_or_obj._brick_index}_path")}#{filter}"]
-        else
-          # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
-          lt_args = [text || "Show this #{klass_or_obj.class.name}",
-                    "#{send("#{klass_or_obj.class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"]
-        end
-        link_to(*lt_args, **kwargs)
-      else
-        # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
-        # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
-        links = instance_variables.each_with_object([]) do |name, s|
-                  iv_name = name.to_s[1..-1]
-                  case (val = instance_variable_get(name))
-                  when ActiveRecord::Relation, ActiveRecord::Base
-                    s << link_to_brick(val, iv_name) if val
-                  end
-                end
-        links.join(' &nbsp; ').html_safe
-      end
-    end
+    include ::Brick::Rails::FormTags
   end
 end
 
@@ -1002,6 +935,7 @@ Module.class_exec do
     end
     class_name = ::Brick.namify(requested)
     relations = ::Brick.relations
+    #        CONTROLLER
     result = if ::Brick.enable_controllers? &&
                 is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
@@ -1020,6 +954,8 @@ Module.class_exec do
                  # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
+
+             # MODULE
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
                    base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
                    (schema_name = [(singular_table_name = class_name.underscore),
@@ -1036,6 +972,50 @@ 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
+
+             # AVO Resource
+             elsif base_module == Object && Object.const_defined?('Avo') && requested.end_with?('Resource') &&
+                   ['MotorResource'].exclude?(requested) # Expect that anything called MotorResource could be from that administrative gem
+               if (model = Object.const_get(requested[0..-9]))
+                 require 'generators/avo/resource_generator'
+                 field_generator = Generators::Avo::ResourceGenerator.new([''])
+                 field_generator.instance_variable_set(:@model, model)
+                 fields = field_generator.send(:generate_fields).split("\n")
+                                         .each_with_object([]) do |f, s|
+                                           if (f = f.strip).start_with?('field ')
+                                             f = f[6..-1].split(',')
+                                             s << [f.first[1..-1].to_sym, [f[1][1..-1].split(': :').map(&:to_sym)].to_h]
+                                           end
+                                         end
+                 built_resource = Class.new(Avo::BaseResource) do |new_resource_class|
+                   self.model_class = model
+                   self.title = :brick_descrip
+                   self.includes = []
+                   if (!model.is_view? && mod_pk = model.primary_key)
+                     field((mod_pk.is_a?(Array) ? mod_pk.first : mod_pk).to_sym, { as: :id })
+                   end
+                   # Create a call such as:  field :name, as: :text
+                   fields.each do |f|
+                     # Add proper types if this is a polymorphic belongs_to
+                     if f.last == { as: :belongs_to } &&
+                        (fk = ::Brick.relations[model.table_name][:fks].find { |k, v| v[:assoc_name] == f.first.to_s }) &&
+                        fk.last.fetch(:polymorphic, nil)
+                       poly_types = fk.last.fetch(:inverse_table, nil)&.each_with_object([]) do |poly_table, s|
+                         s << Object.const_get(::Brick.relations[poly_table][:class_name])
+                       end
+                       if poly_types.present?
+                         f.last[:polymorphic_as] = f.first
+                         f.last[:types] = poly_types
+                       end
+                     end
+                     self.send(:field, *f)
+                   end
+                 end
+                 Object.const_set(requested.to_sym, built_resource)
+                 [built_resource, nil]
+               end
+
+             # MODEL
              elsif ::Brick.enable_models?
                # Custom inheritable Brick base model?
                class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
@@ -1397,14 +1377,19 @@ class Object
     end
 
     def build_controller(namespace, class_name, plural_class_name, model, relations)
+      if (is_avo = (namespace.name == 'Avo' && Object.const_defined?('Avo')))
+        # Basic Avo functionality is available via its own generic controller.
+        # (More information on https://docs.avohq.io/2.0/controllers.html)
+        controller_base = Avo::ResourcesController
+      end
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
 
-      code = +"class #{class_name} < ApplicationController\n"
-      built_controller = Class.new(ActionController::Base) do |new_controller_class|
+      code = +"class #{class_name} < #{controller_base&.name || 'ApplicationController'}\n"
+      built_controller = Class.new(controller_base || ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
         # Brick-specific pages
@@ -1501,118 +1486,120 @@ class Object
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
-        self.define_method :index do
-          if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
-             !params&.key?('_brick_schema') &&
-             (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
-            if params
-              referrer_params.each { |k, v| params.send(:parameters)[k] = v }
-            else
-              api_params = referrer_params&.to_h
+        unless is_avo
+          self.define_method :index do
+            if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
+               !params&.key?('_brick_schema') &&
+               (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
+              if params
+                referrer_params.each { |k, v| params.send(:parameters)[k] = v }
+              else
+                api_params = referrer_params&.to_h
+              end
             end
-          end
-          _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
-
-          if is_openapi
-            json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
-                     'servers': [
-                       { 'url': '{scheme}://{defaultHost}', 'variables': {
-                         'scheme': { 'default': request.env['rack.url_scheme'] },
-                         'defaultHost': { 'default': request.env['HTTP_HOST'] }
-                       } }
-                     ]
-                   }
-            json['paths'] = relations.inject({}) do |s, relation|
-              unless ::Brick.config.enable_api == false
-                table_description = relation.last[:description]
-                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
-                  'get': {
-                    'summary': "list #{relation.first}",
-                    'description': table_description,
-                    'parameters': relation.last[:cols].map do |k, v|
-                                    param = { 'name' => k, 'schema': { 'type': v.first } }
-                                    if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                                      param['description'] = col_descrip
-                                    end
-                                    param
-                                  end,
-                    'responses': { '200': { 'description': 'successful' } }
-                  }
-                }
-
-                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
-                  'patch': {
-                    'summary': "update a #{relation.first.singularize}",
-                    'description': table_description,
-                    'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
-                      param = { 'name' => k, 'schema': { 'type': v.first } }
-                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                        param['description'] = col_descrip
-                      end
-                      param
-                    end,
-                    'responses': { '200': { 'description': 'successful' } }
+            _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
+
+            if is_openapi
+              json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
+                       'servers': [
+                         { 'url': '{scheme}://{defaultHost}', 'variables': {
+                           'scheme': { 'default': request.env['rack.url_scheme'] },
+                           'defaultHost': { 'default': request.env['HTTP_HOST'] }
+                         } }
+                       ]
+                     }
+              json['paths'] = relations.inject({}) do |s, relation|
+                unless ::Brick.config.enable_api == false
+                  table_description = relation.last[:description]
+                  s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
+                    'get': {
+                      'summary': "list #{relation.first}",
+                      'description': table_description,
+                      'parameters': relation.last[:cols].map do |k, v|
+                                      param = { 'name' => k, 'schema': { 'type': v.first } }
+                                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                                        param['description'] = col_descrip
+                                      end
+                                      param
+                                    end,
+                      'responses': { '200': { 'description': 'successful' } }
+                    }
                   }
-                } unless relation.last.fetch(:isView, nil)
-                s
+
+                  s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
+                    'patch': {
+                      'summary': "update a #{relation.first.singularize}",
+                      'description': table_description,
+                      'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
+                        param = { 'name' => k, 'schema': { 'type': v.first } }
+                        if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                          param['description'] = col_descrip
+                        end
+                        param
+                      end,
+                      'responses': { '200': { 'description': 'successful' } }
+                    }
+                  } unless relation.last.fetch(:isView, nil)
+                  s
+                end
               end
+              render inline: json.to_json, content_type: request.format
+              return
             end
-            render inline: json.to_json, content_type: request.format
-            return
-          end
 
-          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 }
+            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 || request.path.start_with?('/api/') # Asking for JSON?
+              data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
+              render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
+              return
             end
-            render inline: exported_csv, content_type: request.format
-            return
-          elsif request.format == :js || request.path.start_with?('/api/') # Asking for JSON?
-            data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
-            render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
-            return
-          end
 
-          # Normal (not swagger or CSV) request
-
-          # %%% Allow params to define which columns to use for order_by
-          # Overriding the default by providing a querystring param?
-          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
-
-          ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
-          @_brick_params = ar_relation.brick_select(params, (selects = []), order_by,
-                                                             translations = {},
-                                                             join_array = ::Brick::JoinArray.new)
-          # %%% Add custom HM count columns
-          # %%% What happens when the PK is composite?
-          counts = model._br_hm_counts.each_with_object([]) do |v, s|
-            s << if is_mysql
-                   "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
-                 elsif is_postgres
-                   "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
-                 else
-                   "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
-                 end
-          end
-          ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
-          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
-          if namespace && (idx = lookup_context.prefixes.index(table_name))
-            lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
-          end
-          @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
-                           if (excl_parts = excl.split('.')).first == table_name
-                             s << excl_parts.last
+            # Normal (not swagger or CSV) request
+
+            # %%% Allow params to define which columns to use for order_by
+            # Overriding the default by providing a querystring param?
+            ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+            order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
+
+            ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
+            @_brick_params = ar_relation.brick_select(params, (selects = []), order_by,
+                                                               translations = {},
+                                                               join_array = ::Brick::JoinArray.new)
+            # %%% Add custom HM count columns
+            # %%% What happens when the PK is composite?
+            counts = model._br_hm_counts.each_with_object([]) do |v, s|
+              s << if is_mysql
+                     "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
+                   elsif is_postgres
+                     "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
+                   else
+                     "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
+                   end
+            end
+            ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
+            instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
+            if namespace && (idx = lookup_context.prefixes.index(table_name))
+              lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
+            end
+            @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
+                             if (excl_parts = excl.split('.')).first == table_name
+                               s << excl_parts.last
+                             end
                            end
-                         end
-          @_brick_bt_descrip = model._br_bt_descrip
-          @_brick_hm_counts = model._br_hm_counts
-          @_brick_join_array = join_array
-          @_brick_erd = params['_brick_erd']&.to_i
+            @_brick_bt_descrip = model._br_bt_descrip
+            @_brick_hm_counts = model._br_hm_counts
+            @_brick_join_array = join_array
+            @_brick_erd = params['_brick_erd']&.to_i
+          end
         end
 
-        unless is_openapi
+        unless is_openapi || is_avo
           _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk)) if pk
           code << "  def index\n"
           code << "    @#{table_name.pluralize} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"

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

@@ -3,7 +3,7 @@
 module Brick
   module Rails
     # Extensions to rails controllers. Provides convenient ways to pass certain
-    # information to the model layer, with `controller_info` and `whodunnit`.
+    # information to the model layer, with `controller_info`.
     # Also includes a convenient on/off switch,
     # `brick_enabled_for_controller`.
     module Controller