brick 1.0.72 → 1.0.74

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06c3efed47ee7086f01a4f59c177f362343f376b1d6534f86e61ee38001b0d7b
-  data.tar.gz: 8b521c56eb5afc09b06aec0adf0085136cb9e94d2c1a93355a8a2fc79da0316b
+  metadata.gz: a7f077a36e2fd62546cdebfde2b9651807ceeaad9571008460423d9e994df44d
+  data.tar.gz: 368ca31e726fa377325b7ff7838e38cd6b79aa222bcec73cdd6cebc645908d28
 SHA512:
-  metadata.gz: 1566ddaa89e45496b752b64ec218456e05dca50cc81a722d5a88e4d4bbe19b28ca981eeb253688f44e55a8ef9949d195bdc5a61f5ba7980b2507c315277b4d4d
-  data.tar.gz: 7643f78bf92721c89bdb0065f112592cba26023ea7745ba34551ce39d9378cd286f50b3ea1491c813e10f6d93521ef16c54fa70edc5dbcd4d70cb5ad6a859ad3
+  metadata.gz: a4154837ca3926cb1cd8d4803d62a789f1aa6449625560c63c06708508543e218765288d13a763aab238ea946dfdc33391454793b02805a8cdf46f729cf436da
+  data.tar.gz: 599cd989ef47a99cb0b6b4cb1a1c53da892d5758ccd208ecb4bf1383a2f29c1bc4600458c4de357e5496f90f664984c10634f469a40f80bcc89a9e5592735899

data/lib/brick/config.rb

@@ -56,6 +56,31 @@ module Brick
       @mutex.synchronize { @enable_routes = enable }
     end
 
+    def enable_api
+      @mutex.synchronize { @enable_api }
+    end
+
+    def enable_api=(enable)
+      @mutex.synchronize { @enable_api = enable }
+    end
+
+    def api_root
+      ver = api_version
+      @mutex.synchronize { @api_root || "/api/#{ver}/" }
+    end
+
+    def api_root=(path)
+      @mutex.synchronize { @api_root = path }
+    end
+
+    def api_version
+      @mutex.synchronize { @api_version || 'v1' }
+    end
+
+    def api_version=(ver)
+      @mutex.synchronize { @api_version = ver }
+    end
+
     # Additional table associations to use (Think of these as virtual foreign keys perhaps)
     def additional_references
       @mutex.synchronize { @additional_references }

data/lib/brick/extensions.rb

@@ -107,7 +107,8 @@ module ActiveRecord
       bracket_name = nil
       prefix = [prefix] unless prefix.is_a?(Array)
       if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
-        dsl2 = +''
+        dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
+        dsl3 = +'' # To return expanded DSL that is nested from another model
         klass = nil
         dsl.each_char do |ch|
           if bracket_name
@@ -129,11 +130,16 @@ module ActiveRecord
               end
               if klass.column_names.exclude?(parts.last) &&
                  (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+                # Expand this entry which refers to an association name
                 members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
                 members += members2
                 dsl2 << dsl2a
+                dsl3 << dsl2a
               else
                 dsl2 << "[#{bracket_name}]"
+                if emit_dsl
+                  dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
+                end
                 members << parts
               end
               bracket_name = nil
@@ -145,15 +151,22 @@ module ActiveRecord
             klass = self
           else
             dsl2 << ch
+            dsl3 << ch
           end
         end
         # Rewrite the DSL in case it's now different from having to expand it
+        # if ::Brick.config.model_descrips[name] != dsl2
+        #   puts ::Brick.config.model_descrips[name]
+        #   puts dsl2.inspect
+        #   puts dsl3.inspect
+        #   binding.pry
+        # end
         ::Brick.config.model_descrips[name] = dsl2 unless emit_dsl
       else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
         x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
         x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
-      emit_dsl ? [members, dsl2] : members
+      emit_dsl ? [members, dsl3] : members
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -221,13 +234,21 @@ module ActiveRecord
     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.tr('/', '_').pluralize}_path".to_sym)
