goodcheck 1.7.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d857a24ca9b2ca50fe761dad0fa03fbeab34a7bf2c2d34eb6cdbeb349f31f53f
-  data.tar.gz: d50e1f2b04239b282eaa1a89eb8965f68de2ff681b1ba814d6695f0491cd497f
+  metadata.gz: c1eb6ece8a435ad763555da38a18d8dacc04f382ae683f15fea06c7dbb117c23
+  data.tar.gz: ba146e257cc9dd9d1253af0009b59b75cd9063f40a8617a4454956a2c858c927
 SHA512:
-  metadata.gz: f64e084cb6b268d3d3febf63a37b811830b3ef77318e73e0f049fb4fbae2c8bec97b8e339562042b2e8029f1035bb20a86ba03086366ac8caaa57bc418521061
-  data.tar.gz: 7b8c73bd327db455afd2a61c74f0b4b6589e4c71c4c0205f60a71f3be37666f826832b608f4f0b0016fa6cdd905a62a90ab08814aa490d5e21de44a9543eee00
+  metadata.gz: 8758e7b9ea900a80e044b1cc5cc8eafd00bc7063a2c821683c69bd6052a1d2418a127ad1e3a64863bb63833dda00597165401280d645b9514cd5909243818a1c
+  data.tar.gz: 4c7d2ef14d5c2fff6f49f89f94aa3b4b169625aafa4c5344a7af6ccdf77bc93cf5c79cdc11b0857f1ebc4951b1e8207d3173d67fb39872cd4a849946718ad992

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 2.0.0 (2019-06-06)
+
+* Introduce trigger, a new pattern definition [#53](https://github.com/sider/goodcheck/pull/53)
+
 ## 1.7.1 (2019-05-29)
 
 * Fix test command error handling

data/README.md

@@ -36,6 +36,10 @@ The `init` command generates template of `goodcheck.yml` configuration file for
 Edit the config file to define patterns you want to check.
 Then run `check` command, and it will print matched texts.
 
+### Cheatsheet
+
+You can download a [printable cheatsheet](cheatsheet.pdf) from this repository.
+
 ## `goodcheck.yml`
 
 An example of configuration is like the following:
@@ -73,7 +77,19 @@ The *rule* hash contains the following keys.
 ### *pattern*
 
 A *pattern* can be a *literal pattern*, *regexp pattern*, *token pattern*, or a string.
-When a string is given, it is interpreted as a *literal pattern* with `case_sensitive: true`.
+
+#### String literal
+
+String literal represents a *literal pattern* or *regexp pattern*.
+
+```yaml
+pattern:
+  - This is literal pattern
+  - /This is regexp pattern/
+```
+
+If the string value begins with `/` and ends with `/`, it is a *regexp pattern*.
+You can optionally specify regexp options like `/casefold/i` or `/multiline/m`.
 
 #### *literal pattern*
 
@@ -84,13 +100,11 @@ id: com.sample.GitHub
 pattern:
   literal: Github
   case_sensitive: true
-  glob: []
 message: Write GitHub, not Github
 ```
 
 All regexp meta characters included in the `literal` value will be escaped.
 `case_sensitive` is an optional key and the default is `true`.
-`glob` is an optional key and the default is empty.
 
 #### *regexp pattern*
 
@@ -102,13 +116,12 @@ pattern:
   regexp: \d{4,}
   case_sensitive: false
   multiline: false
-  glob: []
 message: Insert delimiters when writing large numbers
 justification:
   - When you are not writing numbers, including phone numbers, zip code, ...
 ```
 
-It accepts two optional attributes, `case_sensitive`, `multiline`, and `glob`.
+It accepts two optional attributes, `case_sensitive` and `multiline`.
 The default values of `case_sensitive` and `multiline` are `true` and `false` respectively.
 
 The regexp will be passed to `Regexp.compile`.
@@ -123,7 +136,6 @@ id: com.sample.no-blink
 pattern:
   token: "<blink"
   case_sensitive: false
-  glob: []
 message: Stop using <blink> tag
 glob: "**/*.html"
 justification:
@@ -137,10 +149,34 @@ In that case, try using *regexp pattern*.
 The generated regexp of `<blink` is `<\s*blink\b/m`.
 It matches with `<blink />` and `< BLINK>`, but does not match with `https://www.chromium.org/blink`.
 
-It accepts one optional attributes, `case_sensitive` and `glob`.
+It accepts one optional attribute `case_sensitive`.
 The default value of `case_sensitive` is `true`.
 Note that the generated regexp is in multiline mode.
 
+Token pattern can have optional `where` attribute and *variable bindings*.
+
+```yaml
+pattern:
+  - token: bgcolor=${color:string}
+    where:
+      color: true
+```
+
+The variable binding consists of *variable name* and *variable type*, where `color` and `string` in the example above respectively. You have to add a key of the *variable name* in `where` attribute.
+
+We have 8 builtin patterns:
+
+* `string`
+* `int`
+* `float`
+* `number`
+* `url`
+* `email`
+* `word`
+* `identifier`
+
+You can find the exact definitions of the types in the definition of `Goodcheck::Pattern::Token` (`@@TYPES`).
+
 ### *glob*
 
 A *glob* can be a string, or a hash.
@@ -172,7 +208,7 @@ rules:
     glob: "*.txt"
 ```
 
-### A rule without _negated_ pattern
+### A rule with _negated_ pattern
 
 Goodcheck rules are usually to detect _something is included in a file_.
 You can define the _negated_ rules for the opposite, _something is missing in a file_.
@@ -208,6 +244,34 @@ $ goodcheck check
 db/schema.rb:-:# This file is auto-generated from the current state of the database. Instead: Read the operation manual for DB migration: https://example.com/guides/123
 ```
 
+### Triggers
+
+Version 2.0.0 introduces new abstruction to define patterns, trigger.
+You can continue using `pattern`s in `rule`, but using `trigger` allows more flexible pattern definition and more precise testing.
+
+```
+rules:
+  - id: trigger
+    message: Using trigger
+    trigger:
+      - pattern: <blink
+        glob: "**/*.html"
+        fail:
+          - <blink></blink>
+      - not:
+          pattern:
+            token: <meta charset="UTF-8">
+            case_sensitive: false
+        glob: "**/*.html"
+        pass: |
+          <html>
+            <meta charset="utf-8"></meta>
+          </html>
+```
+
+You can continue existing `pattern` definitions, but `goodcheck test` against `pattern`s with `glob` does not work.
+If your `pattern` definition includes `glob`, swithing `trigger` would make sense.
+
 ## Importing rules
 
 `goodcheck.yml` can have optional `import` attribute.

data/goodcheck.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest-reporters", "~> 1.3.6"
 
   spec.add_runtime_dependency "activesupport", ">= 4.0", "< 6.0"
-  spec.add_runtime_dependency "strong_json", "~> 1.0.1"
+  spec.add_runtime_dependency "strong_json", "~> 1.1.0"
   spec.add_runtime_dependency "rainbow", "~> 3.0.0"
   spec.add_runtime_dependency "httpclient", "~> 2.8.3"
 end

data/lib/goodcheck/analyzer.rb

@@ -1,66 +1,93 @@
 module Goodcheck
   class Analyzer
     attr_reader :rule
+    attr_reader :trigger
     attr_reader :buffer
 
-    def initialize(rule:, buffer:)
+    def initialize(rule:, trigger:, buffer:)
       @rule = rule
+      @trigger = trigger
       @buffer = buffer
     end
 
-    def use_all_patterns!
-      @use_all_patterns = true
-    end
+    def scan(&block)
+      if block_given?
+        if trigger.patterns.empty?
+          yield Issue.new(buffer: buffer, range: nil, rule: rule, text: nil)
+        else
+          var_pats, novar_pats = trigger.patterns.partition {|pat|
+            pat.is_a?(Pattern::Token) && !pat.variables.empty?
+          }
 
-    def patterns
-      if @use_all_patterns
-        rule.patterns
+          unless var_pats.empty?
+            var_pats.each do |pat|
+              scan_var pat, &block
+            end
+          end
+
+          unless novar_pats.empty?
+            regexp = Regexp.union(*novar_pats.map(&:regexp))
+            scan_simple regexp, &block
+          end
+        end
       else
-        rule.patterns.select do |pattern|
+        enum_for(:scan)
+      end
+    end
+
+    def scan_simple(regexp, &block)
+      unless trigger.negated?
+        issues = []
+
+        scanner = StringScanner.new(buffer.content)
+
+        while true
           case
-          when pattern.globs.empty? && rule.globs.empty?
-            true
-          when pattern.globs.empty?
-            rule.globs.any? {|glob| glob.test(buffer.path) }
+          when scanner.scan_until(regexp)
+            text = scanner.matched
+            range = (scanner.pos - text.bytesize) .. scanner.pos
+            issues << Issue.new(buffer: buffer, range: range, rule: rule, text: text)
           else
-            pattern.globs.any? {|glob| glob.test(buffer.path) }
+            break
           end
         end
-      end
-    end
 
-    def scan(&block)
-      if block_given?
-        if rule.patterns.empty?
+        issues.each(&block)
+      else
+        unless regexp =~ buffer.content
           yield Issue.new(buffer: buffer, range: nil, rule: rule, text: nil)
-        else
-          regexp = Regexp.union(*patterns.map(&:regexp))
-
-          unless rule.negated?
-            issues = []
+        end
+      end
+    end
 
-            scanner = StringScanner.new(buffer.content)
+    def scan_var(pat)
+      scanner = StringScanner.new(buffer.content)
 
-            while true
-              case
-              when scanner.scan_until(regexp)
-                text = scanner.matched
-                range = (scanner.pos - text.bytesize) .. scanner.pos
-                issues << Issue.new(buffer: buffer, range: range, rule: rule, text: text)
-              else
-                break
-              end
+      unless trigger.negated?
+        while true
+          case
+          when scanner.scan_until(pat.regexp)
+            if pat.test_variables(scanner)
+              text = scanner.matched
+              range = (scanner.pos - text.bytesize) .. scanner.pos
+              yield Issue.new(buffer: buffer, range: range, rule: rule, text: text)
             end
-
-            issues.each(&block)
           else
-            unless regexp =~ buffer.content
-              yield Issue.new(buffer: buffer, range: nil, rule: rule, text: nil)
-            end
+            break
           end
         end
       else
-        enum_for(:scan)
+        while true
+          case
+          when scanner.scan_until(pat.regexp)
+            if pat.test(scanner)
+              break
+            end
+          else
+            yield Issue.new(buffer: buffer, range: nil, rule: rule, text: nil)
+            break
+          end
+        end
       end
     end
   end

data/lib/goodcheck/commands/check.rb

@@ -28,12 +28,16 @@ module Goodcheck
 
           reporter.analysis do
             load_config!(force_download: force_download, cache_path: cache_dir_path)
-            each_check do |buffer, rule|
+            each_check do |buffer, rule, trigger|
+              reported_issues = Set[]
+
               reporter.rule(rule) do
-                analyzer = Analyzer.new(rule: rule, buffer: buffer)
+                analyzer = Analyzer.new(rule: rule, buffer: buffer, trigger: trigger)
                 analyzer.scan do |issue|
-                  issue_reported = true
-                  reporter.issue(issue)
+                  if reported_issues.add?(issue)
+                    issue_reported = true
+                    reporter.issue(issue)
+                  end
                 end
               end
             end
@@ -53,7 +57,7 @@ module Goodcheck
                 reporter.file(path) do
                   buffers = {}
 
-                  config.rules_for_path(path, rules_filter: rules) do |rule, glob|
+                  config.rules_for_path(path, rules_filter: rules) do |rule, glob, trigger|
                     Goodcheck.logger.debug "Checking rule: #{rule.id}"
                     begin
                       encoding = glob&.encoding || Encoding.default_external.name
@@ -66,7 +70,7 @@ module Goodcheck
                         buffers[encoding] = buffer
                       end
 
-                      yield buffer, rule
+                      yield buffer, rule, trigger
                     rescue ArgumentError => exn
                       stderr.puts "#{path}: #{exn.inspect}"
                     end

data/lib/goodcheck/commands/test.rb

@@ -56,34 +56,53 @@ module Goodcheck
         test_pass = true
 
         config.rules.each do |rule|
-          if !rule.passes.empty? || !rule.fails.empty?
+          if rule.triggers.any? {|trigger| !trigger.passes.empty? || !trigger.fails.empty?}
             stdout.puts "Testing rule #{rule.id}..."
 
-            pass_errors = rule.passes.each.with_index.select do |pass, index|
-              rule_matches_example?(rule, pass)
-            end
-
-            fail_errors = rule.fails.each.with_index.reject do |fail, index|
-              rule_matches_example?(rule, fail)
-            end
-
-            unless pass_errors.empty?
-              test_pass = false
-
-              pass_errors.each do |_, index|
-                stdout.puts "  #{(index+1).ordinalize} pass example matched.😱"
+            rule_ok = true
+
+            rule.triggers.each.with_index do |trigger, index|
+              if !trigger.passes.empty? || !trigger.fails.empty?
+                if trigger.by_pattern?
+                  stdout.puts "  Testing pattern..."
+                else
+                  stdout.puts "  Testing #{(index+1).ordinalize} trigger..."
+                end
+
+                pass_errors = trigger.passes.each.with_index.select do |pass, _|
+                  rule_matches_example?(rule, trigger, pass)
+                end
+
+                fail_errors = trigger.fails.each.with_index.reject do |fail, _|
+                  rule_matches_example?(rule, trigger, fail)
+                end
+
+                unless pass_errors.empty?
+                  test_pass = false
+                  rule_ok = false
+
+                  pass_errors.each do |_, index|
+                    stdout.puts "    #{(index+1).ordinalize} pass example matched.😱"
+                  end
+                end
+
+                unless fail_errors.empty?
+                  test_pass = false
+                  rule_ok = false
+
+                  fail_errors.each do |_, index|
+                    stdout.puts "    #{(index+1).ordinalize} fail example didn't match.😱"
+                  end
+                end
               end
             end
 
-            unless fail_errors.empty?
-              test_pass = false
-
-              fail_errors.each do |_, index|
-                stdout.puts "  #{(index+1).ordinalize} fail example didn't match.😱"
-              end
+            if rule.triggers.any?(&:skips_fail_examples?)
+              stdout.puts "  🚨 The rule contains a `pattern` with `glob`, which is not supported by the test command."
+              stdout.puts "    Skips testing `fail` examples."
             end
 
-            if pass_errors.empty? && fail_errors.empty?
+            if rule_ok
               stdout.puts "  OK!🎉"
             end
           end
@@ -92,10 +111,9 @@ module Goodcheck
         test_pass
       end
 
-      def rule_matches_example?(rule, example)
+      def rule_matches_example?(rule, trigger, example)
         buffer = Buffer.new(path: Pathname("-"), content: example)
-        analyzer = Analyzer.new(rule: rule, buffer: buffer)
-        analyzer.use_all_patterns!
+        analyzer = Analyzer.new(rule: rule, buffer: buffer, trigger: trigger)
         analyzer.scan.count > 0
       end
     end

data/lib/goodcheck/config.rb

@@ -24,20 +24,22 @@ module Goodcheck
       end
     end
 
-    def rules_for_path(path, rules_filter:, &block)
+    def rules_for_path(path, rules_filter:)
       if block_given?
         each_rule(filter: rules_filter).map do |rule|
-          globs = rule.patterns.flat_map(&:globs).push(*rule.globs)
+          rule.triggers.each do |trigger|
+            globs = trigger.globs
 
-          if globs.empty?
-            [rule, nil]
-          else
-            glob = globs.find {|glob| glob.test(path) }
-            if glob
-              [rule, glob]
+            if globs.empty?
+              yield [rule, nil, trigger]
+            else
+              glob = globs.find {|glob| glob.test(path) }
+              if glob
+                yield [rule, glob, trigger]
+              end
             end
           end
-        end.compact.each(&block)
+        end
       else
         enum_for(:rules_for_path, path, rules_filter: rules_filter)
       end

data/lib/goodcheck/config_loader.rb

@@ -35,9 +35,36 @@ module Goodcheck
                           })
       let :glob, array_or(one_glob)
 
