niceql 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 264d9831dd135d386118453dfc912b85aa97dcc866155c371da81c7798b75176
-  data.tar.gz: e382a97252e22a92669979c4cab769eec2aa2ab22d4f451477cb6ac25ade22bf
+SHA1:
+  metadata.gz: 2efa447fea2f15e044d0a45b3ded037e4c217fbd
+  data.tar.gz: 5dab381173c89ee753d0acd16e7188fdf0e9f9d7
 SHA512:
-  metadata.gz: c5d169c36f65290b307db45b0cac7de922e552947cd7f9f24a3521e063c0165a17c2860e0869314e7a197d5f04aac3c6ab3f342d49323f61a13331630c1e0fec
-  data.tar.gz: ce58c850f4ee047fd7720f45da3b1f2bcee01596a2e94f51bccd7c039e92f6709a2c4f02d3395e1e4ef99fc3d8d02c2a8ba35191f62fadd662443a4ff1888e6d
+  metadata.gz: 49542e72e28b3a823306092b2bdb86eca0de2ae88cb74422c694aa7c92fa010d67e35f7feacc03689dfb89e8176c6412028a3ada6620f5c3926f587fc123067d
+  data.tar.gz: d124bc68f6699adc1ef8ce1f5efa8ae3372023e835a62753465849ba2e0b5bab5809601aca295e8f40aa79b7f050636c088c2c9c326a04ba10e1245e685e54eb

data/.travis.yml

@@ -1,7 +1,5 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4
-  - 2.5
-  - 2.3
-  - 2.6
+  - 2.4.1
+before_install: gem install bundler -v 1.15.4

data/README.md

@@ -1,13 +1,10 @@
 # Niceql
 