+      model_path = Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
       av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
       av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('7')
       link = av_class.link_to(name, model_path)
-      model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+      table_name == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+    end
+
+    def self._brick_index
+      tbl_parts = table_name.split('.')
+      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.first == Apartment.default_schema
+      if (index = tbl_parts.map(&:underscore).join('_')) == index.singularize
+        index << '_index' # Rails applies an _index suffix to that route when the resource name is singular
+      end
+      index
     end
 
     def self.brick_import_template
@@ -407,7 +428,7 @@ module ActiveRecord
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
-        next if ['_brick_schema', '_brick_order'].include?(k)
+        next if ['_brick_schema', '_brick_order', 'controller', 'action'].include?(k)
 
         case (ks = k.split('.')).length
         when 1
@@ -427,6 +448,9 @@ module ActiveRecord
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
+        # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
+        #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
+        #     Relevant info here:  https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/402
         columns.each do |col|
           col_alias = " AS #{col.name}_" if (col_name = col.name) == 'class'
           selects << if is_mysql
@@ -726,7 +750,8 @@ Module.class_exec do
                # Vabc instead of VABC)
                full_class_name = +''
                full_class_name << "::#{self.name}" unless self == Object
-               full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
+               singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
+               full_class_name << "::#{singular_class_name}"
                if plural_class_name == 'BrickSwagger' ||
                   (
                     (::Brick.config.add_status || ::Brick.config.add_orphans) &&
@@ -1111,64 +1136,65 @@ class Object
           end
           return [new_controller_class, code + "end # BrickGem controller\n"]
         when 'BrickSwagger'
-          is_swagger = true # if request.format == :json)
+          is_swagger = true
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
-          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
-          # wants to do an ORDER BY based on any of that
-          translations = {}
-          join_array = ::Brick::JoinArray.new
-          is_add_bts = is_add_hms = true
-          # This builds out bt_descrip and hm_counts on the model
-          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+          if (is_swagger || 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
+          ::Brick.set_db_schema(params || api_params)
 
           if is_swagger
-            json = { 'openapi': '3.0.1', 'info': { 'title': 'API V1', 'version': 'v1' },
+            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': 'https://{defaultHost}', 'variables': { 'defaultHost': { 'default': 'www.example.com' } } }
+                       { 'url': '{scheme}://{defaultHost}', 'variables': {
+                         'scheme': { 'default': request.env['rack.url_scheme'] },
+                         'defaultHost': { 'default': request.env['HTTP_HOST'] }
+                       } }
                      ]
                    }
-            json['paths'] = relations.inject({}) do |s, v|
-              s["/api/v1/#{v.first}"] = {
-                'get': {
-                  '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}",
-                  'parameters': v.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
-                    { 'name' => k, 'schema': { 'type': v.first } }
-                  end,
-                  'responses': { '200': { 'description': 'successful' } }
+            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' } }
+                  }
                 }
-                # "/api/v1/books/{id}": {
-                #   "parameters": [
-                #     {
-                #       "name": "id",
-                #       "in": "path",
-                #       "description": "id",
-                #       "required": true,
-                #       "schema": {
-                #         "type": "string"
-                #       }
-                #     },
-                #     {
-                #       "name": "Authorization",
-                #       "in": "header",
-                #       "schema": {
-                #         "type": "string"
-                #       }
-                #     }
-                #   ],
-              }
-              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
@@ -1176,6 +1202,14 @@ class Object
 
           # Normal (non-swagger) request
 
+          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
+          # wants to do an ORDER BY based on any of that
+          translations = {}
+          join_array = ::Brick::JoinArray.new
+          is_add_bts = is_add_hms = true
+          # This builds out bt_descrip and hm_counts on the model
+          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+
           # %%% 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)
@@ -1189,8 +1223,9 @@ class Object
             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
+          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
 
@@ -1206,7 +1241,7 @@ class Object
                    "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
                  end
           end
-          instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
+          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_relation.dup._select!(*selects, *counts))
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
@@ -1221,32 +1256,34 @@ class Object
           @_brick_erd = params['_brick_erd']&.to_i
         end
 
