niceql 0.1.25 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b460b8c53129e07c90a14ebf63de07534d07bda56e8b563df2570659d597163
-  data.tar.gz: 63c4c608e1ae3c087ff4f3e8099a6ad3f3352a13498cfd9d54ca551fd8284c0b
+  metadata.gz: 2056d114407ed81b47224f1bc0f60d2e65bb88118667f074fd972149203bd6ea
+  data.tar.gz: 48c228ee2240a0fd8beec6ecc1c312b42197a8a259bf1d5b438e41fd55c51680
 SHA512:
-  metadata.gz: c71dc21142f026ce021836437215fe92b87451b64c58cf1b9c6aa492e5c8a1e2186b97f6e1e9f114cf074cdae9f36d3e381863eebd5dd7e5e4a88c4483299056
-  data.tar.gz: 60986d42e844edcda1f6a66b83d3edc1b311078a463c15d321ea3e9218f33252764bb2391a7f598fbcbffc6e9cc4af97c6862a072b4b357ff11afd14680830e1
+  metadata.gz: 070a9574f50f434136474dfc1b671956b8df3529434f2e13f36e4b4c952a1dbc23da5a9e81a5d8eba082154c523c6056476b25396ec52654dcbe0436ae04c18e
+  data.tar.gz: e8b550669250d612233b7fdbced172d12cd6d348dd8bfda21ff6ff8dda0358c6cf59e23aa917bbade0f49286017173a10099488a830d1e0802efd71faa98b35a

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+# 0.4.0
+* merged PR https://github.com/alekseyl/niceql/pull/19, now Arel is also extended with niceql methods!!
+* test and better niceql comparisons assertion
+* tests were trialed against rails 4.2 and some additional conditions were added for later cases
+
+# 0.3.0 
+* ruby forced to >= 2.4
+* String match extension no longer needed 
+* fixed issue with missing HINT and DETAIL string ( https://github.com/alekseyl/niceql/issues/18 )
+* both new and old activerecord StatementInvalid formats supported
+* major prettify_pg_err refactoring ( much cleaner code now )
+
+# 0.2.0
+* Fix to issue https://github.com/alekseyl/niceql/pull/17#issuecomment-924278172. ActiveRecord base config is no longer a hash, 
+so it does not have dig method, hence it's breaking the ar_using_pg_adapter? method. 
+* active_record added as development dependency :( for proper testing cover. 
+
+# 0.1.30
+* ActiveRecord pg check for config now will try both connection_db_config and connection_config for adapter verification 
+* prettify_pg_errors will not be set to true if ActiveRecord adapter is not using pg, i.e. ar_using_pg_adapter? is false. 
+* rake dev dependency bumped according to security issues
+
 # 0.1.24/25
 
 * No features, just strict ruby dependency for >= 2.3,

data/README.md

@@ -1,10 +1,13 @@
 # Niceql
 
-This is a small, nice, simple and dependentless solution for SQL prettifiyng for Ruby. 
+This is a small, nice, simple and zero dependency solution for SQL prettifying for Ruby. 
 It can be used in an irb console without any dependencies ( run bin/console and look for examples ).
 
-Any reasonable suggestions on formatting/coloring are welcome
+Any reasonable suggestions are welcome. 
 
+**Please pay attention: untill issue https://github.com/alekseyl/niceql/issues/16 is resolved any UPDATE or INSERT request might corrupt your data, don't use on production!**
+
+ 
 ## Before/After 
 ### SQL prettifier: 
 ![alt text](https://github.com/alekseyl/niceql/raw/master/to_niceql.png "To_niceql")
@@ -41,9 +44,11 @@ Or install it yourself as:
 ```ruby
 Niceql.configure do |c|
   # Setting pg_adapter_with_nicesql to true will force formatting SQL queries
-  # before executing them, this will lead to better SQL-query debugging and much more clearer error messages 
+  # before execution. Formatted SQL will lead to much better SQL-query debugging and much more clearer error messages 
   # if you are using Postgresql as a data source.  
-  # You can adjust pg_adapter in prooduction but do it at your own risk!
+  # 
+  # You can adjust pg_adapter in production but do it at your own risk!
+  # 
   # If you need to debug SQL queries in production use exec_niceql
   # default: false
   # uncomment next string to enable in development
@@ -53,7 +58,7 @@ Niceql.configure do |c|
   # default: false
   # c.prettify_active_record_log_output = true
   
-  # now error prettifying is configurable
+  # Error prettifying is also configurable
   # default: defined? ::ActiveRecord::Base && ActiveRecord::Base.configurations[Rails.env]['adapter'] == 'postgresql'
   # c.prettify_pg_errors = defined? ::ActiveRecord::Base && ActiveRecord::Base.configurations[Rails.env]['adapter'] == 'postgresql'
   
@@ -82,7 +87,7 @@ end
 ### With ActiveRecord
 
 ```ruby
-  # puts colorized ( or not if you are willing so ) to_niceql ( you need to call puts otherwise to_niceql looks ugly  )
+  # puts colorized and formatted corresponding SQL query
   Model.scope.niceql
   
   # only formatting without colorization, you can run output of to_niceql as a SQL query in connection.execute  
@@ -107,23 +112,23 @@ end
     #=>
     #=>  SELECT * 
     #=>  FROM table
-   
-   
-
+    
 
-   # rails combines err with query, so don't forget to do it yourself:
-   puts Niceql::Prettifier.prettify_pg_err( "#{pg_err_output}\n#{sql_query}" )
+   puts Niceql::Prettifier.prettify_pg_err( pg_err_output, sql_query )
    
    # to get real nice result you should execute prettified version (i.e. execute( prettified_sql ) !) of query on your DB! 
    # otherwise you will not get such a nice output
-    puts Niceql::Prettifier.prettify_pg_err(<<~ERR )
+    raw_sql = <<~SQL
+     SELECT err 
+     FROM ( VALUES(1), (2) )
+     ORDER BY 1
+    SQL
+
+    puts Niceql::Prettifier.prettify_pg_err(<<~ERR, raw_sql )
         ERROR:  VALUES in FROM must have an alias
         LINE 2:  FROM ( VALUES(1), (2) )
                       ^
         HINT:  For example, FROM (VALUES ...) [AS] foo.
-         SELECT err 
-         FROM ( VALUES(1), (2) )
-         ORDER BY 1
     ERR
        
     

data/lib/niceql/version.rb

@@ -1,3 +1,3 @@
 module Niceql
-  VERSION = "0.1.25"
+  VERSION = '0.4.0'
 end

data/lib/niceql.rb

@@ -1,19 +1,18 @@
 require "niceql/version"
-require 'niceql/string'
 
 module Niceql
 
   module StringColorize
     def self.colorize_verb( str)
-      #yellow ANSI color
+      # yellow ANSI color
       "\e[0;33;49m#{str}\e[0m"
     end
     def self.colorize_str(str)
-      #cyan ANSI color
+      # cyan ANSI color
       "\e[0;36;49m#{str}\e[0m"
     end
     def self.colorize_err(err)
-      #red ANSI color
+      # red ANSI color
       "\e[0;31;49m#{err}\e[0m"
     end
   end
@@ -45,168 +44,182 @@ module Niceql
     SQL_COMMENTS_CLEARED = /(\s*?--.+\s{1})|(\s*$\s*\/\*[^\/\*]*\*\/\s{1})/
     COMMENT_CONTENT = /[\S]+[\s\S]*[\S]+/
 
-    def self.config
-      Niceql.config
-    end
+    class << self
+      def config
+        Niceql.config
+      end
 
+      def prettify_err(err, original_sql_query = nil)
+        prettify_pg_err( err.to_s, original_sql_query )
+      end
 
-    def self.prettify_err(err)
-      prettify_pg_err( err.to_s )
-    end
 
+      # Postgres error output:
+      # ERROR:  VALUES in FROM must have an alias
+      # LINE 2: FROM ( VALUES(1), (2) );
+      #              ^
+      # HINT:  For example, FROM (VALUES ...) [AS] foo.
 
-    # Postgres error output:
-    # ERROR:  VALUES in FROM must have an alias
-    # LINE 2: FROM ( VALUES(1), (2) );
-    #              ^
-    # HINT:  For example, FROM (VALUES ...) [AS] foo.
-
-    # May go without HINT or DETAIL:
-    # ERROR:  column "usr" does not exist
-    # LINE 1: SELECT usr FROM users ORDER BY 1
-    #                ^
-
-    # ActiveRecord::StatementInvalid will add original SQL query to the bottom like this:
-    # ActiveRecord::StatementInvalid: PG::UndefinedColumn: ERROR:  column "usr" does not exist
-    # LINE 1: SELECT usr FROM users ORDER BY 1
-    #                ^
-    #: SELECT usr FROM users ORDER BY 1
-
-    # prettify_pg_err parses ActiveRecord::StatementInvalid string,
-    # but you may use it without ActiveRecord either way:
-    # prettify_pg_err( err + "\n" + sql ) OR prettify_pg_err( err, sql )
-    # don't mess with original sql query, or prettify_pg_err will deliver incorrect results
-    def self.prettify_pg_err(err, original_sql_query = nil)
-      return err if err[/LINE \d+/].nil?
-      err_line_num = err[/LINE \d+/][5..-1].to_i
-
-      #
-      start_sql_line = err.lines[3][/(HINT|DETAIL)/] ? 4 : 3
-      err_body = start_sql_line < err.lines.length ? err.lines[start_sql_line..-1] : original_sql_query&.lines
-
-
-      # this means original query is missing so it's nothing to prettify
-      return err unless err_body
-
-      err_quote = ( err.lines[1][/\.\.\..+\.\.\./] && err.lines[1][/\.\.\..+\.\.\./][3..-4] ) ||
-          ( err.lines[1][/\.\.\..+/] && err.lines[1][/\.\.\..+/][3..-1] )
-
-      # line[2] is err carret line i.e.: '      ^'
-      # err.lines[1][/LINE \d+:/].length+1..-1 - is a position from error quote begin
-      err_carret_line = err.lines[2][err.lines[1][/LINE \d+:/].length+1..-1]
-      # err line will be painted in red completely, so we just remembering it and use
-      # to replace after paiting the verbs
-      err_line = err_body[err_line_num-1]
-
-      # when err line is too long postgres quotes it part in double '...'
-      if err_quote
-        err_quote_carret_offset = err_carret_line.length - err.lines[1].index( '...' ) + 3
-        err_carret_line =  ' ' * ( err_line.index( err_quote ) + err_quote_carret_offset ) + "^\n"
-      end
+      # May go without HINT or DETAIL:
+      # ERROR:  column "usr" does not exist
+      # LINE 1: SELECT usr FROM users ORDER BY 1
+      #                ^
 
-      err_carret_line = "  " + err_carret_line if err_body[0].start_with?(': ')
-      # if mistake is on last string than err_line.last != \n so we need to prepend \n to carret line
-      err_carret_line = "\n" + err_carret_line unless err_line[-1] == "\n"
+      # ActiveRecord::StatementInvalid will add original SQL query to the bottom like this:
+      # ActiveRecord::StatementInvalid: PG::UndefinedColumn: ERROR:  column "usr" does not exist
+      # LINE 1: SELECT usr FROM users ORDER BY 1
+      #                ^
+      #: SELECT usr FROM users ORDER BY 1
 
-      #colorizing verbs and strings
-      err_body = err_body.join.gsub(/#{VERBS}/ ) { |verb| StringColorize.colorize_verb(verb) }
-                     .gsub(STRINGS){ |str| StringColorize.colorize_str(str) }
+      # prettify_pg_err parses ActiveRecord::StatementInvalid string,
+      # but you may use it without ActiveRecord either way:
+      # prettify_pg_err( err + "\n" + sql ) OR prettify_pg_err( err, sql )
+      # don't mess with original sql query, or prettify_pg_err will deliver incorrect results
+      def prettify_pg_err(err, original_sql_query = nil)
+        return err if err[/LINE \d+/].nil?
+        err_line_num = err[/LINE \d+/][5..-1].to_i
+        # LINE 1: SELECT usr FROM users ORDER BY 1
+        err_address_line = err.lines[1]
 
-      #reassemling error message
-      err_body = err_body.lines
-      err_body[err_line_num-1]= StringColorize.colorize_err( err_line )
-      err_body.insert( err_line_num, StringColorize.colorize_err( err_carret_line ) )
+        start_sql_line = 3 if err.lines.length <= 3
+        # error not always contains HINT
+        start_sql_line ||= err.lines[3][/(HINT|DETAIL)/] ? 4 : 3
+        sql_body = start_sql_line < err.lines.length ? err.lines[start_sql_line..-1] : original_sql_query&.lines
 
-      err.lines[0..start_sql_line-1].join + err_body.join
-    end
+        # this means original query is missing so it's nothing to prettify
+        return err unless sql_body
 
-    def self.prettify_sql( sql, colorize = true )
-      indent = 0
-      parentness = []
-
-      sql = sql.split( SQL_COMMENTS ).each_slice(2).map{ | sql_part, comment |
-        # remove additional formatting for sql_parts but leave comment intact
-        [sql_part.gsub(/[\s]+/, ' '),
-         # comment.match?(/\A\s*$/) - SQL_COMMENTS gets all comment content + all whitespaced chars around
-         # so this sql_part.length == 0 || comment.match?(/\A\s*$/) checks does the comment starts from new line
-         comment && ( sql_part.length == 0 || comment.match?(/\A\s*$/) ? "\n#{comment[COMMENT_CONTENT]}\n" : comment[COMMENT_CONTENT] ) ]
-      }.flatten.join(' ')
-
-      sql.gsub!(/ \n/, "\n")
-
-      sql.gsub!(STRINGS){ |str| StringColorize.colorize_str(str) } if colorize
-
-      first_verb  = true
-      prev_was_comment = false
-
-      sql.gsub!( /(#{VERBS}|#{BRACKETS}|#{SQL_COMMENTS_CLEARED})/) do |verb|
-        if 'SELECT' == verb
-          indent += config.indentation_base if !config.open_bracket_is_newliner || parentness.last.nil? || parentness.last[:nested]
-          parentness.last[:nested] = true if parentness.last
-          add_new_line = !first_verb
-        elsif verb == '('
-          next_closing_bracket = Regexp.last_match.post_match.index(')')
-          # check if brackets contains SELECT statement
-          add_new_line = !!Regexp.last_match.post_match[0..next_closing_bracket][/SELECT/] && config.open_bracket_is_newliner
-          parentness << { nested: add_new_line }
-        elsif verb == ')'
-          # this also covers case when right bracket is used without corresponding left one
-          add_new_line = parentness.last.nil? || parentness.last[:nested]
-          indent -= ( parentness.last.nil? ? 2 * config.indentation_base : (parentness.last[:nested] ? config.indentation_base : 0) )
-          indent = 0 if indent < 0
-          parentness.pop
-        elsif verb[POSSIBLE_INLINER]
-          # in postgres ORDER BY can be used in aggregation function this will keep it
-          # inline with its agg function
-          add_new_line = parentness.last.nil? || parentness.last[:nested]
-        else
-          add_new_line = verb[/(#{INLINE_VERBS})/].nil?
-        end
+        # err line will be painted in red completely, so we just remembering it and use
+        # to replace after painting the verbs
+        err_line = sql_body[err_line_num - 1]
 
-        # !add_new_line && previous_was_comment means we had newlined comment, and now even
-        # if verb is inline verb we will need to add new line with indentation BUT all
-        # inliners match with a space before so we need to strip it
-        verb.lstrip! if !add_new_line && prev_was_comment
 
-        add_new_line = prev_was_comment unless add_new_line
-        add_indent = !first_verb && add_new_line
+        #colorizing verbs and strings
+        colorized_sql_body = sql_body.join.gsub(/#{VERBS}/ ) { |verb| StringColorize.colorize_verb(verb) }
+          .gsub(STRINGS){ |str| StringColorize.colorize_str(str) }
 
-        if verb[SQL_COMMENTS_CLEARED]
-          verb = verb[COMMENT_CONTENT]
-          prev_was_comment = true
-        else
-          first_verb = false
-          prev_was_comment = false
+        #reassemling error message
+        err_body = colorized_sql_body.lines
+        # replacing colorized line contained error and adding caret line
+        err_body[err_line_num - 1]= StringColorize.colorize_err( err_line )
+
+        err_caret_line = extract_err_caret_line( err_address_line, err_line, sql_body, err )
+        err_body.insert( err_line_num, StringColorize.colorize_err( err_caret_line ) )
+
+        err.lines[0..start_sql_line-1].join + err_body.join
+      end
+
+      def prettify_sql( sql, colorize = true )
+        indent = 0
+        parentness = []
+
+        sql = sql.split( SQL_COMMENTS ).each_slice(2).map{ | sql_part, comment |
+          # remove additional formatting for sql_parts but leave comment intact
+          [sql_part.gsub(/[\s]+/, ' '),
+           # comment.match?(/\A\s*$/) - SQL_COMMENTS gets all comment content + all whitespaced chars around
+           # so this sql_part.length == 0 || comment.match?(/\A\s*$/) checks does the comment starts from new line
+           comment && ( sql_part.length == 0 || comment.match?(/\A\s*$/) ? "\n#{comment[COMMENT_CONTENT]}\n" : comment[COMMENT_CONTENT] ) ]
+        }.flatten.join(' ')
+
+        sql.gsub!(/ \n/, "\n")
+
+        sql.gsub!(STRINGS){ |str| StringColorize.colorize_str(str) } if colorize
+
+        first_verb  = true
+        prev_was_comment = false
+
+        sql.gsub!( /(#{VERBS}|#{BRACKETS}|#{SQL_COMMENTS_CLEARED})/) do |verb|
+          if 'SELECT' == verb
+            indent += config.indentation_base if !config.open_bracket_is_newliner || parentness.last.nil? || parentness.last[:nested]
+            parentness.last[:nested] = true if parentness.last
+            add_new_line = !first_verb
+          elsif verb == '('
+            next_closing_bracket = Regexp.last_match.post_match.index(')')
+            # check if brackets contains SELECT statement
+            add_new_line = !!Regexp.last_match.post_match[0..next_closing_bracket][/SELECT/] && config.open_bracket_is_newliner
+            parentness << { nested: add_new_line }
+          elsif verb == ')'
+            # this also covers case when right bracket is used without corresponding left one
+            add_new_line = parentness.last.nil? || parentness.last[:nested]
+            indent -= ( parentness.last.nil? ? 2 * config.indentation_base : (parentness.last[:nested] ? config.indentation_base : 0) )
+            indent = 0 if indent < 0
+            parentness.pop
+          elsif verb[POSSIBLE_INLINER]
+            # in postgres ORDER BY can be used in aggregation function this will keep it
+            # inline with its agg function
+            add_new_line = parentness.last.nil? || parentness.last[:nested]
+          else
+            add_new_line = verb[/(#{INLINE_VERBS})/].nil?
+          end
+
+          # !add_new_line && previous_was_comment means we had newlined comment, and now even
+          # if verb is inline verb we will need to add new line with indentation BUT all
+          # inliners match with a space before so we need to strip it
+          verb.lstrip! if !add_new_line && prev_was_comment
+
+          add_new_line = prev_was_comment unless add_new_line
+          add_indent = !first_verb && add_new_line
+
+          if verb[SQL_COMMENTS_CLEARED]
+            verb = verb[COMMENT_CONTENT]
+            prev_was_comment = true
+          else
+            first_verb = false
+            prev_was_comment = false
+          end
+
+          verb = StringColorize.colorize_verb(verb) if !%w[( )].include?(verb) && colorize
+
+          subs = ( add_indent ? indent_multiline(verb, indent) : verb)
+          !first_verb && add_new_line ? "\n" + subs : subs
         end
 
-        verb = StringColorize.colorize_verb(verb) if !['(', ')'].include?(verb) && colorize
+        # clear all spaces before newlines, and all whitespaces before strings endings
+        sql.tap{ |slf| slf.gsub!( /\s+\n/, "\n" ) }.tap{ |slf| slf.gsub!(/\s+\z/, '') }
+      end
 
-        subs = ( add_indent ? indent_multiline(verb, indent) : verb)
-        !first_verb && add_new_line ? "\n" + subs : subs
+      def prettify_multiple( sql_multi, colorize = true )
+        sql_multi.split( /(?>#{SQL_COMMENTS})|(\;)/ ).inject(['']) { |queries, pattern|
+          queries.last << pattern
+          queries << '' if pattern == ';'
+          queries
+        }.map!{ |sql|
+          # we were splitting by comments and ;, so if next sql start with comment we've got a misplaced \n\n
+          sql.match?(/\A\s+\z/) ? nil : prettify_sql( sql, colorize )
+        }.compact.join("\n\n")
       end
 
-      # clear all spaces before newlines, and all whitespaces before string end
-      sql.tap{ |slf| slf.gsub!( /\s+\n/, "\n" ) }.tap{ |slf| slf.gsub!(/\s+\z/, '') }
-    end
+      private_class_method
+      def indent_multiline( verb, indent )
+        if verb.match?(/.\s*\n\s*./)
+          verb.lines.map!{|ln| ln.prepend(' ' * indent)}.join("\n")
+        else
+          verb.prepend(' ' * indent)
+        end
+      end
 
-    def self.prettify_multiple( sql_multi, colorize = true )
-      sql_multi.split( /(?>#{SQL_COMMENTS})|(\;)/ ).inject(['']) { |queries, pattern|
-        queries.last << pattern
-        queries << '' if pattern == ';'
-        queries
-      }.map!{ |sql|
-        # we were splitting by comments and ;, so if next sql start with comment we've got a misplaced \n\n
-        sql.match?(/\A\s+\z/) ? nil : prettify_sql( sql, colorize )
-      }.compact.join("\n\n")
-    end
+      private_class_method
+      def extract_err_caret_line( err_address_line, err_line, sql_body, err )
+        # LINE could be quoted ( both sides and sometimes only from one ):
+        # "LINE 1: ...t_id\" = $13 AND \"products\".\"carrier_id\" = $14 AND \"product_t...\n",
+        err_quote = (err_address_line.match(/\.\.\.(.+)\.\.\./) || err_address_line.match(/\.\.\.(.+)/) ).try(:[], 1)
+
+        # line[2] is original err caret line i.e.: '      ^'
+        # err_address_line[/LINE \d+:/].length+1..-1 - is a position from error quote begin
+        err_caret_line = err.lines[2][err_address_line[/LINE \d+:/].length+1..-1]
+
+        # when err line is too long postgres quotes it in double '...'
+        # so we need to reposition caret against original line
+        if err_quote
+          err_quote_caret_offset = err_caret_line.length - err_address_line.index( '...' ).to_i + 3
+          err_caret_line =  ' ' * ( err_line.index( err_quote ) + err_quote_caret_offset ) + "^\n"
+        end
 
-    private
-    def self.indent_multiline( verb, indent )
-      #
-      if verb.match?(/.\s*\n\s*./)
-        verb.lines.map!{|ln| "#{' ' * indent}" + ln}.join("\n")
-      else
-        "#{' ' * indent}" + verb.to_s
+        # older versions of ActiveRecord were adding ': ' before an original query :(
+        err_caret_line.prepend('  ') if sql_body[0].start_with?(': ')
+        # if mistake is on last string than err_line.last != \n then we need to prepend \n to caret line
+        err_caret_line.prepend("\n") unless err_line[-1] == "\n"
+        err_caret_line
       end
     end
   end
@@ -229,15 +242,22 @@ module Niceql
 
   module ErrorExt
     def to_s
-      if Niceql.config.prettify_pg_errors && ActiveRecord::Base.connection_config['adapter'] == 'postgresql'
-        Prettifier.prettify_err(super)
-      else
-        super
-      end
+      # older rails version do not provide sql as a standalone query, instead they
+      # deliver joined message
+      Niceql.config.prettify_pg_errors ? Prettifier.prettify_err(super, try(:sql) ) : super
     end
   end
 
   class NiceQLConfig
+    def ar_using_pg_adapter?
+      return false unless defined?(::ActiveRecord::Base)
+
+      adapter = ActiveRecord::Base.try(:connection_db_config).try(:adapter) ||
+        ActiveRecord::Base.try(:connection_config)&.with_indifferent_access&.dig(:adapter)
+
+      adapter == 'postgresql'
+    end
+
     attr_accessor :pg_adapter_with_nicesql,
                   :indentation_base,
                   :open_bracket_is_newliner,
@@ -250,36 +270,30 @@ module Niceql
       self.indentation_base = 2
       self.open_bracket_is_newliner = false
       self.prettify_active_record_log_output = false
-      self.prettify_pg_errors = defined? ::ActiveRecord::Base && ActiveRecord::Base.connection_config['adapter'] == 'postgresql'
+      self.prettify_pg_errors = ar_using_pg_adapter?
     end
   end
 
-
   def self.configure
     yield( config )
 
-    if config.pg_adapter_with_nicesql
-      ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(PostgresAdapterNiceQL)
-    end
+    return unless defined? ::ActiveRecord::Base
 
-    if config.prettify_active_record_log_output
-      ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend( AbstractAdapterLogPrettifier )
-    end
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(PostgresAdapterNiceQL) if config.pg_adapter_with_nicesql
 
-    if config.prettify_pg_errors
-      ::ActiveRecord::StatementInvalid.include( Niceql::ErrorExt )
-    end
+    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend( AbstractAdapterLogPrettifier ) if config.prettify_active_record_log_output
+
+    ::ActiveRecord::StatementInvalid.include( Niceql::ErrorExt ) if config.prettify_pg_errors && config.ar_using_pg_adapter?
   end
 
   def self.config
     @config ||= NiceQLConfig.new
   end
 
-  if defined? ::ActiveRecord::Base
-    ::ActiveRecord::Base.extend ArExtentions
-    [::ActiveRecord::Relation, ::ActiveRecord::Associations::CollectionProxy].each { |klass| klass.send(:include, ArExtentions) }
+  if defined? ::ActiveRecord
+    [::ActiveRecord::Relation,
+     ::Arel::TreeManager,
+     ::Arel::Nodes::Node].each { |klass| klass.send(:include, ArExtentions) }
   end
 
 end
-
-

data/niceql.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["alekseyl"]
   spec.email         = ["leshchuk@gmail.com"]
 
-  spec.summary       = %q{This is simple and nice sql prettifier, it splits, indent and colorize SQL query and PG errors if any }
-  spec.description   = %q{This is simple and nice sql prettifier, it splits, indent and colorize SQL query and PG error if any }
+  spec.summary       = %q{This is simple and nice gem for sql prettifying and formatting. Niceql splits, indent and colorize SQL query and PG errors if any }
+  spec.description   = %q{This is simple and nice gem for sql prettifying and formatting. Niceql splits, indent and colorize SQL query and PG errors if any. Seemless activerecord integration }
   spec.homepage      = "https://github.com/alekseyl/niceql"
   spec.license       = "MIT"
 
@@ -30,12 +30,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.3'
+  spec.required_ruby_version = '>= 2.4'
+  spec.add_development_dependency "activerecord", ">= 6.1"
+
   spec.add_development_dependency "bundler", ">= 1"
-  spec.add_development_dependency "rake", "~> 10"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "minitest", "~> 5.0"
 
   spec.add_development_dependency "differ"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency 'sqlite3'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: niceql
 version: !ruby/object:Gem::Version
-  version: 0.1.25
+  version: 0.4.0
 platform: ruby
 authors:
 - alekseyl
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-04-13 00:00:00.000000000 Z
+date: 2021-11-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -28,16 +42,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -94,8 +108,23 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 'This is simple and nice sql prettifier, it splits, indent and colorize
-  SQL query and PG error if any '
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'This is simple and nice gem for sql prettifying and formatting. Niceql
+  splits, indent and colorize SQL query and PG errors if any. Seemless activerecord
+  integration '
 email:
 - leshchuk@gmail.com
 executables: []
@@ -119,7 +148,6 @@ files:
 - lib/generators/niceql/install_generator.rb
 - lib/generators/templates/niceql_initializer.rb
 - lib/niceql.rb
-- lib/niceql/string.rb
 - lib/niceql/version.rb
 - niceql.gemspec
 - to_niceql.png
@@ -128,7 +156,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -136,17 +164,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.0.9
+signing_key:
 specification_version: 4
-summary: This is simple and nice sql prettifier, it splits, indent and colorize SQL
-  query and PG errors if any
+summary: This is simple and nice gem for sql prettifying and formatting. Niceql splits,
+  indent and colorize SQL query and PG errors if any
 test_files: []

data/lib/niceql/string.rb

@@ -1,5 +0,0 @@
-class String
-  def match?(pattern)
-    self =~ pattern
-  end
-end unless String.method_defined?(:match?)