-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 ).
+This is small, nice, simple and dependentless solution for SQL prettifiyng for Ruby. 
+It can be used in irb console without any dependencies ( run ./console from bin 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")
@@ -32,123 +29,66 @@ gem 'niceql'
 And then execute:
 
     $ bundle
-    # if you are using rails, you may want to install niceql config:
-    rails g niceql:install 
 
 Or install it yourself as:
 
     $ gem install niceql
 
-## Configuration
-
-```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 
-  # if you are using Postgresql as a data source.  
-  # 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
-  # c.pg_adapter_with_nicesql = Rails.env.development?
-  
-  # uncomment next string if you want to log prettified SQL inside ActiveRecord logging. 
-  # default: false
-  # c.prettify_active_record_log_output = true
-  
-  # now error prettifying is 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'
-  
-  # spaces count for one indentation
-  c.indentation_base = 2
-  
-  # setting open_bracket_is_newliner to true will start opening brackets '(' with nested subqueries from new line 
-  # i.e. SELECT * FROM ( SELECT * FROM tags ) tags; will transform to: 
-  # SELECT * 
-  # FROM 
-  # ( 
- #    SELECT * FROM tags 
- #  ) tags; 
- # when open_bracket_is_newliner is false: 
-  # SELECT * 
-  # FROM ( 
- #   SELECT * FROM tags 
- # ) tags; 
- # default: false
-  c.open_bracket_is_newliner = false
-end
-```
-
 ## Usage
 
 ### With ActiveRecord
 
 ```ruby
-  # puts colorized ( or not if you are willing so ) to_niceql ( you need to call puts otherwise to_niceql looks ugly  )
-  Model.scope.niceql
+  # puts prettified to_sql ( you need to call puts otherwise to_niceql looks ugly  )
+  Model.scope.puts_niceql
   
-  # only formatting without colorization, you can run output of to_niceql as a SQL query in connection.execute  
+  # only formatting without colorization can run as SQL query in connection.execute  
   Model.scope.to_niceql
   
-  # prettify PG errors if scope runs with any 
-  Model.scope_with_err.exec_niceql 
+  # prettify PG errors 
+  Model.scope_with_err.explain_err 
 ```
 
 ### Without ActiveRecord
 
 ```ruby
+   puts Niceql::Prettifier.prettify_sql("SELECT * FROM ( VALUES(1), (2) ) AS tmp")
    
-    puts Niceql::Prettifier.prettify_sql("SELECT * FROM ( VALUES(1), (2) ) AS tmp")
-    #=>  SELECT * 
-    #=>  FROM ( VALUES(1), (2) ) AS tmp
-    
-    puts Niceql::Prettifier.prettify_multiple("SELECT * FROM ( VALUES(1), (2) ) AS tmp; SELECT * FROM table")
-    
-    #=>  SELECT * 
-    #=>  FROM ( VALUES(1), (2) ) AS tmp;
-    #=>
-    #=>  SELECT * 
-    #=>  FROM table
+   # see colors in irb %) 
+   #=>  SELECT * 
+   #=>  FROM ( VALUES(1), (2) ) AS tmp
+
+   # rails combines err with query, so don't forget to do it yourself 
+   # to get real nice result you should execute on your DB prettified_sql! 
+   # otherwise you will not get such a nice output
    
+   puts Niceql::Prettifier.prettify_pg_err(<<-ERR )
+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
    
 
-
-   # 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}" )
-   
-   # 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 )
-        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
-       
-    
-    # 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
+# 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
 
 ```
-
-## Customizing colors
-If your console support more colors or different schemes, or if you prefer different colorization, then you can override ColorizeString methods. Current colors are selected with dark and white console themes in mind, so a niceql colorization works good for dark, and good enough for white.
-
 ## Limitations
 
-Right now gem detects only uppercased form of verbs with simple indentation and parsing options. 
+Right now gem detects only uppercased form of verbs with very simple indentation and parsing options. 
 
-## 
+## Customizing colors
+If your console support more colors or different schemes, or you prefer different colorization, then you can override ColorizeString methods. Current color are selected with dark and white console themes in mind, so niceql colorization works good for dark, and good enough for white.
 
 ## Contributing
 

data/lib/niceql/version.rb

@@ -1,3 +1,3 @@
 module Niceql
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/niceql.rb

@@ -1,8 +1,6 @@
 require "niceql/version"
-require 'niceql/string'
 
 module Niceql
-
   module StringColorize
     def self.colorize_verb( str)
       #yellow ANSI color
@@ -19,264 +17,92 @@ module Niceql
   end
 
   module ArExtentions
-    def exec_niceql
-      connection.execute( to_niceql )
+    def explain_err
+      begin
+        connection.execute( "EXPLAIN #{to_niceql}" )
+      rescue StandardError => e
+        puts Prettifier.prettify_err(e )
+      end
     end
 
     def to_niceql
       Prettifier.prettify_sql(to_sql, false)
     end
 
-    def niceql( colorize = true )
+    def puts_niceql( colorize = true )
       puts Prettifier.prettify_sql( to_sql, colorize )
     end
-
   end
 
   module Prettifier
-    INLINE_VERBS = %w(WITH ASC (IN\s) COALESCE AS WHEN THEN ELSE END AND UNION ALL ON DISTINCT INTERSECT EXCEPT EXISTS NOT COUNT ROUND CAST).join('| ')
-    NEW_LINE_VERBS = 'SELECT|FROM|WHERE|CASE|ORDER BY|LIMIT|GROUP BY|(RIGHT |LEFT )*(INNER |OUTER )*JOIN( LATERAL)*|HAVING|OFFSET|UPDATE'
-    POSSIBLE_INLINER = /(ORDER BY|CASE)/
-    VERBS = "#{NEW_LINE_VERBS}|#{INLINE_VERBS}"
+    INLINE_VERBS = %w(ASC IN AS WHEN THEN ELSE END AND UNION ALL WITH ON DISTINCT INTERSECT EXCEPT EXISTS NOT).join('| ')
+    NEW_LINE_VERBS = 'SELECT|FROM|WHERE|CASE|ORDER BY|LIMIT|GROUP BY|WITH|LEFT JOIN|RIGHT JOIN|JOIN|HAVING|OFFSET'
+    VERBS = "#{INLINE_VERBS}|#{NEW_LINE_VERBS}"
     STRINGS = /("[^"]+")|('[^']+')/
     BRACKETS = '[\(\)]'
-    SQL_COMMENTS = /(\s*?--.+\s*)|(\s*?\/\*[^\/\*]*\*\/\s*)/
-    # only newlined comments will be matched
-    SQL_COMMENTS_CLEARED = /(\s*?--.+\s{1})|(\s*$\s*\/\*[^\/\*]*\*\/\s{1})/
-    COMMENT_CONTENT = /[\S]+[\s\S]*[\S]+/
-
-    def self.config
-      Niceql.config
-    end
 
     def self.prettify_err(err)
-      prettify_pg_err( err.to_s )
+      if ActiveRecord::Base.configurations[Rails.env]['adapter'] == 'postgresql'
+        prettify_pg_err( err.to_s )
+      else
+        puts err
+      end
     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?
+    def self.prettify_pg_err(err)
       err_line_num = err[/LINE \d+/][5..-1].to_i
+      start_sql_line = err.lines[3][/HINT/] ? 4 : 3
+      err_body = err.lines[start_sql_line..-1]
+      err_line = StringColorize.colorize_err( err_body[err_line_num-1] )
 
-      #
-      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
-
-      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"
-
-      #colorizing verbs and strings
       err_body = err_body.join.gsub(/#{VERBS}/ ) { |verb| StringColorize.colorize_verb(verb) }
-                     .gsub(STRINGS){ |str| StringColorize.colorize_str(str) }
+      err_body = err_body.gsub(STRINGS){ |str| StringColorize.colorize_str(str) }
 
-      #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 ) )
-
-      err.lines[0..start_sql_line-1].join + err_body.join
+      err_body[err_line_num-1]= err_line
+      err_body.insert( err_line_num, StringColorize.colorize_err( err.lines[2][err.lines[1][/LINE \d+:/].length+1..-1] ) )
+      puts err.lines[0..start_sql_line-1].join + err_body.join
     end
 
     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
-
+      sql = 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|
+      sql.gsub( /(#{VERBS}|#{BRACKETS})/) do |verb|
+        add_new_line = false
         if 'SELECT' == verb
-          indent += config.indentation_base if !config.open_bracket_is_newliner || parentness.last.nil? || parentness.last[:nested]
+          indent += 1
           parentness.last[:nested] = true if parentness.last
           add_new_line = !first_verb
+          first_verb = false
         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 }
+          parentness << { nested: false }
+          indent += 1
         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 -= add_new_line ? 2 : 1
           indent = 0 if indent < 0
           parentness.pop
-        elsif verb[POSSIBLE_INLINER]
+        elsif verb == 'ORDER BY'
           # 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 !['(', ')'].include?(verb) && colorize
-
-        subs = ( add_indent ? indent_multiline(verb, indent) : verb)
-        !first_verb && add_new_line ? "\n" + subs : subs
-      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
-
-    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
-    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
+        add_new_line ? "\n#{' ' * indent}" + verb : verb
       end
     end
   end
 
-  module PostgresAdapterNiceQL
-    def exec_query(sql, name = "SQL", binds = [], prepare: false)
-      # replacing sql with prettified sql, thats all
-      super( Prettifier.prettify_sql(sql, false), name, binds, prepare: prepare )
-    end
-  end
-
-  module AbstractAdapterLogPrettifier
-    def log( sql, *args, &block )
-      # \n need to be placed because AR log will start with action description + time info.
-      # rescue sql - just to be sure Prettifier wouldn't break production
-      formatted_sql = "\n" + Prettifier.prettify_sql(sql) rescue sql
-      super( formatted_sql, *args, &block )
-    end
-  end
-
-  module ErrorExt
-    def to_s
-      Niceql.config.prettify_pg_errors ? Prettifier.prettify_err(super) : super
-    end
-  end
-
-  class NiceQLConfig
-    def ar_using_pg_adapter?
-      return false unless defined?(::ActiveRecord::Base)
-
-      config = ActiveRecord::Base.try(:connection_db_config) || ActiveRecord::Base.try(:connection_config)
-      config&.dig('adapter') == 'postgresql'
-    end
-
-    attr_accessor :pg_adapter_with_nicesql,
-                  :indentation_base,
-                  :open_bracket_is_newliner,
-                  :prettify_active_record_log_output,
-                  :prettify_pg_errors
-
-
-    def initialize
-      self.pg_adapter_with_nicesql = false
-      self.indentation_base = 2
-      self.open_bracket_is_newliner = false
-      self.prettify_active_record_log_output = false
-      self.prettify_pg_errors = ar_using_pg_adapter?
-    end
-  end
-
-  def self.configure
-    yield( config )
-
-    return unless defined? ::ActiveRecord::Base
-
-    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(PostgresAdapterNiceQL) if config.pg_adapter_with_nicesql
-
-    ::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) }
   end
-
 end
-
-

data/niceql.gemspec

@@ -30,12 +30,8 @@ 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.add_development_dependency "bundler", ">= 1"
-  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
 
-  spec.add_development_dependency "differ"
-  spec.add_development_dependency "pry-byebug"
-  spec.add_development_dependency "benchmark-ips"
 end