-        _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk))
-        code << "  def index\n"
-        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
-        code << "    @#{table_name}.brick_select(params)\n"
-        code << "  end\n"
-
-        is_pk_string = nil
-        if (pk_col = model&.primary_key)
-          code << "  def show\n"
-          code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
+        unless is_swagger
+          ::Brick.set_db_schema
+          _, 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"
+          code << "    @#{table_name.pluralize}.brick_select(params)\n"
           code << "  end\n"
-          self.define_method :show do
-            ::Brick.set_db_schema(params)
-            id = if model.columns_hash[pk_col]&.type == :string
-                   is_pk_string = true
-                   params[:id]
-                 else
-                   params[:id]&.split(/[\/,_]/)
-                 end
-            id = id.first if id.is_a?(Array) && id.length == 1
-            instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+
+          is_pk_string = nil
+          if pk.present?
+            code << "  def show\n"
+            code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
+            code << "  end\n"
+            self.define_method :show do
+              ::Brick.set_db_schema(params)
+              id = if model.columns_hash[pk.first]&.type == :string
+                     is_pk_string = true
+                     params[:id]
+                   else
+                     params[:id]&.split(/[\/,_]/)
+                   end
+              id = id.first if id.is_a?(Array) && id.length == 1
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+            end
           end
-        end
 
-        # By default, views get marked as read-only
-        # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          # By default, views get marked as read-only
+          # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
           code << "  def new\n"
           code << "    @#{singular_table_name} = #{model.name}.new\n"
           code << "  end\n"
@@ -1280,7 +1317,7 @@ class Object
             end
           end
 
-          if pk_col
+          if pk.present?
             # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
             # end
@@ -1327,9 +1364,9 @@ class Object
             end
           end
 
-          code << "private\n" if pk_col || is_need_params
+          code << "private\n" if pk.present? || is_need_params
 
-          if pk_col
+          if pk.present?
             code << "  def find_#{singular_table_name}
     id = params[:id]&.split(/[\\/,_]/)
     @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
@@ -1357,16 +1394,16 @@ class Object
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
           end
-        # end
+        end # unless is_swagger
         code << "end # #{namespace_name}#{class_name}\n"
       end # class definition
       [built_controller, code]
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc, source = nil)
-      if (relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1) &&
+      if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
          hm_assoc[:alternate_name] != (source || name.underscore)
-        plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
+        plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
         new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
         # uniq = 1
         # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
@@ -1497,6 +1534,8 @@ module ActiveRecord::ConnectionHandling
                           r['schema']
                         end
           relation_name = schema_name ? "#{schema_name}.#{r['relation_name']}" : r['relation_name']
+          # Both uppers and lowers as well as underscores?
+          apply_double_underscore_patch if relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
           relation = relations[relation_name]
           relation[:isView] = true if r['table_type'] == 'VIEW'
           relation[:description] = r['table_description'] if r['table_description']
@@ -1513,6 +1552,7 @@ module ActiveRecord::ConnectionHandling
           cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
           cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name), r['is_nullable'] == 'NO']
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
+          relation[:col_descrips][col_name] = r['column_description'] if r['column_description']
         end
       else # MySQL2 and OracleEnhanced act a little differently, bringing back an array for each row
         schema_and_tables = case ActiveRecord::Base.connection.adapter_name
@@ -1542,6 +1582,9 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
 
           if (relation_name = r[1]) =~ /^[A-Z0-9_]+$/
             relation_name.downcase!
+          # Both uppers and lowers as well as underscores?
+          elsif relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
+            apply_double_underscore_patch
           end
           # Expect the default schema for SQL Server to be 'dbo'.
           if (::Brick.is_oracle && r[0] != schema) || (is_mssql && r[0] != 'dbo')
@@ -1660,54 +1703,27 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       end
     end
 
-    tables = []
-    views = []
-    table_class_length = 0
-    view_class_length = 0
     relations.each do |k, v|
-      name_parts = k.split('.')
-      idx = 1
-      name_parts = name_parts.map do |x|
-        (idx += 1) < name_parts.length ? x : x.singularize
-      end
-      name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
-      class_name = name_parts.map(&:camelize).join('::')
-      if v.key?(:isView)
-        view_class_length = class_name.length if class_name.length > view_class_length
-        views
-      else
-        table_class_length = class_name.length if class_name.length > table_class_length
-        tables
-      end << [class_name, name_parts]
-    end
-    puts "\n" if tables.present? || views.present?
-    if tables.present?
-      puts "Classes that can be built from tables:"
-      display_classes(tables, table_class_length)
+      rel_name = k.split('.').map { |rel_part| ::Brick.namify(rel_part, :underscore) }
+      schema_names = rel_name[0..-2]
+      schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
+      v[:schema] = schema_names.join('.') unless schema_names.empty?
+      # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
+      v[:resource] = rel_name.last
+      v[:class_name] = (schema_names + [rel_name.last.singularize]).map(&:camelize).join('::')
     end
-    if views.present?
-      puts "Classes that can be built from views:"
-      display_classes(views, view_class_length)
-    end
-
     ::Brick.load_additional_references if initializer_loaded
   end
 
-  def display_classes(rels, max_length)
-    rels.sort.each do |rel|
-      rel_link = rel.last.dup.map(&:underscore)
-      rel_link[-1] = rel_link[-1].pluralize
-      puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel_link.join('/')}"
-    end
-    puts "\n"
-  end
-
   def retrieve_schema_and_tables(sql = nil, is_postgres = nil, is_mssql = nil, schema = nil)
     is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer' if is_mssql.nil?
     sql ||= "SELECT t.table_schema AS \"schema\", t.table_name AS relation_name, t.table_type,#{"
       pg_catalog.obj_description(
-        ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass, 'pg_class'
-      ) AS table_description," if is_postgres}
+        ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass::oid, 'pg_class'
+      ) AS table_description,
+      pg_catalog.col_description(
+        ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass::oid, c.ordinal_position
+      ) AS column_description," if is_postgres}
       c.column_name, c.data_type,
       COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
       kcu.constraint_type AS const, kcu.constraint_name AS \"key\",
@@ -1751,6 +1767,43 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
     [ar_smtn, ar_imtn]
   end
+
+  def apply_double_underscore_patch
+    unless @double_underscore_applied
+      # Same as normal #camelize and #underscore, just that double-underscores turn into a single underscore
+      ActiveSupport::Inflector.class_eval do
+        def camelize(term, uppercase_first_letter = true)
+          strings = term.to_s.split('__').map do |string|
+            # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
+            if !uppercase_first_letter || uppercase_first_letter == :lower
+              string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+            else
+              string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
+            end
+            string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+              word = $2
+              substituted = inflections.acronyms[word] || word.capitalize! || word
+              $1 ? "::#{substituted}" : substituted
+            end
+            string
+          end
+          strings.join('_')
+        end
+
+        def underscore(camel_cased_word)
+          return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+          camel_cased_word.to_s.gsub("::", "/").split('_').map do |word|
+            word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+            word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
+            word.tr!("-", "_")
+            word.downcase!
+            word
+          end.join('__')
+        end
+      end
+      @double_underscore_applied = true
+    end
+  end
 end
 
 # ==========================================
@@ -1777,7 +1830,7 @@ module Brick
 
   class << self
     def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
-      bt_assoc_name = ::Brick.namify(fk[2], true)
+      bt_assoc_name = ::Brick.namify(fk[2], :downcase)
       unless is_polymorphic
         bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
                           bt_assoc_name[-3] == '_' ? bt_assoc_name[0..-4] : bt_assoc_name[0..-3]
@@ -1878,6 +1931,11 @@ module Brick
 
       return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[1] == exclusion[0] && fk[2] == exclusion[1] && primary_table == exclusion[2] } || hms.nil?
 
