querly 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5456868e454a547396bd4b60fbf2b0ac444c2b9
-  data.tar.gz: 3a04207f49e5ea83fea0b56b6be17211bd9ab60b
+  metadata.gz: 691aa5292cedd241455746b5e4f7cd4e4f72f82c
+  data.tar.gz: 47b1c349087fdc731b4740f40c15901a2c1db080
 SHA512:
-  metadata.gz: 9ff30c3f252e24793e5a00b244a7c67453b64e2e746cf508647abfc8a35e7a02a28e243cd4593ac4e7e76aef557dcf4af4f9ce4890b3a028e166d1ce2c8ee94c
-  data.tar.gz: 5aad7656fe6e61c7ca70542b379f16166929ccc288149c8b2e0230029cef6e4ff4d3b1dfe28231eaa139b19decbc6cbbc7051ffd03550cbbefa09d53f5bda07d
+  metadata.gz: bf05476ed45253cd0738db867ba33325bd00e3b4eee6bb20f2eb0caafd19a3a7672d31a2e3db8491e44e1a397f53314757249cc815fa67a0d4bc6d25d0223332
+  data.tar.gz: b99a104c7d4914d195226b04c06b87b6243a79634b35935fea05fa7dae3cfd563f63dc5cd99ef0a3dff3c87babb35b1d0efd700f59306c032f5013840c796b84

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master
 
+## 0.5.0 (2017-06-16)
+
+* Exit 1 on test failure #9
+* Fix example index printing in test (@pocke) #8, #10
+* Introduce pattern matching on method name by set of string and regexp
+* Rule definitions in config can have more structured `examples` attribute
+
+## 0.4.0 (2017-05-25)
+
+* Update `parser` to 2.4 compatible version
+* Check more pathnames which looks like Ruby by default (@pocke) #7
+
 ## 0.3.1 (2017-02-16)
 
 * Allow `require` rules from config file

data/lib/querly.rb

@@ -4,8 +4,7 @@ require "rainbow"
 require "parser/current"
 require "set"
 require "open3"
-
-Parser::Builders::Default.emit_lambda = true
+require "active_support/inflector"
 
 require "querly/version"
 require 'querly/analyzer'

data/lib/querly/cli.rb

@@ -71,7 +71,7 @@ Specify configuration file by --config option.
     option :config, default: "querly.yml"
     def test()
       require "querly/cli/test"
-      Test.new(config_path: config_path).run
+      exit Test.new(config_path: config_path).run
     end
 
     desc "rules", "Print loaded rules"

data/lib/querly/cli/console.rb

@@ -42,7 +42,8 @@ Querly #{VERSION}, interactive console
           when Script
             @analyzer.scripts << script
           when StandardError
-            p script
+            p path: path, script: script.inspect
+            p script.backtrace
           end
         end
 
@@ -61,7 +62,7 @@ Querly #{VERSION}, interactive console
             STDOUT.puts " done"
           when /^find (.+)/
             begin
-              pattern = Pattern::Parser.parse($1)
+              pattern = Pattern::Parser.parse($1, where: {})
 
               count = 0
 

data/lib/querly/cli/formatter.rb

@@ -122,6 +122,12 @@ module Querly
                     id: rule.id,
                     messages: rule.messages,
                     justifications: rule.justifications,
