querly 0.15.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 876ab59fc5630b135ecc548b1fe7e520bc05a9549885940a6c7e67ce03562922
-  data.tar.gz: 2010216ed4481282e6b7cbdfc2a15817519e36e15c90d2617250477b5e73288a
+  metadata.gz: 3604de13f36852d57290140b9bf4e4bfeb5811ffb8dbfef054a3e0ce8e9aa47a
+  data.tar.gz: '09038f2030b2c6bc859cfbd7087ae62da8efd2ac4ae1e3b945741d3f65d3146b'
 SHA512:
-  metadata.gz: e19840999c05c19ad328569415c0d83852de02f277fb0924133ac6f21a85a32f688eaa4821213acdafec0dfcc451f322b3b19ace20ad637ed4561839225cc632
-  data.tar.gz: 4b597d4ad3e6b426b63e3293892818a0621d8d6bc0000a897c9adf1227033bc340c4388cdc47f8c2cdc67266ebb90919eaf8be71e5ca397c232163de2348a3f3
+  metadata.gz: 8c2dbbd840b5eb4fa65418c4d2ab81af6154dbbac94c96d083c4f7f9d88e5447666f7d583b54f4c266f52c4f4f15d2f38210c353762c2f8c281785da161d0aec
+  data.tar.gz: 4fd40dc297b03b7de10e3f1bb348a553d1af355f3e6310feed4b9b8e1fe5324757684e443cb8a699952bc0ccfedcf95f072e13890b5cc838f4c2850b7ef09d58

data/.github/workflows/rubocop.yml

@@ -0,0 +1,18 @@
+name: RuboCop
+
+on: pull_request
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.6
+    - run: gem install rubocop rubocop-rubycw --no-document
+    - name: Run RuboCop
+      shell: bash
+      run: |
+        # https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-error-message
+        rubocop | ruby -pe 'sub(/^(.+):(\d+):(\d+): (.): (.+)$/, %q{::error file=\1,line=\2,col=\3::\5})'

data/.github/workflows/ruby.yml

@@ -0,0 +1,22 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - master
+  pull_request: {}
+
+jobs:
+  test:
+    runs-on: "ubuntu-latest"
+    strategy:
+      matrix:
+        ruby: [2.6, 2.7, head]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - run: bundle install --jobs 4 --retry 3
+    - run: bin/setup
+    - run: bundle exec rake build test

data/.rubocop.yml

@@ -0,0 +1,10 @@
+require:
+  - rubocop-rubycw
+
+AllCops:
+  DisabledByDefault: true
+  Exclude:
+    - test/data/**/*.rb
+
+Rubycw/Rubycw:
+  Enabled: true

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## master
 