+      # if fk[1].end_with?('Suppliers') && fk[4] == 'People'
+      #   puts fk.inspect
+      #   binding.pry
+      # end
+
       if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
         if assoc_hm[:fk].is_a?(String)
           assoc_hm[:fk] = [assoc_hm[:fk], fk[2]] unless fk[2] == assoc_hm[:fk]
@@ -1885,7 +1943,6 @@ module Brick
           assoc_hm[:fk] << fk[2]
         end
         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] && apartment && fk[0] == Apartment.default_schema
                     for_tbl
@@ -1896,7 +1953,7 @@ module Brick
                                           inverse_table: inv_tbl, inverse: assoc_bt }
         assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-        hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
+        this_hm_count = hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
       end
       assoc_bt[:inverse] = assoc_hm
     end

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

@@ -159,7 +159,7 @@ module Brick
                     hms_columns << hm_entry
                   when 'show', 'new', 'update'
                     hm_stuff << if hm_fk_name
-                                  "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                  "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
                                 else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
                                   assoc_name
                                 end
@@ -173,12 +173,13 @@ module Brick
               # environment or whatever, then get either the controllers or routes list instead
               apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
+                                binding.pry if tbl.is_a?(Symbol)
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
                                   tbl = tbl_parts.last
                                 end
                                 s[tbl] = nil
                               end.keys.sort.each_with_object(+'') do |v, s|
-                                s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
+                                s << "<option value=\"#{v.underscore.gsub('.', '/')}\">#{v}</option>"
                               end.html_safe
               table_options << '<option value="brick_status">(Status)</option>'.html_safe if ::Brick.config.add_status
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
@@ -351,15 +352,39 @@ def hide_bcrypt(val, max_len = 200)
 end
 def display_value(col_type, val)
   case col_type
-  when 'geometry'
+  when 'geometry', 'geography'
     if Object.const_defined?('RGeo')
       @is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2' if @is_mysql.nil?
-      if @is_mysql
-        # MySQL's \"Internal Geometry Format\" is like WKB, but with an initial 4 bytes that indicates the SRID.
-        srid = val[0..3].unpack('I')
-        val = val[4..-1]
+      @is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer' if @is_mssql.nil?
+      val_err = nil
+      if @is_mysql || @is_mssql
+        # MySQL's \"Internal Geometry Format\" and MSSQL's Geography are like WKB, but with an initial 4 bytes that indicates the SRID.
+        if (srid = val&.[](0..3)&.unpack('I'))
+          val = val.force_encoding('BINARY')[4..-1].bytes
+
+          # MSSQL spatial bitwise flags, often 0C for a point:
+          # xxxx xxx1 = HasZValues
+          # xxxx xx1x = HasMValues
+          # xxxx x1xx = IsValid
+          # xxxx 1xxx = IsSinglePoint
+          # xxx1 xxxx = IsSingleLineSegment
+          # xx1x xxxx = IsWholeGlobe
+          # Convert Microsoft's unique geography binary to standard WKB
+          # (MSSQL point usually has two doubles, lng / lat, and can also have Z)
+          if @is_mssql
+            if val[0] == 1 && (val[1] & 8 > 0) && # Single point?
+              (val.length - 2) % 8 == 0 && val.length < 27 # And containing up to three 8-byte values?
+              idx = 2
+              new_val = [0, 0, 0, 0, 1]
+              new_val.concat(val[idx - 8...idx].reverse) while (idx += 8) <= val.length
+              val = new_val
+            else
+              val_err = '(Microsoft internal SQL geography type)'
+            end
+          end
+        end
       end
-      RGeo::WKRep::WKBParser.new.parse(val)
+      val_err || (val ? RGeo::WKRep::WKBParser.new.parse(val.pack('c*')) : nil)
     else
       '(Add RGeo gem to parse geometry detail)'
     end
