goodcheck 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbd50cb641f78725c89b7543fad72cc682f89212
-  data.tar.gz: 3bfa5512cdd20c4401e6ebfbb25d32e471bb1bbe
+  metadata.gz: 941c25a76e1e8d433dabf11a05e9881251666ea6
+  data.tar.gz: af4c6b7a6f0c7de3318efd540a9031127a6eab22
 SHA512:
-  metadata.gz: 9c9f1ae3060429088686d073c579e24b675c0e4e03461e9ccdc8b7b230e9f1c09f2f78c471cc7fe2f233ae58bc5d21fc6caadfdd94bd75b44529bc248a8abbe9
-  data.tar.gz: 860f1810b61143bb3f3a7a09fff042919c8e82876e9c4cfb5e0f2131f4993d36d324b3a64aa20493dca3497e56e671300cb26a33ba6848672d6ffec06eca7c21
+  metadata.gz: 30d772081204a902869971bded0ba16b779500d3cad31a0857b75a10979c0cacbe7ce5be45b6b4c0520bd587649394bb54cf0873ea18dccba1896cedcdd20a5a
+  data.tar.gz: a3020566b156d0a23f3ca4b1a2ac590d39182bf47597dcc6fb89bcd861198821f671967925fcf37e0e56f01c39a388e45d9237181f2d2bb4a9b1467083c2d156

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 1.7.0 (2019-05-28)
+
+* Support a rule without `pattern` [#52](https://github.com/sider/goodcheck/pull/52)
+* Let each `pattern` have `glob` [#50](https://github.com/sider/goodcheck/pull/50)
+
 ## 1.6.0 (2019-05-08)
 
 * Add `not` pattern rule [#49](https://github.com/sider/goodcheck/pull/49)

data/README.md

@@ -63,7 +63,7 @@ rules:
 The *rule* hash contains the following keys.
 
 * `id`: a string to identify rules (required)
-* `pattern`: a *pattern* or a sequence of *pattern*s (required)
+* `pattern`: a *pattern* or a sequence of *pattern*s
 * `message`: a string to tell writers why the code piece should be revised (required)
 * `justification`: a sequence of strings to tell writers when a exception can be allowed (optional)
 * `glob`: a *glob* or a sequence of *glob*s (optional)
@@ -84,11 +84,13 @@ 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*
 
@@ -100,12 +102,13 @@ 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` and `multiline`.
+It accepts two optional attributes, `case_sensitive`, `multiline`, and `glob`.
 The default values of `case_sensitive` and `multiline` are `true` and `false` respectively.
 
 The regexp will be passed to `Regexp.compile`.
@@ -120,6 +123,7 @@ id: com.sample.no-blink
 pattern:
   token: "<blink"
   case_sensitive: false
+  glob: []
 message: Stop using <blink> tag
 glob: "**/*.html"
 justification:
@@ -133,7 +137,7 @@ 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 attribute, `case_sensitive`.
+It accepts one optional attributes, `case_sensitive` and `glob`.
 The default value of `case_sensitive` is `true`.
 Note that the generated regexp is in multiline mode.
 
@@ -156,6 +160,54 @@ If you write a string as a `glob`, the string value can be the `pattern` of the
 
 If you omit `glob` attribute in a rule, the rule will be applied to all files given to `goodcheck`.
 
+If both of your rule and its pattern has `glob`, Goodcheck will scan the pattern from the `glob` files in the pattern.
+
+```yaml
+rules:
+  - id: glob_test
+    pattern:
+      - literal: 123      # This pattern applies to .css files
+        glob: "*.css"
+      - literal: abc      # This pattern applies to .txt files
+    glob: "*.txt"
+```
+
+### A rule without _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_.
+
+```yaml
+rules:
+  - id: negated
+    not:
+      pattern:
+        <!DOCTYPE html>
+    message: Write a doctype on HTML files.
+    glob: "**/*.html"
+```
+
+### A rule without `pattern`
+
+You can define a rule without `pattern`.
+The rule emits a issue on each file specified with `glob`.
+You cannot omit `glob` from a rule definition without `pattern`.
+
+```yaml
+rules:
+  - id: without_pattern
+    message: |
+      Read the operation manual for DB migration: https://example.com/guides/123
+    glob: db/schema.rb
+```
+
+The output will be something like:
+
+```
+$ 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
+```
+
 ## Importing rules
 
 `goodcheck.yml` can have optional `import` attribute.

data/goodcheck.gemspec

@@ -25,9 +25,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">= 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.3.6"
 
   spec.add_runtime_dependency "activesupport", ">= 4.0", "< 6.0"
-  spec.add_runtime_dependency "strong_json", "~> 0.7.1"
+  spec.add_runtime_dependency "strong_json", "~> 1.0.0"
   spec.add_runtime_dependency "rainbow", "~> 3.0.0"
   spec.add_runtime_dependency "httpclient", "~> 2.8.3"
 end

data/lib/goodcheck/analyzer.rb

@@ -8,30 +8,55 @@ module Goodcheck
       @buffer = buffer
     end
 
+    def use_all_patterns!
+      @use_all_patterns = true
+    end
+
+    def patterns
+      if @use_all_patterns
+        rule.patterns
+      else
+        rule.patterns.select do |pattern|
+          case
+          when pattern.globs.empty? && rule.globs.empty?
+            true
+          when pattern.globs.empty?
+            rule.globs.any? {|glob| glob.test(buffer.path) }
+          else
+            pattern.globs.any? {|glob| glob.test(buffer.path) }
+          end
+        end
+      end
+    end
+
     def scan(&block)
       if block_given?
-        regexp = Regexp.union(*rule.patterns.map(&:regexp))
+        if rule.patterns.empty?
+          yield Issue.new(buffer: buffer, range: nil, rule: rule, text: nil)
+        else
+          regexp = Regexp.union(*patterns.map(&:regexp))
 
-        unless rule.negated?
-          issues = []
+          unless rule.negated?
+            issues = []
 
-          scanner = StringScanner.new(buffer.content)
+            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
+            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
             end
-          end
 
-          issues.each(&block)
-        else
-          unless regexp =~ buffer.content
-            yield Issue.new(buffer: buffer, range: nil, rule: rule, text: text)
+            issues.each(&block)
+          else
+            unless regexp =~ buffer.content
+              yield Issue.new(buffer: buffer, range: nil, rule: rule, text: nil)
+            end
           end
         end
       else

data/lib/goodcheck/commands/check.rb

@@ -45,8 +45,10 @@ module Goodcheck
           stderr.puts "  #{trace_loc}"
         end
         1
-      rescue StrongJSON::Type::Error => exn
-        stderr.puts "Invalid config at #{exn.path.map {|x| "[#{x}]" }.join}"
+      rescue StrongJSON::Type::TypeError, StrongJSON::Type::UnexpectedAttributeError => exn
+        stderr.puts "Invalid config: #{exn.message}"
+        stderr.puts StrongJSON::ErrorReporter.new(path: exn.path).to_s
+
         1
       rescue Errno::ENOENT => exn
         stderr.puts "#{exn}"

data/lib/goodcheck/commands/init.rb

@@ -3,7 +3,8 @@ module Goodcheck
     class Init
       CONFIG = <<-EOC
 rules:
-  - id: com.example.1
+  # id, pattern, message are required attributes.
+  - id: example.github
     pattern: Github
     message: Do you want to write GitHub?
     glob:
@@ -15,9 +16,46 @@ rules:
     pass:
       - Signup via GitHub
 
-exclude:
-  - node_modules
-  - vendor
+  # You can have *justification* to explain the exceptional cases.
+  - id: example.localStorage
+    pattern:
+      token: localStorage
+    message: |
+      Using localStorage may raise error (example: with Safari in private mode)
+    justification:
+      - If you catch the errors.
+      - When you implement admin console, where end users won't access.
+    glob:
+      - "**/*.js"
+    fail:
+      - |
+        localStorage.setItem(key, value);
+
+  # You can put `not` pattern to detect something is missing.
+  - id: example.strict-mode
+    not:
+      pattern: use strict
+    message: Use *strict mode* if possible.
+    glob: "**/*.js"
+    fail:
+      - |
+        const var = "This is *sloppy* mode."
+
+  # You can omit pattern, which prints the message on the files specified by glob.
+  - id: example.package-lock.json
+    message: Some of the packages are updated!
+    justification:
+      - If you update some of the packages.
+    glob: "package-lock.json"
+
+# You can import rules.
+# import:
+#   - https://example.com/example-rules.yml
+
+# You can skip checking files.
+# exclude:
+#   - node_modules
+#   - vendor
       EOC
 
       attr_reader :stdout

data/lib/goodcheck/commands/test.rb

@@ -93,6 +93,7 @@ module Goodcheck
       def rule_matches_example?(rule, example)
         buffer = Buffer.new(path: Pathname("-"), content: example)
         analyzer = Analyzer.new(rule: rule, buffer: buffer)
+        analyzer.use_all_patterns!
         analyzer.scan.count > 0
       end
     end

data/lib/goodcheck/config.rb

@@ -8,17 +8,33 @@ module Goodcheck
       @exclude_paths = exclude_paths
     end
 
+    def each_rule(filter:, &block)
+      if block_given?
+        if filter.empty?
+          rules.each(&block)
+        else
+          rules.each do |rule|
+            if filter.any? {|rule_id| rule.id == rule_id || rule.id.start_with?("#{rule_id}.") }
+              yield rule
+            end
+          end
+        end
+      else
+        enum_for :each_rule, filter: filter
+      end
+    end
+
     def rules_for_path(path, rules_filter:, &block)
       if block_given?
-        rules.map do |rule|
-          if rules_filter.empty? || rules_filter.any? {|filter| /\A#{Regexp.escape(filter)}\.?/ =~ rule.id }
-            if rule.globs.empty?
-              [rule, nil]
-            else
-              glob = rule.globs.find {|glob| path.fnmatch?(glob.pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
-              if glob
-                [rule, glob]
-              end
+        each_rule(filter: rules_filter).map do |rule|
+          globs = rule.patterns.flat_map(&:globs).push(*rule.globs)
+
+          if globs.empty?
+            [rule, nil]
+          else
+            glob = globs.find {|glob| glob.test(path) }
+            if glob
+              [rule, glob]
             end
           end
         end.compact.each(&block)

data/lib/goodcheck/config_loader.rb

@@ -5,48 +5,117 @@ module Goodcheck
     class InvalidPattern < StandardError; end
 
     Schema = StrongJSON.new do
+      def self.array_or(type)
+        a = array(type)
+        enum(a, type, detector: -> (value) {
+          case value
+          when Array
+            a
+          else
+            type
+          end
+        })
+      end
+
       let :deprecated_regexp_pattern, object(regexp: string, case_insensitive: boolean?, multiline: boolean?)
       let :deprecated_literal_pattern, object(literal: string, case_insensitive: boolean?)
       let :deprecated_token_pattern, object(token: string, case_insensitive: boolean?)
 
-      let :regexp_pattern, object(regexp: string, case_sensitive: boolean?, multiline: boolean?)
-      let :literal_pattern, object(literal: string, case_sensitive: boolean?)
-      let :token_pattern, object(token: string, case_sensitive: boolean?)
-
-      let :pattern, enum(regexp_pattern, literal_pattern, token_pattern,
-                         deprecated_regexp_pattern, deprecated_literal_pattern, deprecated_token_pattern,
-                         string)
-
       let :encoding, enum(*Encoding.name_list.map {|name| literal(name) })
-      let :glob, object(pattern: string, encoding: optional(encoding))
+      let :glob_obj, object(pattern: string, encoding: optional(encoding))
+      let :one_glob, enum(glob_obj,
+                          string,
+                          detector: -> (value) {
+                            case value
+                            when Hash
+                              glob_obj
+                            when String
+                              string
+                            end
+                          })
+      let :glob, array_or(one_glob)
+
+      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 :pattern, enum(regexp_pattern,
+                         literal_pattern,
+                         token_pattern,
+                         deprecated_regexp_pattern,
+                         deprecated_literal_pattern,
+                         deprecated_token_pattern,
+                         string,
+                         detector: -> (value) {
+                           case value
+                           when Hash
+                             case
+                             when value.key?(:regexp) && value.key?(:case_insensitive)
+                               deprecated_regexp_pattern
+                             when value.key?(:regexp)
+                               regexp_pattern
+                             when value.key?(:literal) && value.key?(:case_insensitive)
+                               deprecated_literal_pattern
+                             when value.key?(:literal)
+                               literal_pattern
+                             when value.key?(:token) && value.key?(:case_insensitive)
+                               deprecated_token_pattern
+                             when value.key?(:token)
+                               token_pattern
+                             end
+                           when String
+                             string
+                           end
+                         })
 
       let :positive_rule, object(
         id: string,
-        pattern: enum(array(pattern), pattern),
+        pattern: array_or(pattern),
         message: string,
-        justification: optional(enum(array(string), string)),
-        glob: optional(enum(array(enum(glob, string)), glob, string)),
-        pass: optional(enum(array(string), string)),
-        fail: optional(enum(array(string), string))
+        justification: optional(array_or(string)),
+        glob: optional(glob),
+        pass: optional(array_or(string)),
+        fail: optional(array_or(string))
       )
 
       let :negative_rule, object(
         id: string,
-        not: object(pattern: enum(array(pattern), pattern)),
+        not: object(pattern: array_or(pattern)),
+        message: string,
+        justification: optional(array_or(string)),
+        glob: optional(glob),
+        pass: optional(array_or(string)),
+        fail: optional(array_or(string))
+      )
+
+      let :nopattern_rule, object(
+        id: string,
         message: string,
-        justification: optional(enum(array(string), string)),
-        glob: optional(enum(array(enum(glob, string)), glob, string)),
-        pass: optional(enum(array(string), string)),
-        fail: optional(enum(array(string), string))
+        justification: optional(array_or(string)),
+        glob: glob
       )
 
-      let :rule, enum(positive_rule, negative_rule)
+      let :rule, enum(positive_rule,
+                      negative_rule,
+                      nopattern_rule,
+                      detector: -> (hash) {
+                        if hash.is_a?(Hash)
+                          case
+                          when hash[:pattern]
+                            positive_rule
+                          when hash[:not]
+                            negative_rule
+                          when hash.key?(:glob) && !hash.key?(:pattern) && !hash.key?(:not)
+                            nopattern_rule
+                          end
+                        end
+                      })
 
       let :rules, array(rule)
 
       let :import_target, string
       let :imports, array(import_target)
-      let :exclude, enum(array(string), string)
+      let :exclude, array_or(string)
 
       let :config, object(
         rules: rules,
@@ -129,7 +198,11 @@ module Goodcheck
         negated = false
       end
 
-      [array(hash[:pattern]).map {|pat| load_pattern(pat) }, negated]
+      if hash.key?(:pattern)
+        [array(hash[:pattern]).map {|pat| load_pattern(pat) }, negated]
+      else
+        [[], false]
+      end
     end
 
     def load_globs(globs)
@@ -148,20 +221,21 @@ module Goodcheck
       when String
         Pattern.literal(pattern, case_sensitive: true)
       when Hash
+        globs = load_globs(array(pattern[:glob]))
         case
         when pattern[:literal]
           cs = case_sensitive?(pattern)
           literal = pattern[:literal]
-          Pattern.literal(literal, case_sensitive: cs)
+          Pattern.literal(literal, case_sensitive: cs, globs: globs)
         when pattern[:regexp]
           regexp = pattern[:regexp]
           cs = case_sensitive?(pattern)
           multiline = pattern[:multiline]
-          Pattern.regexp(regexp, case_sensitive: cs, multiline: multiline)
+          Pattern.regexp(regexp, case_sensitive: cs, multiline: multiline, globs: globs)
         when pattern[:token]
           tok = pattern[:token]
           cs = case_sensitive?(pattern)
-          Pattern.token(tok, case_sensitive: cs)
+          Pattern.token(tok, case_sensitive: cs, globs: globs)
         end
       end
     end

data/lib/goodcheck/glob.rb

@@ -7,5 +7,9 @@ module Goodcheck
       @pattern = pattern
       @encoding = encoding
     end
+
+    def test(path)
+      path.fnmatch?(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+    end
   end
 end

data/lib/goodcheck/pattern.rb

@@ -2,26 +2,40 @@ module Goodcheck
   class Pattern
     attr_reader :source
     attr_reader :regexp
+    attr_reader :globs
 
-    def initialize(source:, regexp:)
+    def initialize(source:, regexp:, globs:)
       @source = source
       @regexp = regexp
+      @globs = globs
     end
 
-    def self.literal(literal, case_sensitive:)
-      new(source: literal, regexp: Regexp.compile(Regexp.escape(literal), !case_sensitive))
+    def self.literal(literal, case_sensitive:, globs: [])
+      new(
+        source: literal,
+        regexp: Regexp.compile(Regexp.escape(literal), !case_sensitive),
+        globs: globs
+      )
     end
 
-    def self.regexp(regexp, case_sensitive:, multiline:)
+    def self.regexp(regexp, case_sensitive:, multiline:, globs: [])
       options = 0
       options |= Regexp::IGNORECASE unless case_sensitive
       options |= Regexp::MULTILINE if multiline
 
-      new(source: regexp, regexp: Regexp.compile(regexp, options))
+      new(
+        source: regexp,
+        regexp: Regexp.compile(regexp, options),
+        globs: globs
+      )
     end
 
-    def self.token(tokens, case_sensitive:)
-      new(source: tokens, regexp: compile_tokens(tokens, case_sensitive: case_sensitive))
+    def self.token(tokens, case_sensitive:, globs: [])
+      new(
+        source: tokens,
+        regexp: compile_tokens(tokens, case_sensitive: case_sensitive),
+        globs: globs
+      )
     end
 
     def self.compile_tokens(source, case_sensitive:)

data/lib/goodcheck/version.rb

@@ -1,3 +1,3 @@
 module Goodcheck
-  VERSION = "1.6.0"
+  VERSION = "1.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goodcheck
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-08 00:00:00.000000000 Z
+date: 2019-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -78,14 +92,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement