brick 1.0.70 → 1.0.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af28a866a39817e9daa3a54b8f091c790d9280571cec94f9a3a317606e239fd9
-  data.tar.gz: a2cfe0b823c8b364c8f842852e631a48efe7f9dde8d506a27fbc85ebb74e58eb
+  metadata.gz: e50dce8dd2821ec196836393569138d4e18c53a9ef1e3e910ddffa6bc3788824
+  data.tar.gz: 982b26f7ed3a14f69589b6c422b37a5ec42b210c095cf85ef0eeab151ea80c59
 SHA512:
-  metadata.gz: 0cc18926c7c449e7dfba8d919d41b2490cb4d4a14692073f98f96903da075a31ff029f7a5f5931a845c7caf8f00b51cdba9ab0711dfa626d9e445d9122350b2b
-  data.tar.gz: 84373ca68edb9ebb88b8ccf2963bbf2e416c35c41840df1c1cd6922ef757cac204453aeb1e15881316681558a53ce17e32692e16320bb1b53c608bc41401920d
+  metadata.gz: 2c0e76b3e092d35f57045f3dd106ae9b8c90b266df0a7c0c973824ed20c1ac41560f124420d164e4e9d170b9a386345f424f19bce01bf041c9ebb553c842e553
+  data.tar.gz: 6d257bbec4c364456be5167b55c2eb377d94cdd0485e56dfb699daf14f3dce7a46c94c91534ecbe9c8f090b564e8752de0c3b88cf7560e01ca9d8388a3ec9930

data/lib/brick/extensions.rb

@@ -99,13 +99,14 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false)
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, emit_dsl = false, is_polymorphic = false)
       build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
       build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
       members = []
       bracket_name = nil
       prefix = [prefix] unless prefix.is_a?(Array)
       if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        dsl2 = +''
         klass = nil
         dsl.each_char do |ch|
           if bracket_name
@@ -125,7 +126,15 @@ module ActiveRecord
                 end
                 translations[parts[0..-2].join('.')] = klass
               end
-              members << parts
+              if klass.column_names.exclude?(parts.last) &&
+                 (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
+                members += members2
+                dsl2 << dsl2a
+              else
+                dsl2 << "[#{bracket_name}]"
+                members << parts
+              end
               bracket_name = nil
             else
               bracket_name << ch
@@ -133,13 +142,20 @@ module ActiveRecord
           elsif ch == '['
             bracket_name = +''
             klass = self
+          else
+            dsl2 << ch
           end
         end
+        # Rewrite the DSL just in case it's different because we had to expand it
+        unless emit_dsl
+          # puts "Compare:\n  #{dsl}\n  #{dsl2}"
+          ::Brick.config.model_descrips[name] = dsl2
+        end
       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
-      members
+      emit_dsl ? [members, dsl2] : members
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -169,9 +185,12 @@ module ActiveRecord
                           this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
                           break if this_obj.nil?
                         end
+                        if this_obj.is_a?(ActiveRecord::Base) && (obj_descrip = this_obj.class.brick_descrip(this_obj))
+                          this_obj = obj_descrip
+                        end
                         this_obj&.to_s || ''
                       end
-              is_brackets_have_content = true unless (datum).blank?
+              is_brackets_have_content = true unless datum.blank?
               output << (datum || '')
               bracket_name = nil
             else
@@ -244,7 +263,8 @@ module ActiveRecord
 
         # join_array will receive this relation name when calling #brick_parse_dsl
         _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
+                                     # Last two params here:  "false" is for don't emit DSL, and "true" is for yes, we are polymorphic
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, false, true) }
                                    else
                                      { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
                                    end
@@ -409,15 +429,37 @@ module ActiveRecord
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         columns.each do |col|
-          col_alias = " AS #{col.name}_" if (col_name = col.name) == 'class'
+          if (col_name = col.name) == 'class'
+            col_alias = " AS #{col.name}_"
+          else
+            alias_name = nil
+            idx = 0
+            col_name.each_char do |c|
+              unless (c >= 'a' && c <= 'z') ||
+                 c == '_' ||
+                 (c >= 'A' && c <= 'Z') ||
+                 (c >= '0' && c <= '9')
+                (alias_name ||= col_name.dup)[idx] = 'x'
+              end
+              ++idx
+            end
+            col_alias = " AS #{alias_name}" if alias_name
+          end
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
                      elsif is_postgres || is_mssql
                        # 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')
+                       cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col_name)&.first&.start_with?('xml')
                        "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
