puppet-lint 0.1.13 → 0.2.0.pre1

data/lib/puppet-lint/plugins/check_strings.rb

@@ -1,106 +1,94 @@
 class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
-  class ::Puppet::Parser::Lexer
-    class TokenList
-      def del_token(token)
-        @tokens.delete(token)
-      end
-    end
-
-    TOKENS.add_tokens("<single quotes string>" => :SSTRING)
-    TOKENS.del_token(:SQUOTE)
-
-    if Puppet::PUPPETVERSION =~ /^0\.2/
-      TOKENS.add_token :SQUOTE, "'" do |lexer, value|
-        value = lexer.slurpstring(value)
-        [TOKENS[:SSTRING], value]
-      end
-    else
-      TOKENS.add_token :SQUOTE, "'" do |lexer, value|
-        [ TOKENS[:SSTRING], lexer.slurpstring(value,["'"],:ignore_invalid_escapes).first ]
-      end
-    end
-  end
-
+  # Public: Check the manifest tokens for any double quoted strings that don't
+  # contain any variables or common escape characters and record a warning for
+  # each instance found.
+  #
+  # Returns nothing.
   check 'double_quoted_strings' do
-    tokens.each_index do |token_idx|
-      token = tokens[token_idx]
-
-      if token.first == :STRING
-        unless token.last[:value].include? "\t" or token.last[:value].include? "\n"
-          notify :warning, :message =>  "double quoted string containing no variables", :linenumber => token.last[:line]
-        end
-      elsif token.first == :DQTEXT
-        unless token.last[:value].include? "\\t" or token.last[:value].include? "\\n" or token.last[:value] =~ /[^\\]?\$\{?/
-          notify :warning, :message =>  "double quoted string containing no variables", :linenumber => token.last[:line]
-        end
-      end
+    tokens.select { |r|
+      r.type == :STRING
+    }.reject { |r|
+      r.value.include?('\t') || r.value.include?('\n')
+    }.each do |token|
+      notify :warning, {
+        :message    => 'double quoted string containing no variables',
+        :linenumber => token.line,
+        :column     => token.column,
+      }
     end
   end
 
+  # Public: Check the manifest tokens for double quoted strings that contain
+  # a single variable only and record a warning for each instance found.
+  #
+  # Returns nothing.
   check 'only_variable_string' do
     tokens.each_index do |token_idx|
       token = tokens[token_idx]
 
-      if token.first == :DQPRE and token.last[:value] == ""
-        if tokens[token_idx + 1].first == :VARIABLE
-          if tokens[token_idx + 2].first == :DQPOST and tokens[token_idx + 2].last[:value] == ""
-            notify :warning, :message =>  "string containing only a variable", :linenumber => tokens[token_idx + 1].last[:line]
+      if token.type == :DQPRE and token.value == ''
+        if [:VARIABLE, :UNENC_VARIABLE].include? tokens[token_idx + 1].type
+          if tokens[token_idx + 2].type == :DQPOST
+            if tokens[token_idx + 2].value == ''
+              notify :warning, {
+                :message    => 'string containing only a variable',
+                :linenumber => tokens[token_idx + 1].line,
+                :column     => tokens[token_idx + 1].column,
+              }
+            end
           end
         end
       end
-      if token.first == :DQTEXT and token.last[:value] =~ /\A\$\{.+\}\Z/
-        notify :warning, :message =>  "string containing only a variable", :linenumber => token.last[:line]
-      end
     end
   end
 
+  # Public: Check the manifest tokens for any variables in a string that have
+  # not been enclosed by braces ({}) and record a warning for each instance
+  # found.
+  #
+  # Returns nothing.
   check 'variables_not_enclosed' do
-    tokens.each_index do |token_idx|
-      token = tokens[token_idx]
-
-      if token.first == :DQPRE
-        end_of_string_idx = tokens[token_idx..-1].index { |r| r.first == :DQPOST }
-        tokens[token_idx..end_of_string_idx].each do |t|
-          if t.first == :VARIABLE
-            line = data.split("\n")[t.last[:line] - 1]
-            if line.is_a? String and line.include? "$#{t.last[:value]}"
-              notify :warning, :message =>  "variable not enclosed in {}", :linenumber => t.last[:line]
-            end
-          end
-        end
-      elsif token.first == :DQTEXT and token.last[:value] =~ /\$\w+/
-        notify :warning, :message =>  "variable not enclosed in {}", :linenumber => token.last[:line]
-      end
+    tokens.select { |r|
+      r.type == :UNENC_VARIABLE
+    }.each do |token|
+      notify :warning, {
+        :message    => 'variable not enclosed in {}',
+        :linenumber => token.line,
+        :column     => token.column,
+      }
     end
   end
 
+  # Public: Check the manifest tokens for any single quoted strings containing
+  # a enclosed variable and record an error for each instance found.
+  #
+  # Returns nothing.
   check 'single_quote_string_with_variables' do
-    tokens.each_index do |token_idx|
-      token = tokens[token_idx]
-
-      if token.first == :SSTRING
-        contents = token.last[:value]
-        line_no = token.last[:line]
-
-        if contents.include? '${'
-          notify :error, :message =>  "single quoted string containing a variable found", :linenumber => token.last[:line]
-        end
-      end
+    tokens.select { |r|
+      r.type == :SSTRING && r.value.include?('${')
+    }.each do |token|
+      notify :error, {
+        :message    => 'single quoted string containing a variable found',
+        :linenumber => token.line,
+        :column     => token.column,
+      }
     end
   end
 
+  # Public: Check the manifest tokens for any double or single quoted strings
+  # containing only a boolean value and record a warning for each instance
+  # found.
+  #
+  # Returns nothing.
   check 'quoted_booleans' do
-    tokens.each_index do |token_idx|
-      token = tokens[token_idx]
-
-      if token.first == :SSTRING
-        contents = token.last[:value]
-        line_no = token.last[:line]
-
-        if ['true', 'false'].include? contents
-          notify :warning, :message =>  "quoted boolean value found", :linenumber => token.last[:line]
-        end
-      end
+    tokens.select { |r|
+      [:STRING, :SSTRING].include?(r.type) && %w{true false}.include?(r.value)
+    }.each do |token|
+      notify :warning, {
+        :message    => 'quoted boolean value found',
+        :linenumber => token.line,
+        :column     => token.column,
+      }
     end
   end
 end

data/lib/puppet-lint/plugins/check_variables.rb

@@ -1,23 +1,18 @@
 class PuppetLint::Plugins::CheckVariables < PuppetLint::CheckPlugin
+  # Public: Test the manifest tokens for variables that contain a dash and
+  # record a warning for each instance found.
+  #
+  # Returns nothing.
   check 'variable_contains_dash' do
-    tokens.each_index do |token_idx|
-      token = tokens[token_idx]
-
-      if token.first == :VARIABLE
-        variable = token.last[:value]
-        line_no = token.last[:line]
-        if variable.match(/-/)
-          notify :warning, :message =>  "variable contains a dash", :linenumber => line_no
-        end
-      end
-
-      if token.first == :DQPRE
-        end_of_string_idx = tokens[token_idx..-1].index { |r| r.first == :DQPOST }
-        tokens[token_idx..end_of_string_idx].each do |t|
-          if t.first == :VARIABLE and t.last[:value].match(/-/)
-            notify :warning, :message =>  "variable contains a dash", :linenumber => t.last[:line]
-          end
-        end
+    tokens.select { |r|
+      [:VARIABLE, :UNENC_VARIABLE].include? r.type
+    }.each do |token|
+      if token.value.match(/-/)
+        notify :warning, {
+          :message    => 'variable contains a dash',
+          :linenumber => token.line,
+          :column     => token.column,
+        }
       end
     end
   end

data/lib/puppet-lint/plugins/check_whitespace.rb

@@ -1,61 +1,83 @@
-# Spacing, Identation & Whitespace
-# http://docs.puppetlabs.com/guides/style_guide.html#spacing-indentation--whitespace
-
 class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
+  # Check the raw manifest string for lines containing hard tab characters and
+  # record an error for each instance found.
+  #
+  # Returns nothing.
   check 'hard_tabs' do
-    line_no = 0
-    manifest_lines.each do |line|
-      line_no += 1
-
-      # MUST NOT use literal tab characters
-      notify :error, :message =>  "tab character found", :linenumber => line_no if line.include? "\t"
+    manifest_lines.each_with_index do |line, idx|
+      if line.include? "\t"
+        notify :error, {
+          :message    => 'tab character found',
+          :linenumber => idx + 1,
+          :column     => line.index("\t") + 1,
+        }
+      end
     end
   end
 
+  # Check the raw manifest string for lines ending with whitespace and record
+  # an error for each instance found.
+  #
+  # Returns nothing.
   check 'trailing_whitespace' do
-    line_no = 0
-    manifest_lines.each do |line|
-      line_no += 1
-
-      # MUST NOT contain trailing white space
-      notify :error, :message =>  "trailing whitespace found", :linenumber => line_no if line.end_with? " "
+    manifest_lines.each_with_index do |line, idx|
+      if line.end_with? ' '
+        notify :error, {
+          :message    => 'trailing whitespace found',
+          :linenumber => idx + 1,
+          :column     => line.rindex(' ') + 1,
+        }
+      end
     end
   end
 
+  # Test the raw manifest string for lines containing more than 80 characters
+  # and record a warning for each instance found.  The only exception to this
+  # rule is lines containing puppet:// URLs which would hurt readability if
+  # split.
+  #
+  # Returns nothing.
   check '80chars' do
-    line_no = 0
-    manifest_lines.each do |line|
-      line_no += 1
-
-      # SHOULD NOT exceed an 80 character line width
+    manifest_lines.each_with_index do |line, idx|
       unless line =~ /puppet:\/\//
-        notify :warning, :message =>  "line has more than 80 characters", :linenumber => line_no if line.length > 80
+        if line.scan(/./mu).size > 80
+          notify :warning, {
+            :message    => 'line has more than 80 characters',
+            :linenumber => idx + 1,
+            :column     => 80,
+          }
+        end
       end
     end
   end
 
+  # Check the manifest tokens for any indentation not using 2 space soft tabs
+  # and record an error for each instance found.
+  #
+  # Returns nothing.
   check '2sp_soft_tabs' do
-    line_no = 0
-    manifest_lines.each do |line|
-      line_no += 1
-
-      # MUST use two-space soft tabs
-      line.scan(/^ +/) do |prefix|
-        unless prefix.length % 2 == 0
-          notify :error, :message =>  "two-space soft tabs not used", :linenumber => line_no
-        end
-      end
+    tokens.select { |r|
+      r.type == :INDENT
+    }.reject { |r|
+      r.value.length % 2 == 0
+    }.each do |token|
+      notify :error, {
+        :message    => 'two-space soft tabs not used',
+        :linenumber => token.line,
+        :column     => token.column,
+      }
     end
   end
 
+  # Check the raw manifest strings for any arrows (=>) in a grouping ({}) that
+  # are not aligned with other arrows in that grouping.
+  #
+  # Returns nothing.
   check 'arrow_alignment' do
-    line_no = 0
     in_resource = false
     selectors = []
     resource_indent_length = 0
-    manifest_lines.each do |line|
-      line_no += 1
-
+    manifest_lines.each_with_index do |line, idx|
       # SHOULD align fat comma arrows (=>) within blocks of attributes
       if line =~ /^( +.+? +)=>/
         line_indent = $1
@@ -67,28 +89,36 @@ class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
 
             # check for length first
             unless line_indent.length == selectors.last
-              notify :warning, :message =>  "=> on line isn't properly aligned for selector", :linenumber => line_no
+              notify :warning, {
+                :message    => '=> is not properly aligned for selector',
+                :linenumber => idx + 1,
+                :column     => line_indent.length,
+              }
             end
 
             # then for a new selector or selector finish
-            if line.strip.end_with? "{"
+            if line.strip.end_with? '{'
               selectors.push(0)
             elsif line.strip =~ /\}[,;]?$/
               selectors.pop
             end
           else
             unless line_indent.length == resource_indent_length