+                    examples: rule.examples.map {|example|
+                      {
+                        before: example.before,
+                        after: example.after
+                      }
+                    }
                   },
                   location: {
                     start: [pair.node.loc.first_line, pair.node.loc.column],

data/lib/querly/cli/test.rb

@@ -9,6 +9,15 @@ module Querly
         @config_path = config_path
         @stdout = stdout
         @stderr = stderr
+        @success = true
+      end
+
+      def fail!
+        @success = false
+      end
+
+      def failed?
+        !@success
       end
 
       def run
@@ -17,15 +26,19 @@ module Querly
         unless config
           stdout.puts "There is nothing to test at #{config_path} ..."
           stdout.puts "Make a configuration and run test again!"
-          return
+          return 1
         end
 
         validate_rule_uniqueness(config.rules)
         validate_rule_patterns(config.rules)
+
+        failed? ? 1 : 0
       rescue => exn
         stderr.puts Rainbow("Fatal error:").red
         stderr.puts exn.inspect
         stderr.puts exn.backtrace.map {|x| "  " + x }.join("\n")
+
+        1
       end
 
       def validate_rule_uniqueness(rules)
@@ -41,6 +54,8 @@ module Querly
             duplications += 1
           end
         end
+
+        fail! unless duplications == 0
       end
 
       def validate_rule_patterns(rules)
@@ -52,31 +67,59 @@ module Querly
         errors = 0
 
         rules.each do |rule|
-          rule.before_examples.each.with_index do |example, example_index|
+          rule.before_examples.each.with_index(1) do |example, example_index|
             tests += 1
 
             begin
               unless rule.patterns.any? {|pat| test_pattern(pat, example, expected: true) }
-                stdout.puts(Rainbow("  #{rule.id}").red + ":\t#{example_index}th *before* example didn't match with any pattern")
+                stdout.puts(Rainbow("  #{rule.id}").red + ":\t#{ordinalize example_index} *before* example didn't match with any pattern")
                 false_negatives += 1
               end
             rescue Parser::SyntaxError
               errors += 1
-              stdout.puts(Rainbow("  #{rule.id}").red + ":\tParsing failed for #{example_index}th *before* example")
+              stdout.puts(Rainbow("  #{rule.id}").red + ":\tParsing failed for #{ordinalize example_index} *before* example")
             end
           end
 
-          rule.after_examples.each.with_index do |example, example_index|
+          rule.after_examples.each.with_index(1) do |example, example_index|
             tests += 1
 
             begin
               unless rule.patterns.all? {|pat| test_pattern(pat, example, expected: false) }
-                stdout.puts(Rainbow("  #{rule.id}").red + ":\t#{example_index}th *after* example matched with some of patterns")
+                stdout.puts(Rainbow("  #{rule.id}").red + ":\t#{ordinalize example_index} *after* example matched with some of patterns")
                 false_positives += 1
               end
             rescue Parser::SyntaxError
               errors += 1
-              stdout.puts(Rainbow("  #{rule.id}") + ":\tParsing failed for #{example_index}th *after* example")
+              stdout.puts(Rainbow("  #{rule.id}") + ":\tParsing failed for #{ordinalize example_index} *after* example")
+            end
+          end
+
+          rule.examples.each.with_index(1) do |example, index|
+            if example.before
+              tests += 1
+              begin
+                unless rule.patterns.any? {|pat| test_pattern(pat, example.before, expected: true) }
+                  stdout.puts(Rainbow("  #{rule.id}").red + ":\tbefore of #{ordinalize index} example didn't match with any pattern")
+                  false_negatives += 1
+                end
+              rescue Parser::SyntaxError
+                errors += 1
+                stdout.puts(Rainbow("  #{rule.id}").red + ":\tParsing failed on before of #{ordinalize index} example")
+              end
+            end
+
+            if example.after
+              tests += 1
+              begin
+                unless rule.patterns.all? {|pat| test_pattern(pat, example.after, expected: false) }
+                  stdout.puts(Rainbow("  #{rule.id}").red + ":\tafter of #{ordinalize index} example matched with some of patterns")
+                  false_positives += 1
+                end
+              rescue Parser::SyntaxError
+                errors += 1
+                stdout.puts(Rainbow("  #{rule.id}") + ":\tParsing failed on after of #{ordinalize index} example")
+              end
             end
           end
         end
@@ -86,6 +129,7 @@ module Querly
           stdout.puts "  #{false_positives} examples found which should not match, but matched"
           stdout.puts "  #{false_negatives} examples found which should match, but didn't"
           stdout.puts "  #{errors} examples raised error"
+          fail!
         else
           stdout.puts Rainbow("  All tests green!").green
         end
@@ -112,6 +156,10 @@ module Querly
           Config.load(yaml, config_path: config_path, root_dir: config_path.parent.realpath, stderr: STDERR)
         end
       end
+
+      def ordinalize(number)
+        ActiveSupport::Inflector.ordinalize(number)
+      end
     end
   end
 end

data/lib/querly/pattern/expr.rb

@@ -142,7 +142,7 @@ module Querly
         attr_reader :block
 
         def initialize(receiver:, name:, block:, args: Argument::AnySeq.new)
-          @name = name
+          @name = Array(name)
           @receiver = receiver
           @args = args
           @block = block
@@ -161,6 +161,10 @@ module Querly
           test_node pair.node
         end
 
+        def test_name(node)
+          name.any? {|n| n === node.children[1] }
+        end
+
         def test_node(node)
           return false if block == true && node.type != :block
           return false if block == false && node.type == :block
@@ -169,7 +173,7 @@ module Querly
 
           case node&.type
           when :send
-            return false unless name == node.children[1]
+            return false unless test_name(node)
             return false unless test_receiver(node.children[0])
             return false unless test_args(node.children.drop(2), args)
             true

data/lib/querly/pattern/parser.y

@@ -55,6 +55,7 @@ key_value: keyword COLON expr { result = { key: val[0], value: val[2], negated:
 
 method_name: METHOD
   | EXCLAMATION
+  | META { result = resolve_meta(val[0]) }
 
 method_name_or_ident: method_name
   | LIDENT
@@ -103,14 +104,16 @@ end
 require "strscan"
 
 attr_reader :input
+attr_reader :where
 
-def initialize(input)
+def initialize(input, where:)
   super()
   @input = StringScanner.new(input)
+  @where = where
 end
 
-def self.parse(str)
-  self.new(str).do_parse
+def self.parse(str, where:)
+  self.new(str, where: where).do_parse
 end
 
 def next_token
@@ -158,6 +161,9 @@ def next_token
     [:UIDENT, input.matched.to_sym]
   when input.scan(/self/)
     [:SELF, nil]
+  when input.scan(/'[a-z]\w*/)
+    s = input.matched
+    [:META, s[1, s.size - 1].to_sym]
   when input.scan(/[a-z_](\w)*(\?|\!|=)?/)
     [:LIDENT, input.matched.to_sym]
   when input.scan(/\(/)
@@ -198,3 +204,7 @@ def next_token
     [:AMP, nil]
   end
 end
+
+def resolve_meta(name)
+  where[name] or raise Racc::ParseError, "Undefined meta variable: '#{name}"
+end

data/lib/querly/rule.rb

@@ -1,5 +1,19 @@
 module Querly
   class Rule
+    class Example
+      attr_reader :before
+      attr_reader :after
+
+      def initialize(before:, after:)
+        @before = before
+        @after = after
+      end
+
+      def ==(other)
+        other.is_a?(Example) && other.before == before && other.after == after
+      end
+    end
+
     attr_reader :id
     attr_reader :patterns
     attr_reader :messages
@@ -8,9 +22,10 @@ module Querly
     attr_reader :justifications
     attr_reader :before_examples
     attr_reader :after_examples
+    attr_reader :examples
     attr_reader :tags
 
-    def initialize(id:, messages:, patterns:, sources:, tags:, before_examples:, after_examples:, justifications:)
+    def initialize(id:, messages:, patterns:, sources:, tags:, before_examples:, after_examples:, justifications:, examples:)
       @id = id
       @patterns = patterns
       @sources = sources
@@ -19,6 +34,7 @@ module Querly
       @before_examples = before_examples
       @after_examples = after_examples
       @tags = tags
+      @examples = examples
     end
 
     def match?(identifier: nil, tags: nil)
@@ -44,13 +60,30 @@ module Querly
       id = hash["id"]
       raise InvalidRuleHashError, "id is missing" unless id
 
-      srcs = Array(hash["pattern"])
+      srcs = case hash["pattern"]
+             when Array
+               hash["pattern"]
+             when nil
+               []
+             else
+               [hash["pattern"]]
+             end
+
       raise InvalidRuleHashError, "pattern is missing" if srcs.empty?
       patterns = srcs.map.with_index do |src, index|
+        case src
+        when String
+          subject = src
+          where = {}
+        when Hash
+          subject = src['subject']
+          where = Hash[src['where'].map {|k,v| [k.to_sym, translate_where(v)] }]
+        end
+
         begin
-          Pattern::Parser.parse(src)
+          Pattern::Parser.parse(subject, where: where)
         rescue Racc::ParseError => exn
-          raise PatternSyntaxError, "Pattern syntax error: rule=#{hash["id"]}, index=#{index}, pattern=#{Rainbow(src.split("\n").first).blue}: #{exn}"
+          raise PatternSyntaxError, "Pattern syntax error: rule=#{hash["id"]}, index=#{index}, pattern=#{Rainbow(subject.split("\n").first).blue}, where=#{where.inspect}: #{exn}"
         end
       end
 
@@ -58,6 +91,10 @@ module Querly
       raise InvalidRuleHashError, "message is missing" if messages.empty?
 
       tags = Set.new(Array(hash["tags"]))
+      examples = [hash["examples"]].compact.flatten.map do |example|
+        raise(InvalidRuleHashError, "Example should have at least before or after, #{example.inspect}") unless example.key?("before") || example.key?("after")
+        Example.new(before: example["before"], after: example["after"])
+      end
       before_examples = Array(hash["before"])
       after_examples = Array(hash["after"])
       justifications = Array(hash["justification"])
@@ -69,7 +106,19 @@ module Querly
                tags: tags,
                before_examples: before_examples,
                after_examples: after_examples,
-               justifications: justifications)
+               justifications: justifications,
+               examples: examples)
+    end
+
+    def self.translate_where(value)
+      Array(value).map do |v|
+        case v
+        when /\A\/(.*)\/\Z/
+          Regexp.new($1)
+        else
+          v.to_sym
+        end
+      end
     end
   end
 end

data/lib/querly/script_enumerator.rb

@@ -46,7 +46,9 @@ module Querly
                    path.read
                  end
 
-        script = Script.new(path: path, node: Parser::CurrentRuby.parse(source, path.to_s))
+        buffer = Parser::Source::Buffer.new(path.to_s, 1)
+        buffer.source = source
+        script = Script.new(path: path, node: parser.parse(buffer))
       rescue StandardError, LoadError, Preprocessor::Error => exn
         script = exn
       end
@@ -54,6 +56,13 @@ module Querly
       yield(path, script)
     end
 
+    def parser
+      Parser::CurrentRuby.new(Builder.new).tap do |parser|
+        parser.diagnostics.all_errors_are_fatal = true
+        parser.diagnostics.ignore_warnings = true
+      end
+    end
+
     def preprocessors
       config&.preprocessors || {}
     end
@@ -93,5 +102,15 @@ module Querly
         load_script_from_path(path, &block) if should_load_file
       end
     end
+
+    class Builder < Parser::Builders::Default
+      def string_value(token)
+        value(token)
+      end
+
+      def emit_lambda
+        true
+      end
+    end
   end
 end

data/lib/querly/version.rb

@@ -1,3 +1,3 @@
 module Querly
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/querly.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor', "~> 0.19"
   spec.add_dependency "parser", "~> 2.4.0"
   spec.add_dependency "rainbow", "~> 2.1"
+  spec.add_dependency "activesupport", "~> 5.1.1"
 end

data/sample.yaml

@@ -125,6 +125,26 @@ rules:
       - records.order.where.group
     message: |
       Using both group and order may generate broken SQL
+  - id: sample.pp_meta
+    message: |
+      Method names can be a meta variable reference
+
+      Meta variable starts with single quote ', and followed with lower letter.
+    pattern:
+      - subject: "'p(...)"
+        where:
+          p: /p+/
+  - id: sample.count
+    pattern: count() !{}
+    message: |
+      Use size or length for count, if receiver is an array
+    examples:
+      - before: "[].count"
+        after: "[].size"
+      - after: "[].count(:x)"
+      - after: "[].count {|x| x > 3 }"
+      - before: "[].count(x)"
+        after: "[].count"
 
 preprocessor:
   .slim: slimrb --compile

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: querly
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-25 00:00:00.000000000 Z
+date: 2017-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.1
 description: 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.
   Querly finds out matching pieces from your program.