goodcheck 2.3.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f192f5e6c846fa4e75eeec17b1333d47a5c79f3e06a26190af57e89cfe7ccf1
-  data.tar.gz: f3f0a8e10aad7c78dc1b3dbdc8ae03448401be868d21f10a5227e9007195b5fd
+  metadata.gz: 7da3a85a6dd3f95677661f7863fbc9d51da6ec01272c5e023fa2517aebd7db01
+  data.tar.gz: 8c5f69286210ead4b2f58cc9d11278afad7c704f9056fb2e29b43dad89859985
 SHA512:
-  metadata.gz: a0aee2cbb240465ef3c7ae05383d5cfa1f0827cc132bf79bcb46b5c7a309a2000fc76b79e95ed4bb199fd98d1b0bb5af9e2a6dddb18592a3a06ddc4e6dec6c5a
-  data.tar.gz: a5039ed9328e05f8f49f3d9c36157771665245f9606fc88a1e49e2f7bb80f19cc5cd1c4d1c4853febc6c0cbb56688b18361873340b6d8558aa93552a181ea674
+  metadata.gz: b7394690992cdec71af0ad640998142b77fd07814b9266ce148b18ca65d56f76eadde56d70384e5bc46e3d50911e41ef4350532aeab7f7fc8f85168c4bee46e8
+  data.tar.gz: 9acb5eb4387b21293c2e83501cc8478afd2a5c5e3acf49f6db05660cec6c8da28959bcfe398396f3a08312dad14b666c5b5cef199dffd0be0df9aee2071c80bc

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 2.4.0 (2019-07-11)
+
+* Add `pattern` command to print regexp of patterns [#63](https://github.com/sider/goodcheck/pull/63)
+* Fix variable pattern without a type [#62](https://github.com/sider/goodcheck/pull/62)
+
 ## 2.3.2 (2019-07-04)
 
 * Update README

data/README.md

@@ -177,6 +177,26 @@ We have 8 built-in patterns:
 
 You can find the exact definitions of the types in the definition of `Goodcheck::Pattern::Token` (`@@TYPES`).
 
+You can omit the type of a variable binding.
+
+```yaml
+pattern:
+  - token: margin-left: ${size}px;
+    where:
+      size: true
+  - token: backgroundColor={${color}}
+    where:
+      color: true
+```
+
+In this case, the following character will be used to detect the range of binding. In the first example above, the `px` will be used as the marker for the end of `size` binding.
+
+If parens are surrounding the variable, Goodcheck tries to match with nested ones in the variable. It expands five levels of nesting of parens. See the example of matches with the second `backgroundColor` pattern:
+
+- `backgroundColor={color}` Matches (`color=="color"`)
+- `backgroundColor={{ red: red(), green: green(), blue: green()-1 }}` Matches (`color=="{ red: red(), green: green(), blue: green()-1 }"`)
+- `backgroundColor={ {{{{{{}}}}}} }` Matches (`color==" {{{{{{}}}}}"`)
+
 ### *glob*
 
 A *glob* can be a string, or a hash.
@@ -352,13 +372,22 @@ The test contains:
 
 Use `test` command when you add new rule to be sure you are writing rules correctly.
 
-Available options is:
+Available options are:
 
 * `-c [CONFIG]`, `--config=[CONFIG]` to specify the configuration file.
 * `-v`, `--verbose` to be verbose.
 * `--debug` to print all debug messages.
 * `--force` to ignore downloaded caches
 
+### `goodcheck pattern [options] ids...`
+
+The `pattern` command prints the regular expressions generated from the patterns.
+The command is for debugging patterns, especially token patterns.
+
+Available option is:
+
+* `-c [CONFIG]`, `--config=[CONFIG]` to specify the configuration file.
+
 ## Downloaded rules
 
 Downloaded rules are cached in `cache` directory in *goodcheck home directory*.

data/lib/goodcheck/cli.rb

@@ -16,6 +16,7 @@ module Goodcheck
       init: "Generate a sample configuration file",
       check: "Run check with a configuration",
       test: "Test your configuration",
+      pattern: "Print regexp for rules",
       version: "Print version",
       help: "Show goodcheck version and quit"
     }
@@ -161,5 +162,17 @@ module Goodcheck
       end
       0
     end
+
+    def pattern(args)
+      config_path = Pathname("goodcheck.yml")
+
+      OptionParser.new("Usage: goodcheck pattern [options] ids...") do |opts|
+        opts.on("-c CONFIG", "--config=CONFIG") do |config|
+          config_path = Pathname(config)
+        end
+      end.parse!(args)
+
+      Commands::Pattern.new(stdout: stdout, stderr: stderr, path: config_path, ids: Set.new(args), home_path: home_path).run
+    end
   end
 end

data/lib/goodcheck/commands/pattern.rb

@@ -0,0 +1,41 @@
+module Goodcheck
+  module Commands
+    class Pattern
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :config_path
+      attr_reader :ids
+      attr_reader :home_path
+
+      include ConfigLoading
+      include HomePath
+
+      def initialize(stdout:, stderr:, path:, ids:, home_path:)
+        @stdout = stdout
+        @stderr = stderr
+        @config_path = path
+        @ids = ids
+        @home_path = home_path
+      end
+
+      def run
+        handle_config_errors stderr do
+          load_config!(cache_path: cache_dir_path, force_download: true)
+
+          config.rules.each do |rule|
+            if ids.empty? || ids.any? {|pat| pat == rule.id || rule.id.start_with?("#{pat}.") }
+              stdout.puts "#{rule.id}:"
+              rule.triggers.each do |trigger|
+                trigger.patterns.each do |pattern|
+                  stdout.puts "  - #{pattern.regexp.inspect}"
+                end
+              end
+            end
+          end
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/goodcheck/pattern.rb

@@ -162,13 +162,48 @@ module Goodcheck
         /\b(?<#{name}>#{AUTO_EMAIL_RE})/
       }
 
-      def self.regexp_for_type(name:, type:)
-        ty = type || :word
-        if @@TYPES.key?(ty)
-          @@TYPES[ty][name]
+      def self.expand(prefix, suffix, depth: 5)
+        if depth == 0
+          [
+            /[^#{suffix}]*/
+          ]
+        else
+          expandeds = expand(prefix, suffix, depth: depth - 1)
+          [/[^#{prefix}#{suffix}]*#{prefix}#{expandeds.first}#{suffix}[^#{prefix}#{suffix}]*/] + expandeds
         end
       end
 
+      def self.regexp_for_type(name:, type:, scanner:)
+        prefix = scanner.pre_match[-1]
+        suffix = scanner.check(WORD_RE) || scanner.peek(1)
+
+        case
+        when type == :__
+          body = case
+                 when prefix == "{" && suffix == "}"
+                   ::Regexp.union(expand(prefix, suffix))
+                 when prefix == "(" && suffix == ")"
+                   ::Regexp.union(expand(prefix, suffix))
+                 when prefix == "[" && suffix == "]"
+                   ::Regexp.union(expand(prefix, suffix))
+                 when prefix == "<" && suffix == ">"
+                   ::Regexp.union(expand(prefix, suffix))
+                 else
+                   unless suffix.empty?
+                     /(?~#{::Regexp.escape(suffix)})/
+                   else
+                     /.*/
+                   end
+                 end
+          /(?<#{name}>#{body})/
+
+        when @@TYPES.key?(type)
+          @@TYPES[type][name]
+        end
+      end
+
+      WORD_RE = /\w+|[\p{L}&&\p{^ASCII}]+/
+
       def self.compile_tokens(source, variables, case_sensitive:)
         tokens = []
         s = StringScanner.new(source)
@@ -177,15 +212,24 @@ module Goodcheck
           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
+            type = s[:type] ? s[:type].to_sym : :__
 
             if variables.key?(name)
+              if !s[:type] && s.pre_match == ""
+                Goodcheck.logger.error "Variable binding ${#{name}} at the beginning of pattern would cause an unexpected match"
+              end
+              if !s[:type] && s.peek(1) == ""
+                Goodcheck.logger.error "Variable binding ${#{name}} at the end of pattern would cause an unexpected match"
+              end
+
+              tokens << :nobr
               variables[name].type = type
-              regexp = regexp_for_type(name: name, type: type).to_s
+              regexp = regexp_for_type(name: name, type: type, scanner: s).to_s
               if tokens.empty? && (type == :word || type == :identifier)
                 regexp = /\b#{regexp.to_s}/
               end
               tokens << regexp.to_s
+              tokens << :nobr
             else
               tokens << ::Regexp.escape("${")
               tokens << ::Regexp.escape(name.to_s)
@@ -195,7 +239,7 @@ module Goodcheck
             tokens << ::Regexp.escape(s.matched)
           when s.scan(/\s+/)
             tokens << '\s+'
-          when s.scan(/\w+|[\p{L}&&\p{^ASCII}]+/)
+          when s.scan(WORD_RE)
             tokens << ::Regexp.escape(s.matched)
           when s.scan(%r{[!"#%&'=\-^~¥\\|`@*:+;/?.,]+})
             tokens << ::Regexp.escape(s.matched.rstrip)
@@ -204,18 +248,32 @@ module Goodcheck
           end
         end
 
-        if tokens.first =~ /\A\p{L}/
+        if source[0] =~ /\p{L}/
           tokens.first.prepend('\b')
         end
 
-        if tokens.last =~ /\p{L}\Z/
+        if source[-1] =~ /\p{L}/
           tokens.last << '\b'
         end
 
         options = ::Regexp::MULTILINE
         options |= ::Regexp::IGNORECASE unless case_sensitive
 
-        ::Regexp.new(tokens.join('\s*').gsub(/\\s\*(\\s\+\\s\*)+/, '\s+'), options)
+        buf, skip = tokens[0].is_a?(String) ? [tokens[0], false] : ["", true]
+        tokens.drop(1).each do |tok|
+          if tok == :nobr
+            skip = true
+          else
+            buf << '\s*' unless skip
+            skip = false
+            buf << tok
+          end
+        end
+
+        ::Regexp.new(buf.
+          gsub(/\\s\*(\\s\+\\s\*)+/, '\s+').
+          gsub(/#{::Regexp.escape('\s+\s*')}/, '\s+').
+          gsub(/#{::Regexp.escape('\s*\s+')}/, '\s+'), options)
       end
     end
   end

data/lib/goodcheck/version.rb

@@ -1,3 +1,3 @@
 module Goodcheck
-  VERSION = "2.3.2"
+  VERSION = "2.4.0"
 end

data/lib/goodcheck.rb

@@ -32,3 +32,4 @@ require "goodcheck/commands/check"
 require "goodcheck/commands/init"
 require "goodcheck/commands/test"
 require "goodcheck/import_loader"
+require "goodcheck/commands/pattern"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goodcheck
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-04 00:00:00.000000000 Z
+date: 2019-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -158,6 +158,7 @@ files:
 - lib/goodcheck/commands/check.rb
 - lib/goodcheck/commands/config_loading.rb
 - lib/goodcheck/commands/init.rb
+- lib/goodcheck/commands/pattern.rb
 - lib/goodcheck/commands/test.rb
 - lib/goodcheck/config.rb
 - lib/goodcheck/config_loader.rb