puppet-lint 0.1.13 → 0.2.0.pre1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle/
+.rbenv-version
+Gemfile.lock
+vendor/gems

data/README.md

@@ -112,7 +112,7 @@ ERROR: mymodule::myclass not in autoload module layout on line X
 
 Puppet attempts to autoload only the required manifests for the resources and
 classes specified in your manifests.  In order to do this, the autoloader
-expects your manifests to be layed out on disk in a particular format.  For
+expects your manifests to be laid out on disk in a particular format.  For
 example, when you use `mymodule::myclass` in your manifests, Puppet will
 attempt to read `<modulepath>/mymodule/manifests/myclass.pp`.  The only
 exception to this is when you reference `mymodule` itself (without any
@@ -230,11 +230,11 @@ Placeholder
 ### puppet-lint
 
 You can disable any of the checks when running the `puppet-lint` command by
-adding a `--disable-<check name>` flag to the command.  For example, if you
+adding a `--no-<check name>-check` flag to the command.  For example, if you
 wanted to skip the 80 character check, you would run
 
 ```
-puppet-lint --disable-80chars /path/to/my/manifest.pp
+puppet-lint --no-80chars-check /path/to/my/manifest.pp
 ```
 
 puppet-lint will also check for a `.puppet-lintrc` file in the current
@@ -243,9 +243,16 @@ wanted to always skip the hard tab character check, you could create
 `~./puppet-lintrc` containing
 
 ```
---disable-hard_tabs
+--no-hard_tabs-check
 ```
 
+For a list of all the flags just type:
+
+```
+puppet-lint --help
+```
+
+
 ### Rake task
 
 You can also disable checks when running puppet-lint through the supplied Rake
@@ -253,7 +260,7 @@ task.  Simply add the following line after the `require` statement in your
 `Rakefile`.
 
 ``` ruby
-PuppetLint.configuration.send("disable_<check name")
+PuppetLint.configuration.send("disable_<check name>")
 ```
 
 So, to disable the 80 character check, you would add:
@@ -262,6 +269,13 @@ So, to disable the 80 character check, you would add:
 PuppetLint.configuration.send("disable_80chars")
 ```
 
+The Rake task also supports ignoring certain paths
+from being linted:
+
+``` ruby
+PuppetLint.configuration.ignore_paths = ["vendor/**/*.pp"]
+```
+
 ## Reporting bugs or incorrect results
 
 If you find a bug in puppet-lint or its results, please create an issue in the

data/bin/puppet-lint

@@ -84,6 +84,8 @@ begin
   if File.directory?(path)
     Dir.chdir(path)
     path = Dir.glob('**/*.pp')
+  else
+    path = [path]
   end
 
   path.each do |f|

data/lib/puppet-lint.rb

@@ -1,12 +1,5 @@
-# We're doing this instead of a gem dependency so folks using Puppet
-# from their distro packages don't have to install the gem.
-begin
-  require 'puppet'
-rescue LoadError
-  puts 'Unable to require puppet.  Please gem install puppet and try again.'
-  exit 1
-end
-
+require 'puppet-lint/version'
+require 'puppet-lint/lexer'
 require 'puppet-lint/configuration'
 require 'puppet-lint/plugin'
 
@@ -74,8 +67,6 @@ end
 class PuppetLint::NoCodeError < StandardError; end
 
 class PuppetLint
-  VERSION = '0.1.12'
-
   attr_reader :code, :file
 
   def initialize

data/lib/puppet-lint/configuration.rb

@@ -53,5 +53,9 @@ class PuppetLint
         method[0..-10]
       }
     end
+
+    def self.ignore_paths
+      settings[:ignore_paths] ||= []
+    end
   end
 end

data/lib/puppet-lint/lexer.rb

@@ -0,0 +1,244 @@
+require 'pp'
+require 'strscan'
+
+class PuppetLint
+  class Lexer
+    KEYWORDS = [
+      'class',
+      'case',
+      'default',
+      'define',
+      'import',
+      'if',
+      'else',
+      'elsif',
+      'inherits',
+      'node',
+      'and',
+      'or',
+      'undef',
+      'true',
+      'false',
+      'in',
+      'unless',
+    ]
+
+    KNOWN_TOKENS = [
+      [:CLASSREF, /\A(((::){0,1}[A-Z][-\w]*)+)/],
+      [:NUMBER, /\A(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b/],
+      [:NAME, /\A(((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*)/],
+      [:LBRACK, /\A(\[)/],
+      [:RBRACK, /\A(\])/],
+      [:LBRACE, /\A(\{)/],
+      [:RBRACE, /\A(\})/],
+      [:LPAREN, /\A(\()/],
+      [:RPAREN, /\A(\))/],
+      [:ISEQUAL, /\A(==)/],
+      [:MATCH, /\A(=~)/],
+      [:FARROW, /\A(=>)/],
+      [:EQUALS, /\A(=)/],
+      [:APPENDS, /\A(\+=)/],
+      [:PARROW, /\A(\+>)/],
+      [:PLUS, /\A(\+)/],
+      [:GREATEREQUAL, /\A(>=)/],
+      [:RSHIFT, /\A(>>)/],
+      [:GREATERTHAN, /\A(>)/],
+      [:LESSEQUAL, /\A(<=)/],
+      [:LLCOLLECT, /\A(<<\|)/],
+      [:OUT_EDGE, /\A(<-)/],
+      [:OUT_EDGE_SUB, /\A(<~)/],
+      [:LCOLLECT, /\A(<\|)/],
+      [:LSHIFT, /\A(<<)/],
+      [:LESSTHAN, /\A(<)/],
+      [:NOMATCH, /\A(!~)/],
+      [:NOTEQUAL, /\A(!=)/],
+      [:NOT, /\A(!)/],
+      [:RRCOLLECT, /\A(\|>>)/],
+      [:RCOLLECT, /\A(\|>)/],
+      [:IN_EDGE, /\A(->)/],
+      [:IN_EDGE_SUB, /\A(~>)/],
+      [:MINUS, /\A(-)/],
+      [:COMMA, /\A(,)/],
+      [:DOT, /\A(\.)/],
+      [:COLON, /\A(:)/],
+      [:AT, /\A(@)/],
+      [:SEMIC, /\A(;)/],
+      [:QMARK, /\A(\?)/],
+      [:BACKSLASH, /\A(\\)/],
+      [:DIV, /\A(\/)/],
+      [:TIMES, /\A(\*)/],
+    ]
+
+    def tokens
+      @tokens ||= []
+    end
+
+    def tokenise(code)
+      code.chomp!
+
+      i = 0
+
+      while i < code.size
+        chunk = code[i..-1]
+
+        found = false
+
+        KNOWN_TOKENS.each do |type, regex|
+          if value = chunk[regex, 1]
+            if type == :NAME
+              if KEYWORDS.include? value
+                tokens << new_token(value.upcase.to_sym, value, code[0..i])
+              else
+                tokens << new_token(type, value, code[0..i])
+              end
+            else
+              tokens << new_token(type, value, code[0..i])
+            end
+            i += value.size
+            found = true
+            break
+          end
+        end
+
+        unless found
+          if identifier = chunk[/\A([a-z]\w*)/, 1]
+            tokens << new_token(:IDENTIFIER, identifier, code[0..i])
+            i += identifier.size
+
+          elsif var_name = chunk[/\A\$((::)?([\w-]+::)*[\w-]+)/, 1]
+            tokens << new_token(:VARIABLE, var_name, code[0..i])
+            i += var_name.size + 1
+
+          elsif sstring = chunk[/\A'(.*?)'/, 1]
+            tokens << new_token(:SSTRING, sstring, code[0..i])
+            i += sstring.size + 2
+
+          elsif chunk.match(/\A"/)
+            str_contents = StringScanner.new(code[i+1..-1]).scan_until(/[^\\]"/m)
+            _ = code[0..i].split("\n")
+            interpolate_string(str_contents, _.count, _.last.length)
+            i += str_contents.size + 1
+
+          elsif chunk.match(/\A\//)
+            str_content = StringScanner.new(code[i+1..-1]).scan_until(/[^\\]\//m)
+            tokens << new_token(:REGEX, str_content, code[0..i])
+            i += str_content.size + 1
+
+          elsif comment = chunk[/\A(#.*)/, 1]
+            comment_size = comment.size
+            comment.sub!(/# ?/, '')
+            tokens << new_token(:COMMENT, comment, code[0..i])
+            i += comment_size
+
+          elsif slash_comment = chunk[/\A(\/\/.*)/, 1]
+            slash_comment_size = slash_comment.size
+            slash_comment.sub!(/\/\/ ?/, '')
+            tokens << new_token(:SLASH_COMMENT, slash_comment, code[0..i])
+            i += slash_comment_size
+
+          elsif mlcomment = chunk[/\A(\/\*.*?\*\/)/m, 1]
+            mlcomment_size = mlcomment_size
+            mlcomment.sub!(/^\/\* ?/, '')
+            mlcomment.sub!(/ ?\*\/$/, '')
+            tokens << new_token(:MLCOMMENT, mlcomment, code[0..i])
+            i += mlcomment_size
+
+          elsif indent = chunk[/\A\n([ \t]+)/m, 1]
+            tokens << new_token(:NEWLINE, '\n', code[0..i])
+            tokens << new_token(:INDENT, indent, code[0..i+1])
+            i += indent.size + 1
+
+          elsif whitespace = chunk[/\A([ \t]+)/, 1]
+            tokens << new_token(:WHITESPACE, whitespace, code[0..i])
+            i += whitespace.size
+
+          elsif chunk.match(/\A\n/)
+            tokens << new_token(:NEWLINE, '\n', code[0..i])
+            i += 1
+
+          else
+            value = chunk[0,1]
+            tokens << new_token(value, value, code[0..i])
+            i += 1
+          end
+        end
+      end
+
+      tokens
+    end
+
+    def new_token(type, value, chunk)
+      lines = chunk.split("\n")
+      line_no = lines.empty? ? 1 : lines.count
+      column = lines.empty? ? 1 : lines.last.length
+
+      PuppetLint::Token.new(type, value, line_no, column)
+    end
+
+    def get_string_segment(string, terminators)
+      str = string.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/)
+      begin
+        [str[0..-2], str[-1,1]]
+      rescue
+        [nil, nil]
+      end
+    end
+
+    def interpolate_string(string, line, column)
+      ss = StringScanner.new(string)
+      first = true
+      value, terminator = get_string_segment(ss, '"$')
+      until value.nil?
+        if terminator == "\""
+          if first
+            tokens << PuppetLint::Token.new(:STRING, value, line, column) 
+            first = false
+          else
+            line += value.count("\n")
+            token_column = column + (ss.pos - value.size)
+            tokens << PuppetLint::Token.new(:DQPOST, value, line, token_column)
+          end
+        else
+          if first
+            tokens << PuppetLint::Token.new(:DQPRE, value, line, column)
+            first = false
+          else
+            line += value.count("\n")
+            token_column = column + (ss.pos - value.size)
+            tokens << PuppetLint::Token.new(:DQMID, value, line, token_column)
+          end
+          if ss.scan(/\{/).nil?
+            var_name = ss.scan(/(::)?([\w-]+::)*[\w-]+/)
+            unless var_name.nil?
+              token_column = column + (ss.pos - var_name.size)
+              tokens << PuppetLint::Token.new(:UNENC_VARIABLE, var_name, line, token_column)
+            end
+          else
+            var_name = ss.scan(/(::)?([\w-]+::)*[\w-]+/)
+            unless var_name.nil?
+              token_column = column + (ss.pos - var_name.size)
+              tokens << PuppetLint::Token.new(:VARIABLE, var_name, line, token_column)
+              ss.scan(/\}/)
+            end
+          end
+        end
+        value, terminator = get_string_segment(ss, '"$')
+      end
+    end
+  end
+
+  class Token
+    attr_reader :type, :value, :line, :column
+
+    def initialize(type, value, line, column)
+      @value = value
+      @type = type
+      @line = line
+      @column = column
+    end
+
+    def inspect
+      "<Token #{@type.inspect} (#{@value}) @#{@line}:#{@column}>"
+    end
+  end
+end

data/lib/puppet-lint/plugin.rb

@@ -54,9 +54,8 @@ class PuppetLint::CheckPlugin
   end
 
   def run(fileinfo, data)
-    lexer = Puppet::Parser::Lexer.new
-    lexer.string = data
-    @tokens = lexer.fullscan
+    lexer = PuppetLint::Lexer.new
+    @tokens = lexer.tokenise(data)
     @fileinfo = fileinfo
     @data = data
 
@@ -71,49 +70,6 @@ class PuppetLint::CheckPlugin
     @problems
   end
 
-  def filter_tokens
-    @title_tokens = []
-    @resource_indexes = []
-    @class_indexes = []
-    @defined_type_indexes = []
-
-    @tokens.each_index do |token_idx|
-      if @tokens[token_idx].first == :COLON
-        # gather a list of tokens that are resource titles
-        if @tokens[token_idx-1].first == :RBRACK
-          title_array_tokens = @tokens[@tokens.rindex { |r| r.first == :LBRACK }+1..token_idx-2]
-          @title_tokens += title_array_tokens.select { |token| [:STRING, :NAME].include? token.first }
-        else
-          if @tokens[token_idx + 1].first != :LBRACE
-            @title_tokens << @tokens[token_idx-1]
-          end
-        end
-
-        # gather a list of start and end indexes for resource attribute blocks
-        if @tokens[token_idx+1].first != :LBRACE
-          @resource_indexes << {:start => token_idx+1, :end => @tokens[token_idx+1..-1].index { |r| [:SEMIC, :RBRACE].include? r.first }+token_idx}
-        end
-      elsif [:CLASS, :DEFINE].include? @tokens[token_idx].first
-        lbrace_count = 0
-        @tokens[token_idx+1..-1].each_index do |class_token_idx|
-          idx = class_token_idx + token_idx
-          if @tokens[idx].first == :LBRACE
-            lbrace_count += 1
-          elsif @tokens[idx].first == :RBRACE
-            lbrace_count -= 1
-            if lbrace_count == 0
-              if @tokens[token_idx].first == :CLASS and @tokens[token_idx + 1].first != :LBRACE
-                @class_indexes << {:start => token_idx, :end => idx}
-              end
-              @defined_type_indexes << {:start => token_idx, :end => idx} if @tokens[token_idx].first == :DEFINE
-              break
-            end
-          end
-        end
-      end
-    end
-  end
-
   def tokens
     @tokens
   end
@@ -131,23 +87,138 @@ class PuppetLint::CheckPlugin
   end
 
   def title_tokens
-    filter_tokens if @title_tokens.nil?
-    @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, :NAME].include? token.type
+            }
+          else
+            if tokens[token_idx + 1].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 declaration, they do not include resource types or
+  # titles/namevars.
+  #
+  # Returns an Array of Hashes, each containing:
+  #   :start - An Integer position in the `tokens` Array pointing to the first
+  #            Token of a resource declaration parameters (type :NAME).
+  #   :end   - An Integer position in the `tokens` Array pointing to the last
+  #            Token of a resource declaration parameters (type :RBRACE).
   def resource_indexes
-    filter_tokens if @resource_indexes.nil?
-    @resource_indexes
+    @resource_indexes ||= Proc.new do
+      result = []
+      tokens.each_index do |token_idx|
+        if tokens[token_idx].type == :COLON
+          next_tokens = tokens[(token_idx + 1)..-1].reject { |r|
+            formatting_tokens.include? r.type
+          }
+          if next_tokens.first.type != :LBRACE
+            end_idx = tokens[(token_idx + 1)..-1].index { |r|
+              [:SEMIC, :RBRACE].include? r.type
+            } + token_idx
+
+            result << {:start => token_idx + 1, :end => end_idx}
+          end
+        end
+      end
+      result
+    end.call
   end
 
+  # Internal: Calculate the positions of all class definitions within the
+  # tokenised manifest.
+  #
+  # Returns an Array of Hashes, each containing:
+  #   :start - An Integer position in the `tokens` Array pointing to the first
+  #            token of a class (type :CLASS).
+  #   :end   - An Integer position in the `tokens` Array pointing to the last
+  #            token of a class (type :RBRACE).
   def class_indexes
-    filter_tokens if @class_indexes.nil?
-    @class_indexes
+    @class_indexes ||= Proc.new do
+      result = []
+      tokens.each_index do |token_idx|
+        if tokens[token_idx].type == :CLASS
+          depth = 0
+          tokens[token_idx+1..-1].each_index do |class_token_idx|
+            idx = class_token_idx + token_idx + 1
+            if tokens[idx].type == :LBRACE
+              depth += 1
+            elsif tokens[idx].type == :RBRACE
+              depth -= 1
+              if depth == 0
+                if tokens[token_idx..-1].reject { |r|
+                  r.type == :WHITESPACE
+                }[1].type != :LBRACE
+                  result << {:start => token_idx, :end => idx}
+                end
+                break
+              end
+            end
+          end
+        end
+      end
+      result
+    end.call
   end
 
+  # Internal: Calculate the positions of all defined type definitions within
+  # the tokenised manifest.
+  #
+  # Returns an Array of Hashes, each containing:
+  #   :start - An Integer position in the `tokens` Array pointing to the first
+  #            token of a defined type (type :DEFINE).
+  #   :end   - An Integer position in the `tokens` Array pointing to the last
+  #            token of a defined type (type :RBRACE).
   def defined_type_indexes
-    filter_tokens if @defined_type_indexes.nil?
-    @defined_type_indexes
+    @defined_type_indexes ||= Proc.new do
+      result = []
+      tokens.each_index do |token_idx|
+        if tokens[token_idx].type == :DEFINE
+          depth = 0
+          tokens[token_idx+1..-1].each_index do |define_token_idx|
+            idx = define_token_idx + token_idx + 1
+            if tokens[idx].type == :LBRACE
+              depth += 1
+            elsif tokens[idx].type == :RBRACE
+              depth -= 1
+              if depth == 0
+                result << {:start => token_idx, :end => idx}
+                break
+              end
+            end
+          end
+        end
+      end
+      result
+    end.call
+  end
+
+  def formatting_tokens
+    [
+      :COMMENT,
+      :MLCOMMENT,
+      :SLASH_COMENT,
+      :INDENT,
+      :WHITESPACE,
+      :NEWLINE,
+    ]
   end
 
   def manifest_lines