-                     else # Sqlite or Oracle
-                       "#{tbl_no_schema}.#{col_name}#{col_alias}"
+                     elsif col.type # Could be Sqlite or Oracle
+                       if col_alias
+                         "#{tbl_no_schema}.#{col_name}#{col_alias}"
+                       else
+                         "#{tbl_no_schema}.#{col_name}"
+                       end
+                     else # Oracle with a custom data type
+                       typ = col.sql_type
+                       "'<#{typ.end_with?('_TYP') ? typ[0..-5] : typ}>' AS #{col.name}"
                      end
         end
       end
@@ -1415,7 +1457,7 @@ module ActiveRecord::ConnectionHandling
         # ActiveRecord::Base.connection.current_database will be something like "XEPDB1"
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.raw_connection.username
         ::Brick.db_schemas = {}
-        execute_oracle("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
+        ActiveRecord::Base.execute_sql("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
       when 'SQLite'
         sql = "SELECT m.name AS relation_name, UPPER(m.type) AS table_type,
           p.name AS column_name, p.type AS data_type,
@@ -1478,8 +1520,9 @@ module ActiveRecord::ConnectionHandling
         schema_and_tables = case ActiveRecord::Base.connection.adapter_name
                             when 'OracleEnhanced'
                               sql =
-"SELECT c.owner AS schema, c.table_name AS relation_name, 'BASE_TABLE' AS table_type,
-  LOWER(c.column_name) AS column_name, c.data_type,
+"SELECT c.owner AS schema, c.table_name AS relation_name,
+  CASE WHEN v.owner IS NULL THEN 'BASE_TABLE' ELSE 'VIEW' END AS table_type,
+  c.column_name, c.data_type,
   COALESCE(c.data_length, c.data_precision) AS max_length,
   CASE ac.constraint_type WHEN 'P' THEN 'PRIMARY KEY' END AS const,
   ac.constraint_name AS \"key\",
@@ -1487,9 +1530,11 @@ module ActiveRecord::ConnectionHandling
 FROM all_tab_cols c
   LEFT OUTER JOIN all_cons_columns acc ON acc.owner = c.owner AND acc.table_name = c.table_name AND acc.column_name = c.column_name
   LEFT OUTER JOIN all_constraints ac ON ac.owner = acc.owner AND ac.table_name = acc.table_name AND ac.constraint_name = acc.constraint_name AND constraint_type = 'P'
+  LEFT OUTER JOIN all_views v ON c.owner = v.owner AND c.table_name = v.view_name
 WHERE c.owner IN (#{::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')})
+  AND c.table_name NOT IN (?, ?)
 ORDER BY 1, 2, c.internal_column_id, acc.position"
-                              execute_oracle(sql, *ar_tables)
+                              ActiveRecord::Base.execute_sql(sql, *ar_tables)
                             else
                               ActiveRecord::Base.retrieve_schema_and_tables(sql)
                             end
@@ -1579,7 +1624,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         WHERE ac.constraint_type = 'R'
           AND ac.owner IN (#{schemas})
           AND ac.r_owner IN (#{schemas})"
-        fk_references = ActiveRecord::Base.execute_oracle(sql)
+        fk_references = ActiveRecord::Base.execute_sql(sql)
       end
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
@@ -1679,16 +1724,6 @@ 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 execute_oracle(*sql_args)
-    cursor = ActiveRecord::Base.execute_sql(*sql_args)
-    result = []
-    while row = cursor.fetch()
-      result << row
-    end
-    cursor.close
-    result
-  end
 end
 
 # ==========================================

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

@@ -1090,9 +1090,9 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
       mermaid.initialize({
         startOnLoad: true,
         securityLevel: \"loose\",
+        er: { useMaxWidth: false },
         mermaid: {callback: function(objId) {
           var svg = document.getElementById(objId);
-          svg.removeAttribute(\"width\");
           var cb;
           for(cb in cbs) {
             var gErd = svg.getElementById(cb);

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -560,7 +560,7 @@ ActiveSupport.on_load(:active_record) do
         class << self
           def execute_sql(sql, *param_array)
             param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
-            if ActiveRecord::Base.connection.adapter_name == 'SQLServer'
+            if ['OracleEnhanced', 'SQLServer'].include?(ActiveRecord::Base.connection.adapter_name)
               connection.exec_query(send(:sanitize_sql_array, [sql] + param_array)).rows
             else
               connection.execute(send(:sanitize_sql_array, [sql] + param_array))

metadata

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