-              notify :warning, :message =>  "=> on line isn't properly aligned for resource", :linenumber => line_no
+              notify :warning, {
+                :message    => '=> is not properly aligned for resource',
+                :linenumber => idx + 1,
+                :column     => line_indent.length,
+              }
             end
 
-            if line.strip.end_with? "{"
+            if line.strip.end_with? '{'
               selectors.push(0)
             end
           end
         else
           resource_indent_length = line_indent.length
           in_resource = true
-          if line.strip.end_with? "{"
+          if line.strip.end_with? '{'
             selectors.push(0)
           end
         end

data/lib/puppet-lint/tasks/puppet-lint.rb

@@ -9,13 +9,21 @@ class PuppetLint
 
       task :lint do
         RakeFileUtils.send(:verbose, true) do
-          linter =  PuppetLint.new
-          Dir.glob('**/*.pp').each do |puppet_file|
+          linter = PuppetLint.new
+          matched_files = FileList['**/*.pp']
+
+          if ignore_paths = PuppetLint.configuration.ignore_paths
+            matched_files = matched_files.exclude(*ignore_paths)
+          end
+
+          matched_files.to_a.each do |puppet_file|
             puts "Evaluating #{puppet_file}"
             linter.file = puppet_file
             linter.run
           end
-          fail if linter.errors?
+          fail if linter.errors? || (
+            linter.warnings? && PuppetLint.configuration.fail_on_warnings
+          )
         end
       end
     end

