puppet-lint 0.4.0.pre1 → 1.0.0

data/lib/puppet-lint/configuration.rb

@@ -1,4 +1,6 @@
 class PuppetLint
+  # Public: A singleton class to store the running configuration of
+  # puppet-lint.
   class Configuration
     # Internal: Add helper methods for a new check to the
     # PuppetLint::Configuration object.
@@ -38,7 +40,9 @@ class PuppetLint
     # Public: Catch situations where options are being set for the first time
     # and create the necessary methods to get & set the option in the future.
     #
-    # args[0] - The value to set the option to.
+    # args   - An Array of values to set the option to.
+    # method - The String name of the option.
+    # block  - Unused.
     #
     # Returns nothing.
     #
@@ -102,22 +106,12 @@ class PuppetLint
     # Internal: Register a new check.
     #
     # check - The String name of the check
-    # b     - The Block containing the logic of the check
+    # klass - The Class containing the check logic.
     #
     # Returns nothing.
-    def add_check(check, &b)
+    def add_check(check, klass)
       self.class.add_check(check)
-      check_method[check] = b
-    end
-
-    # Internal: Register a new check helper method.
-    #
-    # name - The String name of the method.
-    # b    - The Block containing the logic of the helper.
-    #
-    # Returns nothing.
-    def add_helper(name, &b)
-      helper_method[name] = b
+      check_object[check] = klass
     end
 
     # Internal: Access the internal storage for settings.
@@ -130,29 +124,15 @@ class PuppetLint
     # Internal: Access the internal storage for check method blocks.
     #
     # Returns a Hash containing all the check blocks.
-    def check_method
-      @check_method ||= {}
+    def check_object
+      @check_object ||= {}
     end
 
     # Public: Get a list of all the defined checks.
     #
     # Returns an Array of String check names.
     def checks
-      check_method.keys
-    end
-
-    # Internal: Access the internal storage for helper method blocks.
-    #
-    # Returns a Hash containing all the helper blocks.
-    def helper_method
-      @helper_method ||= {}
-    end
-
-    # Public: Get a list of all the helper methods.
-    #
-    # Returns an Array of String method names.
-    def helpers
-      helper_method.keys
+      check_object.keys
     end
 
     # Public: Clear the PuppetLint::Configuration storage and set some sane
@@ -167,6 +147,7 @@ class PuppetLint
       self.log_format = ''
       self.with_context = false
       self.fix = false
+      self.show_ignored = false
     end
   end
 end

data/lib/puppet-lint/data.rb