@@ -448,7 +473,7 @@ function changeout(href, param, value, trimAfter) {
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
   if (param === undefined || param === null || param === -1) {
     hrefParts = hrefParts[0].split(\"://\");
-    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
+    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\").filter(function (pp) {return pp !== \"\";});
     if (value === undefined)
       // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
       return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)[0]];
@@ -562,7 +587,7 @@ erDiagram
     <%= \"#\{model_short_name} }o..o{ #\{hm_name} : \\\"#\{hm.first}\\\"\".html_safe %><%
      else # has_many
 %>  <%= \"#\{model_short_name} ||--o{ #\{hm_name} : \\\"#\{
-            hm_name unless hm.first.to_s == hm_class.name.underscore.pluralize.tr('/', '_')
+            hm.first.to_s unless hm.first.to_s.downcase == hm_class.name.underscore.pluralize.tr('/', '_')
           }\\\"\".html_safe %><%
      end %>
 <% end
@@ -604,7 +629,7 @@ erDiagram
                                   end
                          if Object.const_defined?('DutyFree')
                            template_link = "
-  <%= link_to 'CSV', #{table_name}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
+  <%= link_to 'CSV', #{@_brick_model._brick_index}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
   <div id=\"dropper\" contenteditable=\"true\"></div>
   <input type=\"button\" id=\"btnImport\" value=\"Import\">
 
@@ -667,7 +692,7 @@ erDiagram
         console.log(\"x1\", sheetUrl);
 
         // Get JSON data
-        fetch(changeout(<%= #{table_name}_path(format: :js).inspect.html_safe %>, \"_brick_schema\", brickSchema)).then(function (response) {
+        fetch(changeout(<%= #{@_brick_model._brick_index}_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,
@@ -698,10 +723,10 @@ erDiagram
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><tr>
-  <td><h1>#{model_plural = model_name.pluralize}</h1></td>
+  <td><h1>#{model_name}</h1></td>
   <td id=\"imgErd\" title=\"Show ERD\"></td>
 </tr></table>#{template_link}<%
-   if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
+   if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)).present? %><%=
      description %><br><%
    end
    # FILTER PARAMETERS
@@ -712,10 +737,10 @@ erDiagram
        origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
        if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| fk[:fk] == key_parts.last }) &&
           (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
-         <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination.name.underscore.tr('/', '_')\}_path\".to_sym, id) %></h3><%
+         <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination._brick_index\}_path\".to_sym, id) %></h3><%
        end
      end %>
-  (<%= link_to 'See all #{model_plural.split('::').last}', #{path_obj_name.pluralize}_path %>)
+  (<%= link_to 'See all #{model_name.split('::').last.pluralize}', #{@_brick_model._brick_index}_path %>)
 <% end
    # COLUMN EXCLUSIONS
    if @_brick_excl&.present? %>
@@ -768,7 +793,7 @@ erDiagram
               end
        elsif col # HM column
          s << \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col[2]} \"
-         s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1].name.underscore.tr('/', '_').pluralize}_path\"))}\")
+         s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1]._brick_index}_path\"))}\")
        else # Bad column name!
          s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
        end
@@ -776,7 +801,11 @@ erDiagram
      end.html_safe
   %></tr></thead>
   <tbody>
-  <% @#{table_name}.each do |#{obj_name}|
+  <% # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
+     #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
+     #     TinyTds::Error: Adaptive Server connection timed out
+     #     (After restarting the server it worked fine again.)
+     @#{table_name}.each do |#{obj_name}|
        hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
@@ -811,10 +840,11 @@ erDiagram
                    else
                      \"#\{hms_col[1] || 'View'\} #\{hms_col.first}\"
                    end %>