data/lib/puppet-lint/version.rb

@@ -0,0 +1,3 @@
+class PuppetLint
+  VERSION = '0.2.0.pre1'
+end

data/puppet-lint.gemspec

@@ -1,39 +1,18 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'puppet-lint/version'
+
 Gem::Specification.new do |s|
   s.name = 'puppet-lint'
-  s.version = '0.1.13'
+  s.version = PuppetLint::VERSION
   s.homepage = 'https://github.com/rodjek/puppet-lint/'
   s.summary = 'Ensure your Puppet manifests conform with the Puppetlabs style guide'
   s.description = 'Checks your Puppet manifests against the Puppetlabs
   style guide and alerts you to any discrepancies.'
 
-  s.executables = ['puppet-lint']
-  s.files = [
-    '.travis.yml',
-    'bin/puppet-lint',
-    'Gemfile',
-    'lib/puppet-lint/configuration.rb',
-    'lib/puppet-lint/plugin.rb',
-    'lib/puppet-lint/plugins/check_classes.rb',
-    'lib/puppet-lint/plugins/check_conditionals.rb',
-    'lib/puppet-lint/plugins/check_resources.rb',
-    'lib/puppet-lint/plugins/check_strings.rb',
-    'lib/puppet-lint/plugins/check_variables.rb',
-    'lib/puppet-lint/plugins/check_whitespace.rb',
-    'lib/puppet-lint/plugins.rb',
-    'lib/puppet-lint/tasks/puppet-lint.rb',
-    'lib/puppet-lint.rb',
-    'LICENSE',
-    'puppet-lint.gemspec',
-    'Rakefile',
-    'README.md',
-    'spec/puppet-lint/check_classes_spec.rb',
-    'spec/puppet-lint/check_conditionals_spec.rb',
-    'spec/puppet-lint/check_resources_spec.rb',
-    'spec/puppet-lint/check_strings_spec.rb',
-    'spec/puppet-lint/check_variables_spec.rb',
-    'spec/puppet-lint/check_whitespace_spec.rb',
-    'spec/spec_helper.rb',
-  ]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
 
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'rdoc'