niceql 0.3.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfbeddac683e41bcbbc3d8fc2c42fcbb505a6d129c58dc9653a93650317c8125
-  data.tar.gz: e4de50a94af55592a2f31ced37b6a1986abdea37ca462ce529bd7bdfabde08be
+  metadata.gz: 126874d18a0ec3ce725d5f62a63a0cc57012cee9d5268eb189f060d2d1e0b6d0
+  data.tar.gz: '090a0208059e848eda15e721857238c9916a97527e75b672e5216c30b3745ed9'
 SHA512:
-  metadata.gz: 64dc4d5869ee5e79b408b99fe963bcafd595d44a8c8495e72429d104478ee6811b8eba211ef13527e060746a52e4c4a6c192e17aef95237c6d79248b0a421a12
-  data.tar.gz: 865161e1af50386a06a98ba9e1af708f388f44f96f2566fb3f0695ac4756a66030731c8f8e603d5f7c88a009d4a6f4d840c0c2d9f140e81500411cccba17ee41
+  metadata.gz: 400ee6d267eb95de34d1c1e018fceaab42dac6054f08d4bbe90c45c4ea7c366855c45da67b0f3d963d880893e21cbcb70117aa46f7ffe3aff8eacce1aa5d8f75
+  data.tar.gz: 7417f1ddf85cb2959f8eb59a6997154f721dc7696ca66caf60d16b095f7390e17233915680fa176b455a761b135582b76c085ae92b0d89fb53d6a2043c36fc1e

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# 0.5.1
+* No features just some code refactoring
+
+# 0.5.0
+* BREAKING CHANGE! ActiveRecord compatibility extracted to the rails_sql_prettifier gem! 
+  If you need niceql funcitonality with rails / active_record plz include rails_sql_prettifier has a 
+  a versioning aligned to the active_record versions and has same DSL for ActiveRecord the niceql was providing prior.  
+
+# 0.4.1
+* description update 
+
+# 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 

data/README.md

@@ -1,11 +1,13 @@
 # Niceql
 
-This is a small, nice, simple and no-dependency solution for SQL prettifying for Ruby. 
+ATTENTION: Since ver 0.5.0 the ActiveRecord integration will be provided via standalone gem: [rails_sql_prettifier](https://github.com/alekseyl/rails_sql_prettifier)!
+
+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 will corrupt your data, don't use on production!**
+**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 
@@ -44,9 +46,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 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
@@ -56,7 +60,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'
   
@@ -85,7 +89,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  
@@ -110,23 +114,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.3.1"
+  VERSION = '0.5.1'
 end

data/lib/niceql.rb

@@ -4,34 +4,19 @@ 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
 
-  module ArExtentions
-    def exec_niceql
-      connection.execute( to_niceql )
-    end
-
-    def to_niceql
-      Prettifier.prettify_sql(to_sql, false)
-    end
-
-    def 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'
@@ -77,36 +62,31 @@ module Niceql
       # 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 2: ... -> err_line_num = 2
+        err_line_num = err.match(/LINE (\d+):/)[1].to_i
         # LINE 1: SELECT usr FROM users ORDER BY 1
         err_address_line = err.lines[1]
 
-        start_sql_line = 3 if err.lines.length <= 3
+        sql_start_line_num = 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
+        sql_start_line_num ||= err.lines[3][/(HINT|DETAIL)/] ? 4 : 3
+        sql_body_lines = sql_start_line_num < err.lines.length ? err.lines[sql_start_line_num..-1] : original_sql_query&.lines
 
         # this means original query is missing so it's nothing to prettify
-        return err unless sql_body
-
-        # 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]
+        return err unless sql_body_lines
 
+        # this is an SQL line with an error.
+        # we need err_line to properly align the caret in the caret line
+        # and to apply a full red colorizing schema on an SQL line with error
+        err_line = sql_body_lines[err_line_num - 1]
 
-        #colorizing verbs and strings
-        colorized_sql_body = sql_body.join.gsub(/#{VERBS}/ ) { |verb| StringColorize.colorize_verb(verb) }
-          .gsub(STRINGS){ |str| StringColorize.colorize_str(str) }
+        #colorizing verbs, strings and error line
+        err_body = sql_body_lines.map { |ln| ln == err_line ? StringColorize.colorize_err( ln ) : colorize_err_line(ln) }
 
-        #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_caret_line = extract_err_caret_line( err_address_line, err_line, sql_body_lines, err )
         err_body.insert( err_line_num, StringColorize.colorize_err( err_caret_line ) )
 
-        err.lines[0..start_sql_line-1].join + err_body.join
+        err.lines[0..sql_start_line_num-1].join + err_body.join
       end
 
       def prettify_sql( sql, colorize = true )
@@ -198,10 +178,15 @@ module Niceql
         end
       end
 
+      def colorize_err_line( line )
+        line.gsub(/#{VERBS}/ ) { |verb| StringColorize.colorize_verb(verb) }
+          .gsub(STRINGS) { |str| StringColorize.colorize_str(str) }
+      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)
+        err_quote = (err_address_line.match(/\.\.\.(.+)\.\.\./) || err_address_line.match(/\.\.\.(.+)/) )&.send(:[], 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
@@ -223,75 +208,17 @@ module Niceql
     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
-      # 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,
-                  :prettify_active_record_log_output,
-                  :prettify_pg_errors
-
+    attr_accessor :indentation_base, :open_bracket_is_newliner
 
     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 )
+  def self.configure; yield( config ) end
 
-    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
+  def self.config; @config ||= NiceQLConfig.new 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 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.summary       = %q{This is a 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 a simple and nice gem for SQL prettifying and formatting. Niceql splits, indent and colorize SQL query and PG errors if any. Could be used as a standalone gem without any dependencies. Seamless ActiveRecord integration via rails_sql_prettifier gem. }
   spec.homepage      = "https://github.com/alekseyl/niceql"
   spec.license       = "MIT"
 
@@ -31,7 +31,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '>= 2.4'
-  spec.add_development_dependency "activerecord", ">= 6.1"
 
   spec.add_development_dependency "bundler", ">= 1"
   spec.add_development_dependency "rake", ">= 12.3.3"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: niceql
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.1
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-12 00:00:00.000000000 Z
+date: 2022-01-08 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
@@ -122,9 +108,10 @@ dependencies:
     - - ">="
       - !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 '
+description: 'This is a simple and nice gem for SQL prettifying and formatting. Niceql
+  splits, indent and colorize SQL query and PG errors if any. Could be used as a standalone
+  gem without any dependencies. Seamless ActiveRecord integration via rails_sql_prettifier
+  gem. '
 email:
 - leshchuk@gmail.com
 executables: []
@@ -171,9 +158,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.9
 signing_key:
 specification_version: 4
-summary: This is simple and nice gem for sql prettifying and formatting. Niceql splits,
-  indent and colorize SQL query and PG errors if any
+summary: This is a simple and nice gem for SQL prettifying and formatting. Niceql
+  splits, indent and colorize SQL query and PG errors if any.
 test_files: []