lib/goodcheck/config_loader.rb in goodcheck-1.5.1 vs lib/goodcheck/config_loader.rb in goodcheck-1.6.0

@@ -18,20 +18,32 @@
                          string)
 
       let :encoding, enum(*Encoding.name_list.map {|name| literal(name) })
       let :glob, object(pattern: string, encoding: optional(encoding))
 
-      let :rule, object(
+      let :positive_rule, object(
         id: string,
         pattern: enum(array(pattern), 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))
       )
 
+      let :negative_rule, object(
+        id: string,
+        not: object(pattern: enum(array(pattern), 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))
+      )
+
+      let :rule, enum(positive_rule, negative_rule)
+
       let :rules, array(rule)
 
       let :import_target, string
       let :imports, array(import_target)
       let :exclude, enum(array(string), string)
@@ -97,23 +109,28 @@
 
     def load_rule(hash)
       Goodcheck.logger.debug "Loading rule: #{hash[:id]}"
 
       id = hash[:id]
-      patterns = retrieve_patterns(hash)
+      patterns, negated = retrieve_patterns(hash)
       justifications = array(hash[:justification])
       globs = load_globs(array(hash[:glob]))
       message = hash[:message].chomp
       passes = array(hash[:pass])
       fails = array(hash[:fail])
 
-      Rule.new(id: id, patterns: patterns, justifications: justifications, globs: globs, message: message, passes: passes, fails: fails)
+      Rule.new(id: id, patterns: patterns, justifications: justifications, globs: globs, message: message, passes: passes, fails: fails, negated: negated)
     end
 
     def retrieve_patterns(hash)
-      array(hash[:pattern]).map do |pat|
-        load_pattern(pat)
+      if hash.is_a?(Hash) && hash.key?(:not)
+        negated = true
+        hash = hash[:not]
+      else
+        negated = false
       end
+
+      [array(hash[:pattern]).map {|pat| load_pattern(pat) }, negated]
     end
 
     def load_globs(globs)
       globs.map do |glob|
         case glob