@@ -0,0 +1,329 @@
+require 'singleton'
+require 'set'
+
+# Public: A singleton class storing all the information about the manifest
+# being analysed.
+class PuppetLint::Data
+  include Singleton
+
+  class << self
+    # Internal: Get/Set the full expanded path to the manifest file being
+    # checked.
+    attr_reader :path, :fullpath, :filename
+
+    # Internal: Get/Set the raw manifest data, split by \n.
+    attr_accessor :manifest_lines
+
+    # Internal: Store the tokenised manifest.
+    #
+    # tokens - The Array of PuppetLint::Lexer::Token objects to store.
+    #
+    # Returns nothing.
+    def tokens=(tokens)
+      @tokens = tokens
+      @title_tokens = nil
+      @resource_indexes = nil
+      @class_indexes = nil
+      @defined_type_indexes = nil
+    end
+
+    # Public: Get the tokenised manifest.
+    #
+    # Returns an Array of PuppetLint::Lexer::Token objects.
+    def tokens
+      if caller[0][/`.*'/][1..-2] == 'check'
+        @tokens.dup
+      else
+        @tokens
+      end
+    end
+
+    # Internal: Store the path to the manifest file and populate fullpath and
+    # filename.
+    #
+    # val - The path to the file as a String.
+    #
+    # Returns nothing.
+    def path=(val)
+      @path = val
+      if val.nil?
+        @fullpath = nil
+        @filename = nil
+      else
+        @fullpath = File.expand_path(val, ENV['PWD'])
+        @filename = File.basename(val)
+      end
+    end
+
+    # Internal: Retrieve a list of tokens that represent resource titles
+    #
+    # Returns an Array of PuppetLint::Lexer::Token objects.
+    def title_tokens
+      @title_tokens ||= Proc.new do
+        result = []
+        tokens.each_index do |token_idx|
+          if tokens[token_idx].type == :COLON
+            # gather a list of tokens that are resource titles
+            if tokens[token_idx-1].type == :RBRACK
+              array_start_idx = tokens.rindex { |r|
+                r.type == :LBRACK
+              }
+              title_array_tokens = tokens[(array_start_idx + 1)..(token_idx - 2)]
+              result += title_array_tokens.select { |token|
+                {:STRING => true, :NAME => true}.include? token.type
+              }
+            else
+              next_token = tokens[token_idx].next_code_token
+              if next_token.type != :LBRACE
+                result << tokens[token_idx - 1]
+              end
+            end
+          end
+        end
+        result
+      end.call
+    end
+
+    # Internal: Calculate the positions of all resource declarations within the
+    # tokenised manifest. These positions only point to the content of the
+    # resource declarations, they do not include resource types or titles.
+    #
+    # Returns an Array of Hashes, each containing:
+    #   :start - An Integer position in the `tokens` Array pointing to the
+    #            first Token of a resource declaration.
+    #   :end   - An Integer position in the `tokens` Array pointing to the last
+    #            Token of a resource declaration.
+    def resource_indexes
+      @resource_indexes ||= Proc.new do
+        result = []
+        tokens.each_index do |token_idx|
+          if tokens[token_idx].type == :COLON
+            next_token = tokens[token_idx].next_code_token
+            depth = 1
+            if next_token.type != :LBRACE
+              tokens[(token_idx + 1)..-1].each_index do |idx|
+                real_idx = token_idx + idx + 1
+                if tokens[real_idx].type == :LBRACE
+                  depth += 1
+                elsif {:SEMIC => true, :RBRACE => true}.include? tokens[real_idx].type
+                  unless tokens[real_idx].type == :SEMIC && depth > 1
+                    depth -= 1
+                    if depth == 0
+                      result << {
+                        :start        => token_idx + 1,
+                        :end          => real_idx,
+                        :tokens       => tokens[(token_idx + 1)..real_idx],
+                        :type         => find_resource_type_token(token_idx),
+                        :param_tokens => find_resource_param_tokens(tokens[(token_idx + 1)..real_idx]),
+                      }
+                      break
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        result
+      end.call
+    end
+
+    # Internal: Find the Token representing the type of a resource definition.
+    #
+    # index - The Integer pointing to the start of the resource in the `tokens`
+    #         array.
+    #
+    # Returns a Token object.
+    def find_resource_type_token(index)
+      tokens[tokens[0..index].rindex { |token| token.type == :LBRACE }].prev_code_token
+    end
+
+    # Internal: Find all the Token objects representing the parameter names in
+    # a resource definition.
+    #
+    # resource_tokens - An Array of Token objects that comprise the resource
+    #                   definition.
+    #
+    # Returns an Array of Token objects.
+    def find_resource_param_tokens(resource_tokens)
+      resource_tokens.select { |token|
+        token.type == :NAME && token.next_code_token.type == :FARROW
+      }
+    end
+
+    # Internal: Calculate the positions of all class definitions within the
+    # `tokens` Array.
+    #
+    # Returns an Array of Hashes, each containing:
+    #   :start  - An Integer position in the `tokens` Array pointing to the
+    #             first Token of a class definition.
+    #   :end    - An Integer position in the `tokens` Array pointing to the last
+    #             Token of a class definition.
+    #   :tokens - An Array consisting of all the Token objects that make up the
+    #             class definition.
+    def class_indexes
+      @class_indexes ||= definition_indexes(:CLASS)
+    end
+
+    # Internal: Calculate the positions of all defined type definitions within
+    # the `tokens` Array.
+    #
+    # Returns an Array of Hashes, each containing:
+    #   :start  - An Integer position in the `tokens` Array pointing to the
+    #             first Token of a defined type definition.
+    #   :end    - An Integer position in the `tokens` Array pointing to the last
+    #             Token of a defined type definition.
+    #   :tokens - An Array consisting of all the Token objects that make up the
+    #             defined type.
+    def defined_type_indexes
+      @defined_type_indexes ||= definition_indexes(:DEFINE)
+    end
+
+    # Internal: Calculate the positions of all the specified defintion types
+    # within the `tokens` Array.
+    #
+    # Returns an Array of Hashes, each containing:
+    #   :start  - An Integer position in the `tokens` Array pointing to the
+    #             first Token of a definition.
+    #   :end    - An Integer position in the `tokens` Array pointing to the last
+    #             Token of a definition.
+    #   :tokens - An Array consisting of all the Token objects that make up the
+    #             definition.
+    def definition_indexes(type)
+      result = []
+      tokens.each_with_index do |token, i|
+        if token.type == type
+          brace_depth = 0
+          paren_depth = 0
+          in_params = false
+          inherited_class = nil
+          tokens[i+1..-1].each_with_index do |definition_token, j|
+            case definition_token.type
+            when :INHERITS
+              inherited_class = definition_token.next_code_token
+            when :LPAREN
+              in_params = true if paren_depth == 0
+              paren_depth += 1
+            when :RPAREN
+              in_params = false if paren_depth == 1
+              paren_depth -= 1
+            when :LBRACE
+              brace_depth += 1
+            when :RBRACE
+              brace_depth -= 1
+              if brace_depth == 0 && !in_params
+                if token.next_code_token.type != :LBRACE
+                  result << {
+                    :start           => i,
+                    :end             => i + j + 1,
+                    :tokens          => tokens[i..(i + j + 1)],
+                    :param_tokens    => param_tokens(tokens[i..(i + j + 1)]),
+                    :type            => type,
+                    :name_token      => token.next_code_token,
+                    :inherited_token => inherited_class,
+                  }
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+      result
+    end
+
+    # Internal: Finds all the tokens that make up the defined type or class
+    # definition parameters.
+    #
+    # these_tokens - An Array of PuppetLint::Lexer::Token objects that make up
+    #                the defined type or class definition.
+    #
+    # Returns an Array of PuppetLint::Lexer::Token objects or nil if it takes
+    # no parameters.
+    def param_tokens(these_tokens)
+      depth = 0
+      lparen_idx = nil
+      rparen_idx = nil
+
+      these_tokens.each_with_index do |token, i|
+        if token.type == :LPAREN
+          depth += 1
+          lparen_idx = i if depth == 1
+        elsif token.type == :RPAREN
+          depth -= 1
+          if depth == 0
+            rparen_idx = i
+            break
+          end
+        end
+      end
+
+      if lparen_idx.nil? or rparen_idx.nil?
+        nil
+      else
+        these_tokens[(lparen_idx + 1)..(rparen_idx - 1)]
+      end
+    end
+
+    # Internal: Retrieves a list of token types that are considered to be
+    # formatting tokens (whitespace, newlines, etc).
+    #
+    # Returns an Array of Symbols.
+    def formatting_tokens
+      @formatting_tokens ||= PuppetLint::Lexer::FORMATTING_TOKENS
+    end
+
+    # Internal: Retrieves a Hash of Sets. Each key is a check name Symbol and
+    # the Set of Integers returned lists all the lines that the check results
+    # should be ignored on.
+    #
+    # Returns a Hash of Sets of Integers.
+    def ignore_overrides
+      @ignore_overrides ||= {}
+    end
+
+    # Internal: Parses all COMMENT, MLCOMMENT and SLASH_COMMENT tokens looking
+    # for control comments (comments that enable or disable checks). Builds the
+    # contents of the `ignore_overrides` hash.
+    #
+    # Returns nothing.
+    def parse_control_comments
+      @ignore_overrides.each_key { |check| @ignore_overrides[check].clear }
+
+      comment_token_types = Set[:COMMENT, :MLCOMMENT, :SLASH_COMMENT]
+
+      comment_tokens = tokens.select { |token|
+        comment_token_types.include?(token.type)
+      }
+      control_comment_tokens = comment_tokens.select { |token|
+        token.value.strip =~ /\Alint:(ignore:[\w\d]+|endignore)/
+      }
+
+      stack = []
+      control_comment_tokens.each do |token|
+        control, reason = token.value.strip.split(' ', 2)
+        split_control = control.split(':')
+        command = split_control[1]
+
+        if command == 'ignore'
+          check = split_control[2].to_sym
+
+          if token.prev_token && !Set[:NEWLINE, :INDENT].include?(token.prev_token.type)
+            # control comment at the end of the line, override applies to
+            # a single line only
+            (ignore_overrides[check] ||= {})[token.line] = reason
+          else
+            stack << [token.line, reason, check]
+          end
+        else
+          start = stack.pop
+          unless start.nil?
+            (start[0]..token.line).each do |i|
+              (ignore_overrides[start[2]] ||= {})[i] = start[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet-lint/lexer.rb

@@ -4,6 +4,8 @@ require 'puppet-lint/lexer/token'
 require 'set'
 
 class PuppetLint
+  # Internal: A generic error thrown by the lexer when it encounters something
+  # it can't handle.
   class LexerError < StandardError
     # Internal: Get the Integer line number of the location of the error.
     attr_reader :line_no
@@ -18,16 +20,18 @@ class PuppetLint
     #          at when it encountered the error.
     def initialize(code, offset)
       chunk = code[0..offset]
-      @line_no = chunk.count("\n") + 1
+      @line_no = chunk.scan(/(\r\n|\r|\n)/).size + 1
       if @line_no == 1
         @column = chunk.length
       else
-        @column = chunk.length - chunk.rindex("\n") - 1
+        @column = chunk.length - chunk.rindex(/(\r\n|\r|\n)/) - 1
       end
       @column = 1 if @column == 0
     end
   end
 
+  # Internal: The puppet-lint lexer. Converts your manifest into its tokenised
+  # form.
   class Lexer
     # Internal: A Hash whose keys are Strings representing reserved keywords in
     # the Puppet DSL.
@@ -109,6 +113,8 @@ class PuppetLint
       [:QMARK, /\A(\?)/],
       [:BACKSLASH, /\A(\\)/],
       [:TIMES, /\A(\*)/],
+      [:MODULO, /\A(%)/],
+      [:PIPE, /\A(\|)/],
     ]
 
     # Internal: A Hash whose keys are Symbols representing token types which
@@ -138,8 +144,6 @@ class PuppetLint
     # Raises PuppetLint::LexerError if it encounters unexpected characters
     # (usually the result of syntax errors).
     def tokenise(code)
-      code.chomp!
-
       i = 0
 
       while i < code.size
@@ -165,7 +169,7 @@ class PuppetLint
         end
 
         unless found
-          if var_name = chunk[/\A\$((::)?([\w-]+::)*[\w-]+)/, 1]
+          if var_name = chunk[/\A\$((::)?([\w-]+::)*[\w-]+(\[.+?\])*)/, 1]
             tokens << new_token(:VARIABLE, var_name, :chunk => code[0..i])
             i += var_name.size + 1
 
@@ -182,13 +186,13 @@ class PuppetLint
 
           elsif comment = chunk[/\A(#.*)/, 1]
             comment_size = comment.size
-            comment.sub!(/# ?/, '')
+            comment.sub!(/#/, '')
             tokens << new_token(:COMMENT, comment, :chunk => code[0..i])
             i += comment_size
 
           elsif slash_comment = chunk[/\A(\/\/.*)/, 1]
             slash_comment_size = slash_comment.size
-            slash_comment.sub!(/\/\/ ?/, '')
+            slash_comment.sub!(/\/\//, '')
             tokens << new_token(:SLASH_COMMENT, slash_comment, :chunk => code[0..i])
             i += slash_comment_size
 
@@ -206,18 +210,20 @@ class PuppetLint
             tokens << new_token(:REGEX, str_content[0..-2], :chunk => code[0..i])
             i += str_content.size + 1
 
-          elsif indent = chunk[/\A\r?\n([ \t]+)/m, 1]
-            tokens << new_token(:NEWLINE, '\n', :chunk => code[0..i])
-            tokens << new_token(:INDENT, indent, :chunk => code[0..i+1])
-            i += indent.size + 1
+          elsif eolindent = chunk[/\A((\r\n|\r|\n)[ \t]+)/m, 1]
+            eol = eolindent[/\A([\r\n]+)/m, 1]
+            indent = eolindent[/\A[\r\n]+([ \t]+)/m, 1]
+            tokens << new_token(:NEWLINE, eol, :chunk => code[0..i])
+            tokens << new_token(:INDENT, indent, :chunk => code[0..i+eol.size])
+            i += indent.size + eol.size
 
           elsif whitespace = chunk[/\A([ \t]+)/, 1]
             tokens << new_token(:WHITESPACE, whitespace, :chunk => code[0..i])
             i += whitespace.size
 
-          elsif chunk.match(/\A\r?\n/)
-            tokens << new_token(:NEWLINE, '\n', :chunk => code[0..i])
-            i += 1
+          elsif eol = chunk[/\A(\r\n|\r|\n)/, 1]
+            tokens << new_token(:NEWLINE, eol, :chunk => code[0..i])
+            i += eol.size
 
           elsif chunk.match(/\A\//)
             tokens << new_token(:DIV, '/', :chunk => code[0..i])
@@ -265,11 +271,11 @@ class PuppetLint
     # Returns the instantiated PuppetLint::Lexer::Token object.
     def new_token(type, value, opts = {})
       if opts[:chunk]
-        line_no = opts[:chunk].count("\n") + 1
+        line_no = opts[:chunk].scan(/(\r\n|\r|\n)/).size + 1
         if line_no == 1
           column = opts[:chunk].length
         else
-          column = opts[:chunk].length - opts[:chunk].rindex("\n") - 1
+          column = opts[:chunk].length - opts[:chunk].rindex(/(\r\n|\r|\n)/) - 1
         end
         column += 1 if column == 0
       else
@@ -330,7 +336,7 @@ class PuppetLint
             tokens << new_token(:STRING, value, :line => line, :column => column)
             first = false
           else
-            line += value.count("\n")
+            line += value.scan(/(\r\n|\r|\n)/).size
             token_column = column + (ss.pos - value.size)
             tokens << new_token(:DQPOST, value, :line => line, :column => token_column)
           end
@@ -339,29 +345,30 @@ class PuppetLint
             tokens << new_token(:DQPRE, value, :line => line, :column => column)
             first = false
           else
-            line += value.count("\n")
+            line += value.scan(/(\r\n|\r|\n)/).size
             token_column = column + (ss.pos - value.size)
             tokens << new_token(:DQMID, value, :line => line, :column => token_column)
           end
           if ss.scan(/\{/).nil?
             var_name = ss.scan(/(::)?([\w-]+::)*[\w-]+/)
-            unless var_name.nil?
+            if var_name.nil?
+              token_column = column + ss.pos - 1
+              tokens << new_token(:DQMID, "$", :line => line, :column => token_column)
+            else
               token_column = column + (ss.pos - var_name.size)
               tokens << new_token(:UNENC_VARIABLE, var_name, :line => line, :column => token_column)
             end
           else
             contents = ss.scan_until(/\}/)[0..-2]
-            if contents.match(/\A(::)?([\w-]+::)*[\w-]+\Z/)
-              token_column = column + (ss.pos - contents.size - 1)
-              tokens << new_token(:VARIABLE, contents, :line => line, :column => token_column)
-            else
-              lexer = PuppetLint::Lexer.new
-              lexer.tokenise(contents)
-              lexer.tokens.each do |token|
-                tok_col = column + token.column + (ss.pos - contents.size - 1)
-                tok_line = token.line + line - 1
-                tokens << new_token(token.type, token.value, :line => tok_line, :column => tok_col)
-              end
+            if contents.match(/\A(::)?([\w-]+::)*[\w-]+(\[.+?\])*/)
+              contents = "$#{contents}"
+            end
+            lexer = PuppetLint::Lexer.new
+            lexer.tokenise(contents)
+            lexer.tokens.each do |token|
+              tok_col = column + token.column + (ss.pos - contents.size - 1)
+              tok_line = token.line + line - 1
+              tokens << new_token(token.type, token.value, :line => tok_line, :column => tok_col)
             end
           end
         end