+## 1.2.0 (2020-12-15)
+
+* Relax Thor version requirements by @y-yagi ([#85](https://github.com/soutaro/querly/pull/85))
+* Fix ERB comment preprocessing by @mallowlabs ([#84](https://github.com/soutaro/querly/pull/84))
+* Better error message for Ruby code syntax error by @ybiquitous ([#83](https://github.com/soutaro/querly/pull/83))
+
+## 1.1.0 (2020-05-17)
+
+* Fix invalid bytes sequence in UTF-8 error by @mallowlabs [#75](https://github.com/soutaro/querly/pull/75)
+* Detect safe navigation operator as a method call by @pocke [#71](https://github.com/soutaro/querly/pull/71)
+
+## 1.0.0 (2019-7-19)
+
+* Add `--config` option for `find` and `console` [#67](https://github.com/soutaro/querly/pull/67)
+* Improve preprocessor performance by processing concurrently [#68](https://github.com/soutaro/querly/pull/68)
+
+## 0.16.0 (2019-04-23)
+
+* Support string literal pattern (@pocke) [#64](https://github.com/soutaro/querly/pull/64)
+* Allow underscore method name pattern (@pocke) [#63](https://github.com/soutaro/querly/pull/63)
+* Add erb support (@hanachin) [#61](https://github.com/soutaro/querly/pull/61)
+* Add `exit` command on console (@wata727) [#59](https://github.com/soutaro/querly/pull/59)
+
+## 0.15.1 (2019-03-12)
+
+* Relax parser version requirement
+
 ## 0.15.0 (2019-02-13)
 
 * Fix broken `querly init` template (@ybiquitous) #56

data/README.md

@@ -1,6 +1,8 @@
+![Querly logo](https://github.com/soutaro/querly/blob/master/logo/Querly%20horizontal.png)
+
 # Querly - Pattern Based Checking Tool for Ruby
 
-[![Build Status](https://travis-ci.org/soutaro/querly.svg?branch=master)](https://travis-ci.org/soutaro/querly)
+![Ruby](https://github.com/soutaro/querly/workflows/Ruby/badge.svg)
 
 Querly is a query language and tool to find out method calls from Ruby programs.
 Define rules to check your program with patterns to find out *bad* pieces.

data/Rakefile

@@ -11,7 +11,7 @@ task :default => :test
 task :build => :racc
 task :test => :racc
 
-rule /\.rb/ => ".y" do |t|
+rule %r/\.rb/ => ".y" do |t|
   sh "racc", "-v", "-o", "#{t.name}", "#{t.source}"
 end
 

data/bin/setup

@@ -4,5 +4,4 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
-
-# Do any other automated setup that you need to do here
+bundle exec rake racc

data/lib/querly.rb

@@ -5,6 +5,7 @@ require "parser/ruby25"
 require "set"
 require "open3"
 require "active_support/inflector"
+require "parallel"
 
 require "querly/version"
 require 'querly/analyzer'

data/lib/querly/cli.rb

@@ -12,6 +12,7 @@ module Querly
     option :root
     option :format, default: "text", type: :string, enum: %w(text json)
     option :rule, type: :string
+    option :threads, default: Parallel.processor_count, type: :numeric
     def check(*paths)
       require 'querly/cli/formatter'
 
@@ -23,6 +24,8 @@ module Querly
                   end
       formatter.start
 
+      threads = Integer(options[:threads])
+
       begin
         unless config_path.file?
           STDERR.puts <<-Message
@@ -32,20 +35,15 @@ Specify configuration file by --config option.
           exit 1
         end
 
-        root_option = options[:root]
-        root_path = root_option ? Pathname(root_option).realpath : config_path.parent.realpath
-
-        config = begin
-          yaml = YAML.load(config_path.read)
-          Config.load(yaml, config_path: config_path, root_dir: root_path, stderr: STDERR)
+        begin
+          config = config(root_option: options[:root])
         rescue => exn
           formatter.config_error config_path, exn
-          exit 1
         end
 
         analyzer = Analyzer.new(config: config, rule: options[:rule])
 
-        ScriptEnumerator.new(paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) }, config: config).each do |path, script|
+        ScriptEnumerator.new(paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) }, config: config, threads: threads).each do |path, script|
           case script
           when Script
             analyzer.scripts << script
@@ -67,6 +65,8 @@ Specify configuration file by --config option.
     end
 
     desc "console [paths]", "Start console for given paths"
+    option :config, default: "querly.yml"
+    option :threads, default: Parallel.processor_count, type: :numeric
     def console(*paths)
       require 'querly/cli/console'
       home_path = if (path = ENV["QUERLY_HOME"])
@@ -75,21 +75,32 @@ Specify configuration file by --config option.
                        Pathname(Dir.home) + ".querly"
                      end
       home_path.mkdir unless home_path.exist?
+      config = config_path.file? ? config(root_option: nil) : nil
+      threads = Integer(options[:threads])
 
       Console.new(
         paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) },
         history_path: home_path + "history",
-        history_size: ENV["QUERLY_HISTORY_SIZE"]&.to_i || 1_000_000
+        history_size: ENV["QUERLY_HISTORY_SIZE"]&.to_i || 1_000_000,
+        config: config,
+        threads: threads
       ).start
     end
 
     desc "find pattern [paths]", "Find for the pattern in given paths"
+    option :config, default: "querly.yml"
+    option :threads, default: Parallel.processor_count, type: :numeric
     def find(pattern, *paths)
       require 'querly/cli/find'
 
+      config = config_path.file? ? config(root_option: nil) : nil
+      threads = Integer(options[:threads])
+
       Find.new(
         pattern: pattern,
         paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) },
+        config: config,
+        threads: threads
       ).start
     end
 
@@ -125,6 +136,13 @@ Specify configuration file by --config option.
 
     private
 
+    def config(root_option:)
+      root_path = root_option ? Pathname(root_option).realpath : config_path.parent.realpath
+
+      yaml = YAML.load(config_path.read)
+      Config.load(yaml, config_path: config_path, root_dir: root_path, stderr: STDERR)
+    end
+
     def config_path
       [Pathname(options[:config]),
        Pathname("querly.yaml")].compact.find(&:file?) || Pathname(options[:config])

data/lib/querly/cli/console.rb

@@ -8,13 +8,17 @@ module Querly
       attr_reader :paths
       attr_reader :history_path
       attr_reader :history_size
+      attr_reader :config
       attr_reader :history
+      attr_reader :threads
 
-      def initialize(paths:, history_path:, history_size:)
+      def initialize(paths:, history_path:, history_size:, config: nil, threads:)
         @paths = paths
         @history_path = history_path
         @history_size = history_size
+        @config = config
         @history = []
+        @threads = threads
       end
 
       def start
@@ -42,9 +46,9 @@ Querly #{VERSION}, interactive console
       def analyzer
         return @analyzer if @analyzer
 
-        @analyzer = Analyzer.new(config: nil, rule: nil)
+        @analyzer = Analyzer.new(config: config, rule: nil)
 
-        ScriptEnumerator.new(paths: paths, config: nil).each do |path, script|
+        ScriptEnumerator.new(paths: paths, config: config, threads: threads).each do |path, script|
           case script
           when Script
             @analyzer.scripts << script
@@ -60,7 +64,7 @@ Querly #{VERSION}, interactive console
       def start_loop
         while line = Readline.readline("> ", true)
           case line
-          when "quit"
+          when "quit", "exit"
             exit
           when "reload!"
             STDOUT.print "reloading..."

data/lib/querly/cli/find.rb

@@ -7,10 +7,14 @@ module Querly
 
       attr_reader :pattern_str
       attr_reader :paths
+      attr_reader :config
+      attr_reader :threads
 
-      def initialize(pattern:, paths:)
+      def initialize(pattern:, paths:, config: nil, threads:)
         @pattern_str = pattern
         @paths = paths
+        @config = config
+        @threads = threads
       end
 
       def start
@@ -36,7 +40,7 @@ module Querly
         puts "#{count} results"
       rescue => exn
         STDOUT.puts Rainbow("Error: #{exn}").red
-        STDTOU.puts "pattern: #{pattern_str}"
+        STDOUT.puts "pattern: #{pattern_str}"
         STDOUT.puts "Backtrace:"
         STDOUT.puts format_backtrace(exn.backtrace)
       end
@@ -48,9 +52,9 @@ module Querly
       def analyzer
         return @analyzer if @analyzer
 
-        @analyzer = Analyzer.new(config: nil, rule: nil)
+        @analyzer = Analyzer.new(config: config, rule: nil)
 
-        ScriptEnumerator.new(paths: paths, config: nil).each do |path, script|
+        ScriptEnumerator.new(paths: paths, config: config, threads: threads).each do |path, script|
           case script
           when Script
             @analyzer.scripts << script

data/lib/querly/cli/formatter.rb

@@ -46,7 +46,12 @@ module Querly
 
         def script_error(path, error)
           STDERR.puts Rainbow("Failed to load script: #{path}").red
-          STDERR.puts error.inspect
+
+          if error.is_a? Parser::SyntaxError
+            STDERR.puts error.diagnostic.render
+          else
+            STDERR.puts error.inspect
+          end
         end
 
         def issue_found(script, rule, pair)

data/lib/querly/node_pair.rb

@@ -25,7 +25,7 @@ module Querly
         yield self
 
         children.each do |child|
-          child.each_subpair &block
+          child.each_subpair(&block)
         end
       else
         enum_for :each_subpair

data/lib/querly/pattern/expr.rb

@@ -118,7 +118,7 @@ module Querly
 
           when :str
             return false unless type == :string
-            test_value(node.children.first)
+            test_value(node.children.first.scrub)
 
           when :sym
             return false unless type == :symbol
@@ -147,7 +147,8 @@ module Querly
 
         def =~(pair)
           # Skip send node with block
-          if pair.node.type == :send && pair.parent
+          type = pair.node.type
+          if (type == :send || type == :csend) && pair.parent
             if pair.parent.node.type == :block
               if pair.parent.node.children.first.equal? pair.node
                 return false
@@ -176,7 +177,7 @@ module Querly
           node = node.children.first if node&.type == :block
 
           case node&.type
-          when :send
+          when :send, :csend
             return false unless test_name(node)
             return false unless test_receiver(node.children[0])
             return false unless test_args(node.children.drop(2), args)
@@ -290,7 +291,8 @@ module Querly
           if receiver.test_node(node)
             true
           else
-            node&.type == :send && test_node(node.children[0])
+            type = node&.type
+            (type == :send || type == :csend) && test_node(node.children[0])
           end
         end
       end
@@ -315,7 +317,7 @@ module Querly
             # We don't want lvar without method call
             # Skips when the node is not receiver of :send
             parent_node = pair.parent&.node
-            if parent_node && parent_node.type == :send && parent_node.children.first.equal?(node)
+            if parent_node && (parent_node.type == :send || parent_node.type == :csend) && parent_node.children.first.equal?(node)
               test_node(node)
             end
           else
@@ -325,7 +327,7 @@ module Querly
 
         def test_node(node)
           case node&.type
-          when :send
+          when :send, :csend
             node.children[1] == name
           when :lvar
             node.children.first == name

data/lib/querly/pattern/parser.y

@@ -72,7 +72,7 @@ keyword: LIDENT | UIDENT
 constant: UIDENT { result = [val[0]] }
   | UIDENT COLONCOLON constant { result = [val[0]] + val[2] }
 
-send: LIDENT block { result = val[1] != nil ? Expr::Send.new(receiver: nil, name: val[0], args: Argument::AnySeq.new, block: val[1]) : Expr::Vcall.new(name: val[0]) }
+send: LIDENT block { result = val[1] != nil ? Expr::Send.new(receiver: nil, name: val[0], block: val[1]) : Expr::Vcall.new(name: val[0]) }
   | UIDENT block { result = Expr::Send.new(receiver: nil, name: val[0], block: val[1]) }
   | method_name { result = Expr::Send.new(receiver: nil, name: val[0], block: nil) }
   | method_name_or_ident LPAREN args RPAREN block { result = Expr::Send.new(receiver: nil,
@@ -83,18 +83,15 @@ send: LIDENT block { result = val[1] != nil ? Expr::Send.new(receiver: nil, name
                                                                   name: val[1],
                                                                   args: Argument::AnySeq.new,
                                                                   block: val[2]) }
-  | receiver method_name_or_ident block { result = Expr::Send.new(receiver: val[0],
-                                                                  name: val[1],
-                                                                  args: Argument::AnySeq.new,
-                                                                  block: val[2]) }
-  | receiver method_name_or_ident LPAREN args RPAREN block { result = Expr::Send.new(receiver: val[0],
-                                                                                     name: val[1],
-                                                                                     args: val[3],
-                                                                                     block: val[5]) }
   | receiver method_name_or_ident LPAREN args RPAREN block { result = Expr::Send.new(receiver: val[0],
                                                                                      name: val[1],
                                                                                      args: val[3],
                                                                                      block: val[5]) }
+  | receiver UNDERBAR block { result = Expr::Send.new(receiver: val[0], name: /.+/, block: val[2]) }
+  | receiver UNDERBAR LPAREN args RPAREN block { result = Expr::Send.new(receiver: val[0],
+                                                                         name: /.+/,
+                                                                         args: val[3],
+                                                                         block: val[5]) }
 
 receiver: expr DOT { result = val[0] }
   | expr DOTDOTDOT { result = Expr::ReceiverContext.new(receiver: val[0]) }
@@ -136,6 +133,8 @@ def next_token
     [:NIL, false]
   when input.scan(/:string:/)
     [:STRING, nil]
+  when input.scan(/"([^"]+)"/)
+    [:STRING, input[1]]
   when input.scan(/:dstr:/)
     [:DSTR, nil]
   when input.scan(/:int:/)

data/lib/querly/pp/cli.rb

@@ -42,7 +42,7 @@ module Querly
       end
 
       def run
-        available_commands = [:haml]
+        available_commands = [:haml, :erb]
 
         if available_commands.include?(command)
           send :"run_#{command}"
@@ -70,6 +70,25 @@ module Querly
           stdout.print compiler.precompiled
         end
       end
+
+      def run_erb
+        require 'better_html'
+        require 'better_html/parser'
+        load_libs
+        source = stdin.read
+        source_buffer = Parser::Source::Buffer.new('(erb)')
+        source_buffer.source = source
+        parser = BetterHtml::Parser.new(source_buffer, template_language: :html)
+
+        new_source = source.gsub(/./, ' ')
+        parser.ast.descendants(:erb).each do |erb_node|
+          indicator_node, _, code_node, = *erb_node
+          next if indicator_node&.loc&.source == '#'
+          new_source[code_node.loc.range] = code_node.loc.source
+          new_source[code_node.loc.range.end] = ';'
+        end
+        stdout.puts new_source
+      end
     end
   end
 end