niceql 0.1.24 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec80b35674703f65be9841e1596065cb395f71d31eca1704e40648390de88b6c
-  data.tar.gz: b59ca0d932ef22245dc040425260a050441ac69789cb97284983f07e71088bf2
+  metadata.gz: cfbeddac683e41bcbbc3d8fc2c42fcbb505a6d129c58dc9653a93650317c8125
+  data.tar.gz: e4de50a94af55592a2f31ced37b6a1986abdea37ca462ce529bd7bdfabde08be
 SHA512:
-  metadata.gz: c87708d4886737e56558278e958563292cc0dbb955d204ed38ff0c6e8f9f8797bebf1ef67caf531e13f80e70b7f9f762e147f19f762aa8e1f7b9e8cd5c80912f
-  data.tar.gz: 98fc43d968e68143940722d341f828316313b3f614785024a0203ea5e294df4c1c3b3ff4494d207353690ec43b27c64680eee7b71789286257a21bddd4fc44b0
+  metadata.gz: 64dc4d5869ee5e79b408b99fe963bcafd595d44a8c8495e72429d104478ee6811b8eba211ef13527e060746a52e4c4a6c192e17aef95237c6d79248b0a421a12
+  data.tar.gz: 865161e1af50386a06a98ba9e1af708f388f44f96f2566fb3f0695ac4756a66030731c8f8e603d5f7c88a009d4a6f4d840c0c2d9f140e81500411cccba17ee41

data/.travis.yml

@@ -4,4 +4,4 @@ rvm:
   - 2.4
   - 2.5
   - 2.3
-  - 2.2
+  - 2.6

data/CHANGELOG.md

@@ -1,6 +1,24 @@
-# 0.1.24
+# 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 )
 
-* No features, just strict ruby dependency for >= 2.3 and travis fix for ruby 2.3
+# 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,
+* travis fix for ruby 2.3 and 2.6 added
 
 # 0.1.23
  * +LATERAL verb

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 no-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
 
+**Please pay attention: untill issue https://github.com/alekseyl/niceql/issues/16 is resolved any UPDATE or INSERT request will 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")
@@ -43,7 +46,7 @@ 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 
   # 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

data/lib/niceql/version.rb

@@ -1,3 +1,3 @@
 module Niceql
-  VERSION = "0.1.24"
+  VERSION = "0.3.1"
 end

data/lib/niceql.rb

@@ -1,5 +1,4 @@
 require "niceql/version"
-require 'niceql/string'
 
 module Niceql
 
@@ -45,168 +44,181 @@ 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
+      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 +241,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,25 +269,20 @@ 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
@@ -281,5 +295,3 @@ module Niceql
   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.2'
+  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.24
+  version: 0.3.1
 platform: ruby
 authors:
 - alekseyl
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-04-13 00:00:00.000000000 Z
+date: 2021-10-12 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.2'
+      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.1.4
+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?)