-         <%= link_to txt, send(\"#\{klass.name.underscore.tr('/', '_').pluralize}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
+         <%= link_to txt, send(\"#\{klass._brick_index}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
         <% end
          elsif (col = cols[col_name])
-    %><%=  display_value(col&.type || col&.sql_type, val) %><%
+           col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
+    %><%=  display_value(col_type || col&.sql_type, val) %><%
          else # Bad column name!
       %>?<%
          end
@@ -908,7 +938,7 @@ erDiagram
 if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
   description %><br><%
 end
-%><%= link_to '(See all #{obj_name.pluralize})', #{path_obj_name.pluralize}_path %>
+%><%= link_to '(See all #{obj_name.pluralize})', #{@_brick_model._brick_index}_path %>
 #{erd_markup}
 <% if obj %>
   <br><br>
@@ -974,7 +1004,8 @@ end
             \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
           end %>
     <% else
-      case (col_type = col.type || col.sql_type)
+      col_type = col.sql_type == 'geography' ? col.sql_type : col.type
+      case (col_type ||= col.sql_type)
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly?
              is_revert = false %>
@@ -1008,8 +1039,8 @@ end
       <% when :binary, :primary_key
            is_revert = false %>
       <% else %>
-        <%= display_value(col_type, val)
-           is_revert = false %>
+        <%= is_revert = false
+           display_value(col_type, val) %>
       <% end
        end
        if is_revert
@@ -1077,7 +1108,7 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
   var imgErd = document.getElementById(\"imgErd\");
   var mermaidErd = document.getElementById(\"mermaidErd\");
   var mermaidCode;
-  var cbs = {<%= callbacks.map { |k, v| \"#\{k}: \\\"#\{v.name.underscore.pluralize}\\\"\" }.join(', ').html_safe %>};
+  var cbs = {<%= callbacks.map { |k, v| \"#\{k}: \\\"#\{send(\"#\{v._brick_index}_path\".to_sym)}\\\"\" }.join(', ').html_safe %>};
   if (imgErd) imgErd.addEventListener(\"click\", showErd);
   function showErd() {
     imgErd.style.display = \"none\";
@@ -1101,7 +1132,7 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
               function (evt) {
                 location.href = changeout(changeout(
                   changeout(location.href, '_brick_order', null), // Remove any ordering
-                -1, cbs[this.id]), \"_brick_erd\", \"1\");
+                -1, cbs[this.id].replace(/^[\/]+/, \"\")), \"_brick_erd\", \"1\");
               }
             );
           }

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -125,8 +125,8 @@ module Brick
   class << self
     attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle
 
-    def set_db_schema(params)
-      schema = params['_brick_schema'] || 'public'
+    def set_db_schema(params = nil)
+      schema = (params ? params['_brick_schema'] : ::Brick.default_schema) || 'public'
       if schema && ::Brick.db_schemas&.include?(schema)
         ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
         schema
@@ -152,17 +152,19 @@ module Brick
     end
 
     # Convert spaces to underscores if the second character and onwards is mixed case
-    def namify(name, attempt_downcase = false)
-      name.downcase! if attempt_downcase && name =~ /^[A-Z0-9_]+$/
+    def namify(name, action = nil)
+      has_uppers = name =~ /[A-Z]+/
+      has_lowers = name =~ /[a-z]+/
+      name.downcase! if has_uppers && action == :downcase
       if name.include?(' ')
         # All uppers or all lowers?
-        if name[1..-1] =~ /^[A-Z0-9_]+$/ || name[1..-1] =~ /^[a-z0-9_]+$/
+        if !has_uppers || !has_lowers
           name.titleize.tr(' ', '_')
         else # Mixed uppers and lowers -- just remove existing spaces
           name.tr(' ', '')
         end
       else
-        name
+        action == :underscore ? name.underscore : name
       end
     end
 
@@ -266,6 +268,26 @@ module Brick
       !!Brick.config.enable_routes
     end
 
+    # @api public
+    def enable_api=(path)
+      Brick.config.enable_api = path
+    end
+
+    # @api public
+    def enable_api
+      Brick.config.enable_api
+    end
+
+    # @api public
+    def api_root=(path)
+      Brick.config.api_root = path
+    end
+
+    # @api public
+    def api_root
+      Brick.config.api_root
+    end
+
     # @api public
     def skip_database_views=(value)
       Brick.config.skip_database_views = value
@@ -472,6 +494,13 @@ In config/initializers/brick.rb appropriate entries would look something like:
     def version
       VERSION::STRING
     end
+
+    def display_classes(rels, max_length)
+      rels.sort.each do |rel|
+        puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel.last}"
+      end
+      puts "\n"
+    end
   end
 
   module RouteSet
@@ -479,35 +508,65 @@ In config/initializers/brick.rb appropriate entries would look something like:
       return super if ::Brick.routes_done
 
       ::Brick.routes_done = true
+      tables = []
+      views = []
+      table_class_length = 38 # Length of "Classes that can be built from tables:"
+      view_class_length = 37 # Length of "Classes that can be built from views:"
       existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
       ::Rails.application.routes.append do
         # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
         # If auto-controllers and auto-models are both enabled then this makes sense:
-        ::Brick.relations.each do |rel_name, v|
-          rel_name = rel_name.split('.').map { |x| ::Brick.namify(x).underscore }
-          schema_names = rel_name[0..-2]
-          schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
-          # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
-          k = rel_name.last
-          unless existing_controllers.key?(controller_name = k.pluralize)
+        ::Brick.relations.each do |k, v|
+          unless !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
-            if schema_names.present? # && !Object.const_defined('Apartment')
-              send(:namespace, schema_names.first) do
-                send(:resources, controller_name.to_sym, **options)
+            full_resource = nil
+            if (schema_name = v.fetch(:schema, nil)) # && !Object.const_defined('Apartment')
+              send(:namespace, schema_name) do
+                send(:resources, v[:resource].to_sym, **options)
               end
+              full_resource = "#{schema_name}/#{v[:resource]}"
+              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
             else
-              send(:resources, controller_name.to_sym, **options)
+              send(:resources, v[:resource].to_sym, **options)
+              # Normally goes to something like:  /api/v1/employees
+              send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+            end
+
+            if (class_name = v.fetch(:class_name, nil))
+              if v.key?(:isView)
+                view_class_length = class_name.length if class_name.length > view_class_length
+                views
+              else
+                table_class_length = class_name.length if class_name.length > table_class_length
+                tables
+              end << [class_name, full_resource || v[:resource]]
             end
           end
-          if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
-            get('/brick_status', to: 'brick_gem#status', as: 'brick_status')
-          end
-          if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
-            get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
-          end
         end
-        send(:get, '/api-docs/v1/swagger.json', { to: 'brick_swagger#index' }) if Object.const_defined?('Rswag::Ui')
+        puts "\n" if tables.present? || views.present?
+        if tables.present?
+          puts "Classes that can be built from tables:#{' ' * (table_class_length - 38)}  Path:"
+          puts "======================================#{' ' * (table_class_length - 38)}  ====="
+          ::Brick.display_classes(tables, table_class_length)
+        end
+        if views.present?
+          puts "Classes that can be built from views:#{' ' * (view_class_length - 37)}  Path:"
+          puts "=====================================#{' ' * (view_class_length - 37)}  ====="
+          ::Brick.display_classes(views, view_class_length)
+        end
+
+        if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
+          get('/brick_status', to: 'brick_gem#status', as: 'brick_status')
+        end
+        if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
+          get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
+        end
+        if Object.const_defined?('Rswag::Ui') && doc_endpoint = Rswag::Ui.config.config_object[:urls].last
+          # Serves JSON swagger info from a path such as  '/api-docs/v1/swagger.json'
+          puts "Mounting swagger info endpoint for \"#{doc_endpoint[:name]}\" on #{doc_endpoint[:url]}"
+          send(:get, doc_endpoint[:url], { to: 'brick_swagger#index' })
+        end
       end
       super
     end

data/lib/generators/brick/install_generator.rb

@@ -147,6 +147,8 @@ module Brick
 # Brick.enable_controllers = true # Setting this to \"false\" will disable controllers in development
 # Brick.enable_views = true # Setting this to \"false\" will disable views in development
 
+# ::Brick.api_root = '/api/v1/' # Path from which to serve out API resources when the RSwag gem is present
+
 # # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
 # Brick.skip_database_views = true
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.72
+  version: 1.0.74
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-20 00:00:00.000000000 Z
+date: 2022-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord