niceql 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f9f1dc89c0c7353d4b8c63056d43968b0ad2f71a602d4e50ba5a48bfa568ed0
-  data.tar.gz: 9fc1ea32fc0ed3053702b3014dbb270457af028e61b6b1bb63ff6c28005d8ce4
+  metadata.gz: cfbeddac683e41bcbbc3d8fc2c42fcbb505a6d129c58dc9653a93650317c8125
+  data.tar.gz: e4de50a94af55592a2f31ced37b6a1986abdea37ca462ce529bd7bdfabde08be
 SHA512:
-  metadata.gz: e0b76948b56fe949aac0b5582081d42a60e35dede01332772c4fb233bd8c14bd2cf1d029187d25e0bb85c20d660f29763d401f2283695f28da36c0053293411c
-  data.tar.gz: 2be8cfca05e187114624a2c70b9318c2dd161c42aca5c3ad90456e2ea2a46cda59de1aadd4d22e8e1111155078fa03b986ce4e7624e809776934eb0c0c94dcb5
+  metadata.gz: 64dc4d5869ee5e79b408b99fe963bcafd595d44a8c8495e72429d104478ee6811b8eba211ef13527e060746a52e4c4a6c192e17aef95237c6d79248b0a421a12
+  data.tar.gz: 865161e1af50386a06a98ba9e1af708f388f44f96f2566fb3f0695ac4756a66030731c8f8e603d5f7c88a009d4a6f4d840c0c2d9f140e81500411cccba17ee41

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 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. 

data/lib/niceql/version.rb

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

data/lib/niceql.rb

@@ -1,5 +1,4 @@
 require "niceql/version"
-require 'niceql/string'
 
 module Niceql
 
@@ -45,167 +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 self.prettify_err(err)
-      prettify_pg_err( err.to_s )
-    end
+      def prettify_err(err, original_sql_query = nil)
+        prettify_pg_err( err.to_s, original_sql_query )
+      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.
-
-    # 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
+      # Postgres error output:
+      # ERROR:  VALUES in FROM must have an alias
+      # LINE 2: FROM ( VALUES(1), (2) );
+      #              ^
+      # HINT:  For example, FROM (VALUES ...) [AS] foo.
 
-      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"
+      # May go without HINT or DETAIL:
+      # ERROR:  column "usr" does not exist
+      # LINE 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) }
+      # 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
 
-      #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 ) )
+      # 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]
 
-      err.lines[0..start_sql_line-1].join + err_body.join
-    end
+        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
 
-    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
+        # this means original query is missing so it's nothing to prettify
+        return err unless sql_body
 
-        # !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
+        # 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 = 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
+        #colorizing verbs and strings
+        colorized_sql_body = sql_body.join.gsub(/#{VERBS}/ ) { |verb| StringColorize.colorize_verb(verb) }
+          .gsub(STRINGS){ |str| StringColorize.colorize_str(str) }
+
+        #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
@@ -228,7 +241,9 @@ module Niceql
 
   module ErrorExt
     def to_s
-      Niceql.config.prettify_pg_errors ? Prettifier.prettify_err(super) : super
+      # 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
 
@@ -280,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,7 +30,7 @@ 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"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: niceql
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-22 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,8 +122,9 @@ 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 '
+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: []
@@ -147,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
@@ -164,7 +164,7 @@ 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:
   - - ">="
@@ -174,6 +174,6 @@ requirements: []
 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?)