+      let :var_pattern, any
+      let :variable_pattern, array_or(var_pattern)
+      let :negated_variable_pattern, object(not: variable_pattern)
+
+      let :where, hash(
+        enum(
+          variable_pattern,
+          negated_variable_pattern,
+          literal(true),
+          detector: -> (value) {
+            case
+            when value.is_a?(Hash) && value.key?(:not)
+              negated_variable_pattern
+            when value == true
+              literal(true)
+            else
+              variable_pattern
+            end
+          }
+        )
+      )
+
       let :regexp_pattern, object(regexp: string, case_sensitive: boolean?, multiline: boolean?, glob: optional(glob))
       let :literal_pattern, object(literal: string, case_sensitive: boolean?, glob: optional(glob))
-      let :token_pattern, object(token: string, case_sensitive: boolean?, glob: optional(glob))
+      let :token_pattern, object(
+        token: string,
+        case_sensitive: boolean?,
+        glob: optional(glob),
+        where: optional(where)
+      )
 
       let :pattern, enum(regexp_pattern,
                          literal_pattern,
@@ -95,12 +122,58 @@ module Goodcheck
         glob: glob
       )
 
+      let :positive_trigger, object(
+        pattern: array_or(pattern),
+        glob: optional(glob),
+        pass: optional(array_or(string)),
+        fail: optional(array_or(string))
+      )
+
+      let :negative_trigger, object(
+        not: object(pattern: array_or(pattern)),
+        glob: optional(glob),
+        pass: optional(array_or(string)),
+        fail: optional(array_or(string))
+      )
+
+      let :nopattern_trigger, object(
+        glob: glob_obj
+      )
+
+      let :trigger, enum(
+        positive_trigger,
+        negative_trigger,
+        nopattern_trigger,
+        detector: -> (hash) {
+          if hash.is_a?(Hash)
+            case
+            when hash.key?(:pattern)
+              positive_trigger
+            when hash.key?(:not)
+              negative_trigger
+            else
+              nopattern_trigger
+            end
+          end
+        }
+      )
+
+      let :triggered_rule, object(
+        id: string,
+        message: string,
+        justification: optional(array_or(string)),
+        trigger: array_or(trigger)
+      )
+
       let :rule, enum(positive_rule,
                       negative_rule,
                       nopattern_rule,
+                      triggered_rule,
                       detector: -> (hash) {
                         if hash.is_a?(Hash)
                           case
+                          when hash[:trigger]
+                            triggered_rule
                           when hash[:pattern]
                             positive_rule
                           when hash[:not]
@@ -180,14 +253,76 @@ module Goodcheck
       Goodcheck.logger.debug "Loading rule: #{hash[:id]}"
 
       id = hash[:id]
-      patterns, negated = retrieve_patterns(hash)
+      triggers = retrieve_triggers(hash)
       justifications = array(hash[:justification])
-      globs = load_globs(array(hash[:glob]))
       message = hash[:message].chomp
+
+      Rule.new(id: id, message: message, justifications: justifications, triggers: triggers)
+    end
+
+    def retrieve_triggers(hash)
+      if hash.key?(:trigger)
+        array(hash[:trigger]).map do |trigger|
+          retrieve_trigger(trigger)
+        end
+      else
+        globs = load_globs(array(hash[:glob]))
+        passes = array(hash[:pass])
+        fails = array(hash[:fail])
+
+        if hash.key?(:not) || hash.key?(:pattern)
+          if hash.key?(:not)
+            negated = true
+            patterns = array(hash[:not][:pattern])
+          else
+            negated = false
+            patterns = array(hash[:pattern])
+          end
+
+          glob_patterns, noglob_patterns = patterns.partition {|pat|
+            pat.is_a?(Hash) && pat.key?(:glob)
+          }
+
+          skip_fails = !fails.empty? && !glob_patterns.empty?
+
+          glob_patterns.map do |pat|
+            Trigger.new(
+              patterns: [load_pattern(pat)],
+              globs: load_globs(array(pat[:glob])),
+              passes: passes,
+              fails: [],
+              negated: negated
+            ).by_pattern!.skips_fail_examples!(skip_fails)
+          end.push(
+            Trigger.new(
+              patterns: noglob_patterns.map {|pat| load_pattern(pat) },
+              globs: globs,
+              passes: passes,
+              fails: glob_patterns.empty? ? fails : [],
+              negated: negated
+            ).by_pattern!.skips_fail_examples!(skip_fails)
+          )
+        else
+          [Trigger.new(patterns: [],
+                       globs: globs,
+                       passes: passes,
+                       fails: fails,
+                       negated: false).by_pattern!]
+        end
+      end
+    end
+
+    def retrieve_trigger(hash)
+      patterns, negated = retrieve_patterns(hash)
+      globs = load_globs(array(hash[:glob]))
       passes = array(hash[:pass])
       fails = array(hash[:fail])
 
-      Rule.new(id: id, patterns: patterns, justifications: justifications, globs: globs, message: message, passes: passes, fails: fails, negated: negated)
+      Trigger.new(patterns: patterns,
+                  globs: globs,
+                  passes: passes,
+                  fails: fails,
+                  negated: negated)
     end
 
     def retrieve_patterns(hash)
@@ -219,27 +354,84 @@ module Goodcheck
     def load_pattern(pattern)
       case pattern
       when String
-        Pattern.literal(pattern, case_sensitive: true)
+        case (pat = load_string_pattern(pattern))
+        when String
+          Pattern::Literal.new(source: pat, case_sensitive: true)
+        when ::Regexp
+          Pattern::Regexp.new(source: pattern,
+                              regexp: pat,
+                              multiline: pat.multiline?,
+                              case_sensitive: !pat.casefold?)
+        end
       when Hash
-        globs = load_globs(array(pattern[:glob]))
+        if pattern[:glob]
+          print_warning_once "🌏 Pattern with glob is deprecated: globs are ignored at all."
+        end
+
         case
         when pattern[:literal]
           cs = case_sensitive?(pattern)
           literal = pattern[:literal]
-          Pattern.literal(literal, case_sensitive: cs, globs: globs)
+          Pattern::Literal.new(source: literal, case_sensitive: cs)
         when pattern[:regexp]
           regexp = pattern[:regexp]
           cs = case_sensitive?(pattern)
           multiline = pattern[:multiline]
-          Pattern.regexp(regexp, case_sensitive: cs, multiline: multiline, globs: globs)
+          Pattern::Regexp.new(source: regexp, case_sensitive: cs, multiline: multiline)
         when pattern[:token]
           tok = pattern[:token]
           cs = case_sensitive?(pattern)
-          Pattern.token(tok, case_sensitive: cs, globs: globs)
+          Pattern::Token.new(source: tok, variables: load_token_vars(pattern[:where]), case_sensitive: cs)
+        end
+      end
+    end
+
+    def load_string_pattern(string)
+      if string =~ /\A\/(.*)\/([im]*)\Z/
+        source = $1
+        opts = $2
+        options = 0
+        options |= ::Regexp::IGNORECASE if opts =~ /i/
+        options |= ::Regexp::MULTILINE if opts =~ /m/
+        ::Regexp.new(source, options)
+      else
+        string
+      end
+    end
+
+    def load_token_vars(pattern)
+      case pattern
+      when Hash
+        pattern.each.with_object({}) do |(key, value), hash|
+          hash[key.to_sym] = load_var_pattern(value)
         end
+      else
+        {}
       end
     end
 
+    def load_var_pattern(pattern)
+      if pattern.is_a?(Hash) && pattern[:not]
+        negated = true
+        pattern = pattern[:not]
+      else
+        negated = false
+      end
+
+      pattern = [] if pattern == true
+
+      patterns = array(pattern).map do |pat|
+        case pat
+        when String
+          load_string_pattern(pat)
+        else
+          pat
+        end
+      end
+
+      Pattern::Token::VarPattern.new(patterns: patterns, negated: negated)
+    end
+
     def case_sensitive?(pattern)
       return true if pattern.is_a?(String)
       case

data/lib/goodcheck/glob.rb

@@ -11,5 +11,11 @@ module Goodcheck
     def test(path)
       path.fnmatch?(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB)
     end
+
+    def ==(other)
+      other.is_a?(Glob) &&
+        other.pattern == pattern &&
+        other.encoding == encoding
+    end
   end
 end

data/lib/goodcheck/issue.rb

@@ -27,5 +27,18 @@ module Goodcheck
         @location
       end
     end
+
+    def ==(other)
+      other.is_a?(Issue) &&
+        other.buffer == buffer &&
+        other.range == range &&
+        other.rule == rule
+    end
+
+    alias eql? ==
+
+    def hash
+      self.class.hash ^ buffer.hash ^ range.hash ^ rule.hash
+    end
   end
 end

data/lib/goodcheck/pattern.rb

@@ -1,74 +1,215 @@
 module Goodcheck
-  class Pattern
-    attr_reader :source
-    attr_reader :regexp
-    attr_reader :globs
-
-    def initialize(source:, regexp:, globs:)
-      @source = source
-      @regexp = regexp
-      @globs = globs
-    end
+  module Pattern
+    class Literal
+      attr_reader :source
+      attr_reader :case_sensitive
+
+      def initialize(source:, case_sensitive:)
+        @source = source
+        @case_sensitive = case_sensitive
+      end
 
-    def self.literal(literal, case_sensitive:, globs: [])
-      new(
-        source: literal,
-        regexp: Regexp.compile(Regexp.escape(literal), !case_sensitive),
-        globs: globs
-      )
+      def regexp
+        @regexp ||= ::Regexp.compile(::Regexp.escape(source), !case_sensitive)
+      end
     end
 
-    def self.regexp(regexp, case_sensitive:, multiline:, globs: [])
-      options = 0
-      options |= Regexp::IGNORECASE unless case_sensitive
-      options |= Regexp::MULTILINE if multiline
+    class Regexp
+      attr_reader :source
+      attr_reader :case_sensitive
+      attr_reader :multiline
 
-      new(
-        source: regexp,
-        regexp: Regexp.compile(regexp, options),
-        globs: globs
-      )
-    end
+      def initialize(source:, case_sensitive:, multiline:, regexp: nil)
+        @source = source
+        @case_sensitive = case_sensitive
+        @multiline = multiline
+        @regexp = regexp
+      end
 
-    def self.token(tokens, case_sensitive:, globs: [])
-      new(
-        source: tokens,
-        regexp: compile_tokens(tokens, case_sensitive: case_sensitive),
-        globs: globs
-      )
+      def regexp
+        @regexp ||= begin
+          options = 0
+          options |= ::Regexp::IGNORECASE unless case_sensitive
+          options |= ::Regexp::MULTILINE if multiline
+          ::Regexp.compile(source, options)
+        end
+      end
     end
 
-    def self.compile_tokens(source, case_sensitive:)
-      tokens = []
-      s = StringScanner.new(source)
-
-      until s.eos?
-        case
-        when s.scan(/\(|\)|\{|\}|\[|\]|\<|\>/)
-          tokens << Regexp.escape(s.matched)
-        when s.scan(/\s+/)
-          tokens << '\s+'
-        when s.scan(/\w+|[\p{Letter}&&\p{^ASCII}]+/)
-          tokens << Regexp.escape(s.matched)
-        when s.scan(%r{[!"#$%&'=\-^~¥\\|`@*:+;/?.,]+})
-          tokens << Regexp.escape(s.matched.rstrip)
-        when s.scan(/./)
-          tokens << Regexp.escape(s.matched)
+    class Token
+      attr_reader :source, :case_sensitive, :variables
+
+      def initialize(source:, variables:, case_sensitive:)
+        @source = source
+        @variables = variables
+        @case_sensitive = case_sensitive
+      end
+
+      def regexp
+        @regexp ||= Token.compile_tokens(source, variables, case_sensitive: case_sensitive)
+      end
+
+      class VarPattern
+        attr_reader :negated
+        attr_reader :patterns
+        attr_accessor :type
+
+        def initialize(patterns:, negated:)
+          @patterns = patterns
+          @negated = negated
+        end
+
+        def cast(str)
+          case type
+          when :int
+            str.to_i
+          when :float, :number
+            str.to_f
+          else
+            str
+          end
+        end
+
+        def test(str)
+          return true if patterns.empty?
+
+          value = cast(str)
+
+          unless negated
+            patterns.any? {|pattern| pattern === value }
+          else
+            patterns.none? {|pattern| pattern === value }
+          end
+        end
+
+        def self.empty
+          VarPattern.new(patterns: [], negated: false)
         end
       end
 
-      if tokens.first =~ /\A\p{Letter}/
-        tokens.first.prepend('\b')
+      def test_variables(match)
+        variables.all? do |name, var|
+          str = match[name]
+          str && var.test(str)
+        end
       end
 
-      if tokens.last =~ /\p{Letter}\Z/
-        tokens.last << '\b'
+      @@TYPES = {}
+
+      @@TYPES[:string] = -> (name) {
+        ::Regexp.union(
+          /"(?<#{name}>(?:[^"]|\")*)"/,
+          /'(?<#{name}>(?:[^']|\')*)'/
+        )
+      }
+
+      @@TYPES[:number] = -> (name) {
+        ::Regexp.union(
+          regexp_for_type(name: name, type: :int),
+          regexp_for_type(name: name, type: :float)
+        )
+      }
+
+      @@TYPES[:int] = -> (name) {
+        ::Regexp.union(
+          /(?<#{name}>[+-]?[1-9](:?\d|_\d)*)/,
+          /(?<#{name}>[+-]?0[dD][0-7]+)/,
+          /(?<#{name}>[+-]?0[oO]?[0-7]+)/,
+          /(?<#{name}>[+-]?0[xX][0-9a-fA-F]+)/,
+          /(?<#{name}>[+-]?0[bB][01]+)/
+        )
+      }
+
+      @@TYPES[:float] = -> (name) {
+        ::Regexp.union(
+          /(?<#{name}>[+-]?\d+\.\d*(:?e[+-]?\d+)?)/,
+          /(?<#{name}>[+-]?\d+(:?e[+-]?\d+)?)/
+        )
+      }
+
+      @@TYPES[:word] = -> (name) {
+        /(?<#{name}>\S+)/
+      }
+
+      @@TYPES[:identifier] = -> (name) {
+        /(?<#{name}>[a-zA-Z_]\w*)\b/
+      }
+
+      # From rails_autolink gem
+      # https://github.com/tenderlove/rails_autolink/blob/master/lib/rails_autolink/helpers.rb#L73
+      # With ')' support, which should be frequently used for markdown or CSS `url(...)`
+      AUTO_LINK_RE = %r{
+        (?: ((?:ed2k|ftp|http|https|irc|mailto|news|gopher|nntp|telnet|webcal|xmpp|callto|feed|svn|urn|aim|rsync|tag|ssh|sftp|rtsp|afs|file):)// | www\. )
+        [^\s<\u00A0")]+
+      }ix
+
+      # https://github.com/tenderlove/rails_autolink/blob/master/lib/rails_autolink/helpers.rb#L81-L82
+      AUTO_EMAIL_LOCAL_RE = /[\w.!#\$%&'*\/=?^`{|}~+-]/
+      AUTO_EMAIL_RE = /(?<!#{AUTO_EMAIL_LOCAL_RE})[\w.!#\$%+-]\.?#{AUTO_EMAIL_LOCAL_RE}*@[\w-]+(?:\.[\w-]+)+/
+
+      @@TYPES[:url] = -> (name) {
+        /\b(?<#{name}>#{AUTO_LINK_RE})/
+      }
+
+      @@TYPES[:email] = -> (name) {
+        /\b(?<#{name}>#{AUTO_EMAIL_RE})/
+      }
+
+      def self.regexp_for_type(name:, type:)
+        ty = type || :word
+        if @@TYPES.key?(ty)
+          @@TYPES[ty][name]
+        end
       end
 
-      options = Regexp::MULTILINE
-      options |= Regexp::IGNORECASE unless case_sensitive
+      def self.compile_tokens(source, variables, case_sensitive:)
+        tokens = []
+        s = StringScanner.new(source)
+
+        until s.eos?
+          case
+          when s.scan(/\${(?<name>[a-zA-Z_]\w*)(?::(?<type>#{::Regexp.union(*@@TYPES.keys.map(&:to_s))}))?}/)
+            name = s[:name].to_sym
+            type = s[:type] && s[:type].to_sym
 
-      Regexp.new(tokens.join('\s*').gsub(/\\s\*(\\s\+\\s\*)+/, '\s+'), options)
+            if variables.key?(name)
+              variables[name].type = type
+              regexp = regexp_for_type(name: name, type: type).to_s
+              if tokens.empty? && (type == :word || type == :identifier)
+                regexp = /\b#{regexp.to_s}/
+              end
+              tokens << regexp.to_s
+            else
+              tokens << ::Regexp.escape("${")
+              tokens << ::Regexp.escape(name.to_s)
+              tokens << ::Regexp.escape("}")
+            end
+          when s.scan(/\(|\)|\{|\}|\[|\]|\<|\>/)
+            tokens << ::Regexp.escape(s.matched)
+          when s.scan(/\s+/)
+            tokens << '\s+'
+          when s.scan(/\w+|[\p{L}&&\p{^ASCII}]+/)
+            tokens << ::Regexp.escape(s.matched)
+          when s.scan(%r{[!"#%&'=\-^~¥\\|`@*:+;/?.,]+})
+            tokens << ::Regexp.escape(s.matched.rstrip)
+          when s.scan(/./)
+            tokens << ::Regexp.escape(s.matched)
+          end
+        end
+
+        if tokens.first =~ /\A\p{L}/
+          tokens.first.prepend('\b')
+        end
+
+        if tokens.last =~ /\p{L}\Z/
+          tokens.last << '\b'
+        end
+
+        options = ::Regexp::MULTILINE
+        options |= ::Regexp::IGNORECASE unless case_sensitive
+
+        ::Regexp.new(tokens.join('\s*').gsub(/\\s\*(\\s\+\\s\*)+/, '\s+'), options)
+      end
     end
   end
 end

data/lib/goodcheck/rule.rb

@@ -1,26 +1,15 @@
 module Goodcheck
   class Rule
     attr_reader :id
-    attr_reader :patterns
+    attr_reader :triggers
     attr_reader :message
     attr_reader :justifications
-    attr_reader :globs
-    attr_reader :passes
-    attr_reader :fails
 
-    def initialize(id:, patterns:, message:, justifications:, globs:, fails:, passes:, negated:)
+    def initialize(id:, triggers:, message:, justifications:)
       @id = id
-      @patterns = patterns
+      @triggers = triggers
       @message = message
       @justifications = justifications
-      @globs = globs
-      @passes = passes
-      @fails = fails
-      @negated = negated
-    end
-
-    def negated?
-      @negated
     end
   end
 end

data/lib/goodcheck/trigger.rb

@@ -0,0 +1,44 @@
+module Goodcheck
+  class Trigger
+    attr_reader :patterns
+    attr_reader :globs
+    attr_reader :passes
+    attr_reader :fails
+    attr_reader :negated
+
+    def initialize(patterns:, globs:, passes:, fails:, negated:)
+      @patterns = patterns
+      @globs = globs
+      @passes = passes
+      @fails = fails
+      @negated = negated
+    end
+
+    def by_pattern!
+      @by_pattern = true
+      self
+    end
+
+    def by_pattern?
+      # True if the trigger is from `pattern` or `not` attribute (compatible mode.)
+      @by_pattern
+    end
+
+    def skips_fail_examples!(flag = true)
+      @skips_fail_examples = flag
+      self
+    end
+
+    def skips_fail_examples?
+      @skips_fail_examples
+    end
+
+    def negated?
+      @negated
+    end
+
+    def fires_for?(path:)
+      globs.any? {|glob| glob.test(path) }
+    end
+  end
+end

data/lib/goodcheck/version.rb

@@ -1,3 +1,3 @@
 module Goodcheck
-  VERSION = "1.7.1"
+  VERSION = "2.1.0"
 end

data/lib/goodcheck.rb

@@ -23,6 +23,7 @@ require "goodcheck/array_helper"
 require "goodcheck/analyzer"
 require "goodcheck/issue"
 require "goodcheck/rule"
+require "goodcheck/trigger"
 require "goodcheck/pattern"
 require "goodcheck/config"
 require "goodcheck/config_loader"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goodcheck
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-28 00:00:00.000000000 Z
+date: 2019-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -92,14 +92,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -147,6 +147,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- cheatsheet.pdf
 - exe/goodcheck
 - goodcheck.gemspec
 - lib/goodcheck.rb
@@ -170,6 +171,7 @@ files:
 - lib/goodcheck/reporters/json.rb
 - lib/goodcheck/reporters/text.rb
 - lib/goodcheck/rule.rb
+- lib/goodcheck/trigger.rb
 - lib/goodcheck/version.rb
 - logo/GoodCheck Horizontal.pdf
 - logo/GoodCheck Horizontal.png