querly 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b38a9eb384827611a39b2d1bef7e1b8cb574f2c8
-  data.tar.gz: c02c0c2ebb9844465855e2691e02715b5c73b359
+  metadata.gz: 23d5bf2430a932df4208453cc4847d06915a5140
+  data.tar.gz: 6be0f56ed32a3bded3ef3b9241633faedfc83c3a
 SHA512:
-  metadata.gz: e9a5550cec1e87aad9dcfd0372af5a65ec82b46f685c8960c89b7a34316e64ffc2172136a4a238dfa3803349796df235d960ca4ca24df503f8895c4776a9631f
-  data.tar.gz: fa20ac97b8485b262e625e20a945719c254a7a13f4006e0e8513156567324e3b932c6d75e623b16062085026eb9ad8e4ad902adb169f786026588ebd64cfc729
+  metadata.gz: 68bfb69f1c7628a24f2738bf5be828ce7b31d181a82f550ad1ed54b451d7612fa2ff7f4e6a6b6bf229dbfe147c13ff2a0656436c6b2680cfc800bd70106a34c3
+  data.tar.gz: 9794d372352bd5cff6704b93604ea6b94942a6e4eaf882602788b0660c579e80bfae6369843b5eb75cb55ae3d97848123e52517b4acbb825d1f961e731acacc0

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Change Log
+
+## 0.2.0 (2016-11-24)
+
+* Remove `tagging` section from config
+* Add `check` section to select rules to check
+* Add `import` section to load rules from other file
+* Add `querly rules` sub command to print loaded rules
+* Add *with block* and *without block* pattern (`foo {}` / `foo !{}`)
+* Add *some of receiver chain* pattern (`...`)
+* Fix keyword args pattern matching bug
+
+## 0.1.0
+
+* First release.

data/README.md

@@ -1,22 +1,23 @@
-# Querly - Query Method Calls from Ruby Programs
+# Querly - Pattern Based Checking Tool for Ruby
 
 [![Build Status](https://travis-ci.org/soutaro/querly.svg?branch=master)](https://travis-ci.org/soutaro/querly)
 
 Querly is a query language and tool to find out method calls from Ruby programs.
-You write simple query for method calls, and Querly finds out *wrong* pieces from your program.
+Define rules to check your program with patterns to find out *bad* pieces.
+Querly finds out matching pieces from your program.
 
 ## Overview
 
-Your project should have many local rules:
+Your project may have many local rules:
 
-* Should not use `Customer#update_mail` but 30x faster `Customer.update_all_email` (Slower `#update_mail` is left just for existing code, but new code should not use it)
+* Should not use `Customer#update_mail` and use 30x faster `Customer.update_all_email` instead (Slower `#update_mail` is left just for existing code, but new code should not use it)
 * Should not use `root_url` without `locale:` parameter
 * Should not use `Net::HTTP` for Web API calls, but use `HTTPClient`
 
 These local rule violations will be found during code review.
-Reviewers will ask commiter to revise, commiter will fix, fine.
+Reviewers will ask commiter to revise; commiter will fix; fine.
 Really?
-It is boring and time consuming.
+It is boring and time-consuming.
 We need some automation!
 
 However, that rules cannot be the standard.
@@ -43,7 +44,7 @@ rules:
     message: Use HTTPClient to make HTTP request
 ```
 
-Write down your local rules, and let Querly do boring checks.
+Write down your local rules, and let Querly check conformance with them.
 Focus on spec, design, UX, and other important things during code review!
 
 ## Installation
@@ -66,8 +67,8 @@ Copy the following YAML and paste as `querly.yml` in your project's repo.
 rules:
   - id: sample.debug_print
     pattern:
-      - p
-      - pp
+      - self.p
+      - self.pp
     message: Delete debug print
 ```
 
@@ -120,7 +121,7 @@ There will be many false positives, and *querly warning free code* does not make
 
 * TODO: support to ignore warnings through magic comments in code
 
-This is not to ensure *there is nothing wrong in the code*, but just tells you *code fragments you should review with special care*.
+Querly is not to ensure *there is nothing wrong in the code*, but just tells you *code fragments you should review with special care*.
 I believe it still improves your software development productivity.
 
 ### Incoming updates?

data/exe/querly-pp

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(__dir__, "../lib")
+
+require "querly/pp/cli"
+
+Querly::PP::CLI.new(ARGV).run

data/lib/querly.rb

@@ -18,8 +18,8 @@ require 'querly/node_pair'
 require "querly/pattern/parser"
 require 'querly/pattern/kind'
 require "querly/config"
-require "querly/tagging"
 require "querly/preprocessor"
+require "querly/check"
 
 module Querly
   # Your code goes here...

data/lib/querly/analyzer.rb

@@ -1,13 +1,11 @@
 module Querly
   class Analyzer
-    attr_reader :rules
+    attr_reader :config
     attr_reader :scripts
-    attr_reader :taggings
 
-    def initialize(taggings:)
-      @rules = []
+    def initialize(config:)
+      @config = config
       @scripts = []
-      @taggings = taggings
     end
 
     #
@@ -15,14 +13,11 @@ module Querly
     #
     def run
       scripts.each do |script|
-        tagging = taggings.find {|tagging| tagging.applicable?(script) }
-
-        each_subnode script.root_pair do |node_pair|
+        rules = config.rules_for_path(script.path)
+        script.root_pair.each_subpair do |node_pair|
           rules.each do |rule|
-            if applicable_rule?(tagging, rule)
-              if rule.patterns.any? {|pattern| test_pair(node_pair, pattern) }
-                yield script, rule, node_pair
-              end
+            if rule.patterns.any? {|pattern| test_pair(node_pair, pattern) }
+              yield script, rule, node_pair
             end
           end
         end
@@ -31,7 +26,7 @@ module Querly
 
     def find(pattern)
       scripts.each do |script|
-        each_subnode script.root_pair do |node_pair|
+        script.root_pair.each_subpair do |node_pair|
           if test_pair(node_pair, pattern)
             yield script, node_pair
           end
@@ -42,23 +37,5 @@ module Querly
     def test_pair(node_pair, pattern)
       pattern.expr =~ node_pair && pattern.test_kind(node_pair)
     end
-
-    def applicable_rule?(tagging, rule)
-      if tagging && !rule.tags.empty?
-        tagging.tags_set.any? {|set| set.subset?(rule.tags) }
-      else
-        true
-      end
-    end
-
-    def each_subnode(node_pair, &block)
-      return unless node_pair.node
-
-      yield node_pair
-
-      node_pair.children.each do |child|
-        each_subnode child, &block
-      end
-    end
   end
 end

data/lib/querly/check.rb

@@ -0,0 +1,104 @@
+module Querly
+  class Check
+    Query = Struct.new(:opr, :tags, :identifier) do
+      def apply(current:, all:)
+        case opr
+        when :append
+          current.union(all.select {|rule| match?(rule) })
+        when :except
+          current.reject {|rule| match?(rule) }.to_set
+        when :only
+          all.select {|rule| match?(rule) }.to_set
+        end
+      end
+
+      def match?(rule)
+        rule.match?(identifier: identifier, tags: tags)
+      end
+    end
+
+    attr_reader :patterns
+    attr_reader :rules
+
+    def initialize(pattern:, rules:)
+      @rules = rules
+
+      @has_trailing_slash = pattern.end_with?("/")
+      @has_middle_slash = /\/./ =~ pattern
+
+      @patterns = []
+
+      pattern.sub!(/\A\//, '')
+
+      case
+      when has_trailing_slash? && has_middle_slash?
+        patterns << File.join(pattern, "**")
+      when has_trailing_slash?
+        patterns << File.join(pattern, "**")
+        patterns << File.join("**", pattern, "**")
+      when has_middle_slash?
+        patterns << pattern
+        patterns << File.join(pattern, "**")
+      else
+        patterns << pattern
+        patterns << File.join("**", pattern)
+        patterns << File.join(pattern, "**")
+        patterns << File.join("**", pattern, "**")
+      end
+    end
+
+    def has_trailing_slash?
+      @has_trailing_slash
+    end
+
+    def has_middle_slash?
+      @has_middle_slash
+    end
+
+    def self.load(hash)
+      pattern = hash["path"]
+
+      rules = Array(hash["rules"]).map do |rule|
+        case rule
+        when String
+          parse_rule_query(:append, rule)
+        when Hash
+          case
+          when rule["append"]
+            parse_rule_query(:append, rule["append"])
+          when rule["except"]
+            parse_rule_query(:except, rule["except"])
+          when rule["only"]
+            parse_rule_query(:only, rule["only"])
+          else
+            parse_rule_query(:append, rule)
+          end
+        end
+      end
+
+      self.new(pattern: pattern, rules: rules)
+    end
+
+    def self.parse_rule_query(opr, query)
+      case query
+      when String
+        Query.new(opr, nil, query)
+      when Hash
+        if query['tags']
+          ts = query['tags']
+          if ts.is_a?(String)
+            ts = ts.split
+          end
+          tags = Set.new(ts)
+        end
+        identifier = query['id']
+
+        Query.new(opr, tags, identifier)
+      end
+    end
+
+    def match?(path:)
+      patterns.any? {|pat| File.fnmatch?(pat, path.to_s) }
+    end
+  end
+end

data/lib/querly/cli.rb

@@ -5,6 +5,7 @@ module Querly
   class CLI < Thor
     desc "check [paths]", "Check paths based on configuration"
     option :config, default: "querly.yml"
+    option :root
     option :format, default: "text", type: :string, enum: %w(text json)
     def check(*paths)
       require 'querly/cli/formatter'
@@ -26,18 +27,20 @@ Specify configuration file by --config option.
           exit 1
         end
 
-        config = Config.new
-        begin
-          config.add_file config_path
+        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)
         rescue => exn
           formatter.config_error config_path, exn
           exit
         end
 
-        analyzer = Analyzer.new(taggings: config.taggings)
-        analyzer.rules.concat config.rules
+        analyzer = Analyzer.new(config: config)
 
-        ScriptEnumerator.new(paths: paths.map {|path| Pathname(path) }, preprocessors: config.preprocessors).each do |path, script|
+        ScriptEnumerator.new(paths: paths.map {|path| Pathname(path) }, config: config).each do |path, script|
           case script
           when Script
             analyzer.scripts << script
@@ -71,6 +74,13 @@ Specify configuration file by --config option.
       Test.new(config_path: config_path).run
     end
 
+    desc "rules", "Print loaded rules"
+    option :config, default: "querly.yml"
+    def rules(*ids)
+      require "querly/cli/rules"
+      Rules.new(config_path: config_path, ids: ids).run
+    end
+
     private
 
     def config_path

data/lib/querly/cli/console.rb

@@ -33,9 +33,9 @@ Querly #{VERSION}, interactive console
       def analyzer
         return @analyzer if @analyzer
 
-        @analyzer = Analyzer.new(taggings: [])
+        @analyzer = Analyzer.new(config: nil)
 
-        ScriptEnumerator.new(paths: paths).each do |path, script|
+        ScriptEnumerator.new(paths: paths, config: nil).each do |path, script|
           case script
           when Script
             @analyzer.scripts << script

data/lib/querly/cli/rules.rb

@@ -0,0 +1,77 @@
+module Querly
+  class CLI
+    class Rules
+      attr_reader :config_path
+      attr_reader :stdout
+      attr_reader :ids
+
+      def initialize(config_path:, ids:, stdout: STDOUT)
+        @config_path = config_path
+        @stdout = stdout
+        @ids = ids
+      end
+
+      def config
+        yaml = YAML.load(config_path.read)
+        @config ||= Config.load(yaml, config_path: config_path, root_dir: config_path.parent.realpath)
+      end
+
+      def run
+        rules = config.rules.select {|rule| test_rule(rule) }
+        stdout.puts YAML.dump(rules.map {|rule| rule_to_yaml(rule) })
+      end
+
+      def test_rule(rule)
+        if ids.empty?
+          true
+        else
+          ids.any? {|id| rule.match?(identifier: id) }
+        end
+      end
+
+      def rule_to_yaml(rule)
+        { "id" => rule.id }.tap do |hash|
+          singleton rule.sources do |a|
+            hash["pattern"] = a
+          end
+
+          singleton rule.messages do |a|
+            hash["message"] = a
+          end
+
+          empty rule.tags do |a|
+            hash["tags"] = a
+          end
+
+          singleton rule.justifications do |a|
+            hash["justification"] = a
+          end
+
+          singleton rule.before_examples do |a|
+            hash["before"] = a
+          end
+
+          singleton rule.after_examples do |a|
+            hash["after"] = a
+          end
+        end
+      end
+
+      def empty(array)
+        unless array.empty?
+          yield array.to_a
+        end
+      end
+
+      def singleton(array)
+        empty(array) do
+          if array.length == 1
+            yield array.first
+          else
+            yield array.to_a
+          end
+        end
+      end
+    end
+  end
+end

data/lib/querly/cli/test.rb

@@ -92,12 +92,12 @@ module Querly
       end
 
       def test_pattern(pattern, example, expected:)
-        analyzer = Analyzer.new(taggings: [])
+        analyzer = Analyzer.new(config: nil)
 
         found = false
 
         node = Parser::CurrentRuby.parse(example)
-        analyzer.each_subnode NodePair.new(node: node) do |pair|
+        NodePair.new(node: node).each_subpair do |pair|
           if analyzer.test_pair(pair, pattern)
             found = true
           end
@@ -108,9 +108,8 @@ module Querly
 
       def load_config
         if config_path.file?
-          config = Config.new
-          config.add_file config_path
-          config
+          yaml = YAML.load(config_path.read)
+          Config.load(yaml, config_path: config_path, root_dir: config_path.parent.realpath, stderr: STDERR)
         end
       end
     end

data/lib/querly/config.rb

@@ -1,55 +1,87 @@
 module Querly
   class Config
     attr_reader :rules
-    attr_reader :paths
-    attr_reader :taggings
     attr_reader :preprocessors
+    attr_reader :root_dir
+    attr_reader :checks
+    attr_reader :rules_cache
 
-    def initialize()
-      @rules = []
-      @paths = []
-      @taggings = []
-      @preprocessors = {}
+    def initialize(rules:, preprocessors:, root_dir:, checks:)
+      @rules = rules
+      @root_dir = root_dir
+      @preprocessors = preprocessors
+      @checks = checks
+      @rules_cache = {}
     end
 
-    def add_file(path)
-      paths << path
+    def self.load(hash, config_path:, root_dir:, stderr: STDERR)
+      Factory.new(hash, config_path: config_path, root_dir: root_dir, stderr: stderr).config
+    end
 
-      content = YAML.load(path.read)
-      load_rules(content)
-      load_taggings(content)
-      load_preprocessors(content["preprocessor"] || {})
+    def all_rules
+      @all_rules ||= Set.new(rules)
     end
 
-    def load_rules(yaml)
-      yaml["rules"].each do |hash|
-        id = hash["id"]
-        patterns = Array(hash["pattern"]).map {|src| Pattern::Parser.parse(src) }
-        messages = Array(hash["message"])
-        justifications = Array(hash["justification"])
-
-        rule = Rule.new(id: id)
-        rule.patterns.concat patterns
-        rule.messages.concat messages
-        rule.justifications.concat justifications
-        Array(hash["tags"]).each {|tag| rule.tags << tag }
-        rule.before_examples.concat Array(hash["before"])
-        rule.after_examples.concat Array(hash["after"])
-
-        rules << rule
-      end
+    def relative_path_from_root(path)
+      path.absolute? ? path.relative_path_from(root_dir) : path.cleanpath
     end
 
-    def load_taggings(yaml)
-      @taggings = Array(yaml["tagging"]).map {|hash|
-        Tagging.new(path_pattern: hash["path"],
-                    tags_set: Array(hash["tags"]).map {|string| Set.new(string.split) })
-      }.sort_by {|tagging| -tagging.path_pattern.size }
+    def rules_for_path(path)
+      relative_path = relative_path_from_root(path)
+      matching_checks = checks.select {|check| check.match?(path: relative_path) }
+
+      if rules_cache.key?(matching_checks)
+        rules_cache[matching_checks]
+      else
+        matching_checks.flat_map(&:rules).inject(all_rules) do |rules, query|
+          query.apply(current: rules, all: all_rules)
+        end.tap do |rules|
+          rules_cache[matching_checks] = rules
+        end
+      end
     end
 
-    def load_preprocessors(preprocessors)
-      @preprocessors = preprocessors.each.with_object({}) do |(key, value), hash|
-        hash[key] = Preprocessor.new(ext: key, command: value)
+    class Factory
+      attr_reader :yaml
+      attr_reader :root_dir
+      attr_reader :stderr
+      attr_reader :config_path
+
+      def initialize(yaml, config_path:, root_dir:, stderr: STDERR)
+        @yaml = yaml
+        @config_path = config_path
+        @root_dir = root_dir
+        @stderr = stderr
+      end
+
+      def config
+        if yaml["tagging"]
+          stderr.puts "tagging is deprecated and ignored"
+        end
+
+        rules = Array(yaml["rules"]).map {|hash| Rule.load(hash) }
+        preprocessors = (yaml["preprocessor"] || {}).each.with_object({}) do |(key, value), hash|
+          hash[key] = Preprocessor.new(ext: key, command: value)
+        end
+
+        imports = Array(yaml["import"])
+        imports.each do |import|
+          if import["load"]
+            load_pattern = Pathname(import["load"])
+            load_pattern = config_path.parent + load_pattern if load_pattern.relative?
+
+            Pathname.glob(load_pattern.to_s) do |path|
+              stderr.puts "Loading rules from #{path}..."
+              YAML.load(path.read).each do |hash|
+                rules << Rule.load(hash)
+              end
+            end
+          end
+        end
+
+        checks = Array(yaml["check"]).map {|hash| Check.load(hash) }
+
+        Config.new(rules: rules, preprocessors: preprocessors, checks: checks, root_dir: root_dir)
       end
     end
   end

data/lib/querly/node_pair.rb

@@ -17,5 +17,19 @@ module Querly
         end
       end
     end
+
+    def each_subpair(&block)
+      if block_given?
+        return unless node
+
+        yield self
+
+        children.each do |child|
+          child.each_subpair &block
+        end
+      else
+        enum_for :each_subpair
+      end
+    end
   end
 end

data/lib/querly/pattern/expr.rb

@@ -128,6 +128,9 @@ module Querly
               true
             end
 
+          when :regexp
+            type == :regexp
+            
           end
         end
       end
@@ -136,18 +139,20 @@ module Querly
         attr_reader :name
         attr_reader :receiver
         attr_reader :args
+        attr_reader :block
 
-        def initialize(receiver:, name:, args: Argument::AnySeq.new)
+        def initialize(receiver:, name:, block:, args: Argument::AnySeq.new)
           @name = name
           @receiver = receiver
           @args = args
+          @block = block
         end
 
         def =~(pair)
           # Skip send node with block
           if pair.node.type == :send && pair.parent
             if pair.parent.node.type == :block
-              if pair.parent.node.children.first == pair.node
+              if pair.parent.node.children.first.equal? pair.node
                 return false
               end
             end
@@ -157,6 +162,9 @@ module Querly
         end
 
         def test_node(node)
+          return false if block == true && node.type != :block
+          return false if block == false && node.type == :block
+
           node = node.children.first if node&.type == :block
 
           case node&.type
@@ -173,15 +181,19 @@ module Querly
 
           case args
           when Argument::AnySeq
-            if args.tail && first_node
-              case
-              when nodes.last.type == :kwsplat
-                true
-              when nodes.last.type == :hash && args.tail.is_a?(Argument::KeyValue)
-                hash = hash_node_to_hash(nodes.last)
-                test_hash_args(hash, args.tail)
+            if args.tail
+              if first_node
+                case
+                when nodes.last.type == :kwsplat
+                  true
+                when nodes.last.type == :hash && args.tail.is_a?(Argument::KeyValue)
+                  hash = hash_node_to_hash(nodes.last)
+                  test_hash_args(hash, args.tail)
+                else
+                  test_hash_args({}, args.tail)
+                end
               else
-                true
+                test_hash_args({}, args.tail)
               end
             else
               true
@@ -243,6 +255,22 @@ module Querly
         end
       end
 
+      class ReceiverContext < Base
+        attr_reader :receiver
+
+        def initialize(receiver:)
+          @receiver = receiver
+        end
+
+        def test_node(node)
+          if receiver.test_node(node)
+            true
+          else
+            node&.type == :send && test_node(node.children[0])
+          end
+        end
+      end
+
       class Vcall < Base
         attr_reader :name
 

data/lib/querly/pattern/parser.y

@@ -22,6 +22,7 @@ expr: constant { result = Expr::Constant.new(path: val[0]) }
   | FLOAT { result = Expr::Literal.new(type: :float, value: val[0]) }
   | SYMBOL { result = Expr::Literal.new(type: :symbol, value: val[0]) }
   | NUMBER { result = Expr::Literal.new(type: :number, value: val[0]) }
+  | REGEXP { result = Expr::Literal.new(type: :regexp, value: nil) }
   | DSTR { result = Expr::Dstr.new() }
   | UNDERBAR { result = Expr::Any.new }
   | NIL { result = Expr::Nil.new }
@@ -64,14 +65,34 @@ constant: UIDENT { result = [val[0]] }
   | UIDENT COLONCOLON constant { result = [val[0]] + val[2] }
 
 send: LIDENT { result = Expr::Vcall.new(name: val[0]) }
-  | method_name { result = Expr::Send.new(receiver: Expr::Any.new, name: val[0]) }
-  | method_name_or_ident LPAREN args RPAREN { result = Expr::Send.new(receiver: Expr::Any.new,
-                                                             name: val[0],
-                                                             args: val[2]) }
-  | expr DOT method_name_or_ident { result = Expr::Send.new(receiver: val[0], name: val[2], args: Argument::AnySeq.new) }
-  | expr DOT method_name_or_ident LPAREN args RPAREN { result = Expr::Send.new(receiver: val[0],
-                                                                      name: val[2],
-                                                                      args: val[4]) }
+  | method_name { result = Expr::Send.new(receiver: Expr::Any.new, name: val[0], block: nil) }
+  | method_name_or_ident LPAREN args RPAREN block { result = Expr::Send.new(receiver: Expr::Any.new,
+                                                                            name: val[0],
+                                                                            args: val[2],
+                                                                            block: val[4]) }
+  | 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 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: expr DOT { result = val[0] }
+  | expr DOTDOTDOT { result = Expr::ReceiverContext.new(receiver: val[0]) }
+
+block: { result = nil }
+  | WITH_BLOCK { result = true }
+  | WITHOUT_BLOCK { result = false }
 
 end
 
@@ -116,9 +137,15 @@ def next_token
     [:SYMBOL, nil]
   when input.scan(/:number:/)
     [:NUMBER, nil]
+  when input.scan(/:regexp:/)
+    [:REGEXP, nil]
   when input.scan(/:\w+/)
     s = input.matched
     [:SYMBOL, s[1, s.size - 1].to_sym]
+  when input.scan(/{}/)
+    [:WITH_BLOCK, nil]
+  when input.scan(/!{}/)
+    [:WITHOUT_BLOCK, nil]
   when input.scan(/[+-]?[0-9]+\.[0-9]/)
     [:FLOAT, input.matched.to_f]
   when input.scan(/[+-]?[0-9]+/)

data/lib/querly/pp/cli.rb

@@ -0,0 +1,74 @@
+require "optparse"
+
+module Querly
+  module PP
+    class CLI
+      attr_reader :argv
+      attr_reader :command
+      attr_reader :load_paths
+      attr_reader :requires
+
+      attr_reader :stdin
+      attr_reader :stderr
+      attr_reader :stdout
+
+      def initialize(argv, stdin: STDIN, stdout: STDOUT, stderr: STDERR)
+        @argv = argv
+        @stdin = stdin
+        @stdout = stdout
+        @stderr = stderr
+
+        @load_paths = []
+        @requires = []
+
+        OptionParser.new do |opts|
+          opts.banner = "Usage: #{opts.program_name} pp-name [options]"
+          opts.on("-I dir") {|path| load_paths << path }
+          opts.on("-r lib") {|rq| requires << rq }
+        end.permute!(argv)
+
+        @command = argv.shift&.to_sym
+      end
+
+      def load_libs
+        load_paths.each do |path|
+          $LOAD_PATH << path
+        end
+
+        requires.each do |lib|
+          require lib
+        end
+
+      end
+
+      def run
+        available_commands = [:haml]
+
+        if available_commands.include?(command)
+          send :"run_#{command}"
+        else
+          stderr.puts "Unknown command: #{command}"
+          stderr.puts "  available commands: #{available_commands.join(", ")}"
+          exit 1
+        end
+      end
+
+      def run_haml
+        require "haml"
+        load_libs
+
+        source = stdin.read
+
+        options = Haml::Options.new
+
+        parser = Haml::Parser.new(source, options)
+        parser.parse
+
+        compiler = Haml::Compiler.new(options)
+        compiler.compile(parser.root)
+
+        stdout.print compiler.precompiled
+      end
+    end
+  end
+end

data/lib/querly/rule.rb

@@ -2,25 +2,67 @@ module Querly
   class Rule
     attr_reader :id
     attr_reader :patterns
-
     attr_reader :messages
+
+    attr_reader :sources
     attr_reader :justifications
     attr_reader :before_examples
     attr_reader :after_examples
     attr_reader :tags
-    attr_reader :scope
 
-    def initialize(id:, scope: :nil)
+    def initialize(id:, messages:, patterns:, sources:, tags:, before_examples:, after_examples:, justifications:)
       @id = id
-      @scope = scope
-
-      @patterns = []
-      @messages = []
-      @justifications = []
-      @before_examples = []
-      @after_examples = []
-      @tags = Set.new
-      @scope = scope
+      @patterns = patterns
+      @sources = sources
+      @messages = messages
+      @justifications = justifications
+      @before_examples = before_examples
+      @after_examples = after_examples
+      @tags = tags
+    end
+
+    def match?(identifier: nil, tags: nil)
+      if identifier
+        unless id == identifier || id.start_with?(identifier + ".")
+          return false
+        end
+      end
+
+      if tags
+        unless tags.subset?(self.tags)
+          return false
+        end
+      end
+
+      true
+    end
+
+    class InvalidRuleHashError < StandardError; end
+
+    def self.load(hash)
+      id = hash["id"]
+      raise InvalidRuleHashError, "id is missing" unless id
+
+      srcs = Array(hash["pattern"])
+      raise InvalidRuleHashError, "pattern is missing" if srcs.empty?
+      patterns = srcs.map {|src| Pattern::Parser.parse(src) }
+
+      messages = Array(hash["message"])
+      raise InvalidRuleHashError, "message is missing" if messages.empty?
+
+      tags = Set.new(Array(hash["tags"]))
+      before_examples = Array(hash["before"])
+      after_examples = Array(hash["after"])
+      justifications = Array(hash["justification"])
+
+      Rule.new(id: id,
+               messages: messages,
+               patterns: patterns,
+               sources: srcs,
+               tags: tags,
+               before_examples: before_examples,
+               after_examples: after_examples,
+               justifications: justifications)
     end
   end
 end

data/lib/querly/script_enumerator.rb

@@ -1,11 +1,11 @@
 module Querly
   class ScriptEnumerator
     attr_reader :paths
-    attr_reader :preprocessors
+    attr_reader :config
 
-    def initialize(paths:, preprocessors: {})
+    def initialize(paths:, config:)
       @paths = paths
-      @preprocessors = preprocessors
+      @config = config
     end
 
     def each(&block)
@@ -54,6 +54,10 @@ module Querly
       yield(path, script)
     end
 
+    def preprocessors
+      config&.preprocessors || {}
+    end
+
     def enumerate_files_in_dir(path, &block)
       if path.basename.to_s =~ /\A\.[^\.]+/
         # skip hidden paths

data/lib/querly/version.rb

@@ -1,3 +1,3 @@
 module Querly
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/querly.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Soutaro Matsumoto"]
   spec.email         = ["matsumoto@soutaro.com"]
 
-  spec.summary       = %q{Query Method Calls from Ruby Programs}
-  spec.description   = %q{Querly is a query language and tool to find out method calls from Ruby programs. You write simple query, and Querly finds out wrong pieces in your program.}
+  spec.summary       = %q{Pattern Based Checking Tool for Ruby}
+  spec.description   = %q{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.}
   spec.homepage      = "https://github.com/soutaro/querly"
 
   spec.files         = `git ls-files -z`
@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "racc", "= 1.4.14"
+  spec.add_development_dependency "unification_assertion", "0.0.1"
 
   spec.add_dependency 'thor', "~> 0.19"
   spec.add_dependency "parser", "~> 2.3.1"

data/sample.yaml

@@ -118,10 +118,34 @@ rules:
     tags:
       - test
       - capybara
+  - id: sample.order-group
+    pattern: order...group
+    before:
+      - records.where.order.group
+      - records.order.where.group
+    message: |
+      Using both group and order may generate broken SQL
+
 preprocessor:
   .slim: slimrb --compile
-tagging:
-  - path: test
-    tags:
-  - path: features/step_definitions
-    tags: test capybara
+
+import:
+  - load: rules/*.yml
+
+check:
+  - path: /
+    rules:
+      - except: minitest
+  - path: /test
+    rules:
+      - minitest
+      - except:
+          tags: capybara minitest
+  - path: /test/integration
+    rules:
+      - append:
+          tags: capybara minitest
+  - path: /features/step_definitions
+    rules:
+      - append:
+          tags: capybara minitest

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: querly
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-10 00:00:00.000000000 Z
+date: 2016-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.4.14
+- !ruby/object:Gem::Dependency
+  name: unification_assertion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -109,27 +123,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.1'
 description: Querly is a query language and tool to find out method calls from Ruby
-  programs. You write simple query, and Querly finds out wrong pieces in your program.
+  programs. Define rules to check your program with patterns to find out *bad* pieces.
+  Querly finds out matching pieces from your program.
 email:
 - matsumoto@soutaro.com
 executables:
 - querly
+- querly-pp
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - exe/querly
+- exe/querly-pp
 - lib/querly.rb
 - lib/querly/analyzer.rb
+- lib/querly/check.rb
 - lib/querly/cli.rb
 - lib/querly/cli/console.rb
 - lib/querly/cli/formatter.rb
+- lib/querly/cli/rules.rb
 - lib/querly/cli/test.rb
 - lib/querly/config.rb
 - lib/querly/node_pair.rb
@@ -138,11 +158,11 @@ files:
 - lib/querly/pattern/kind.rb
 - lib/querly/pattern/parser.rb
 - lib/querly/pattern/parser.y
+- lib/querly/pp/cli.rb
 - lib/querly/preprocessor.rb
 - lib/querly/rule.rb
 - lib/querly/script.rb
 - lib/querly/script_enumerator.rb
-- lib/querly/tagging.rb
 - lib/querly/version.rb
 - querly.gemspec
 - sample.yaml
@@ -168,5 +188,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Query Method Calls from Ruby Programs
+summary: Pattern Based Checking Tool for Ruby
 test_files: []

data/lib/querly/tagging.rb

@@ -1,32 +0,0 @@
-module Querly
-  class Tagging
-    attr_reader :path_pattern
-    attr_reader :tags_set
-
-    def initialize(path_pattern:, tags_set:)
-      @path_pattern = path_pattern
-      @tags_set = tags_set
-    end
-
-    def applicable?(script)
-      return true unless path_pattern
-
-      pattern_components = path_pattern.split('/')
-
-      script_path = if script.path.absolute?
-                      script.path
-                    else
-                      script.path.realpath
-                    end
-      path_components = script_path.to_s.split(File::Separator)
-
-      path_components.each_cons(pattern_components.size) do |slice|
-        if slice == pattern_components
-          return true
-        end
-      end
-
-      false
-    end
-  end
-end