puppet-lint 2.0.0 → 2.0.1

data/Gemfile

@@ -1,3 +1,22 @@
 source 'https://rubygems.org'
 
 gemspec
+
+group :test do
+  gem 'rake', '~> 10.0'
+  gem 'rspec', '~> 3.0'
+  gem 'rspec-its', '~> 1.0'
+  gem 'rspec-collection_matchers', '~> 1.0'
+  gem 'rack', '~> 1.0'
+
+  if RUBY_VERSION < '2.0'
+    # json 2.x requires ruby 2.0. Lock to 1.8
+    gem 'json', '~> 1.8'
+    # json_pure 2.0.2 requires ruby 2.0. Lock to 2.0.1
+    gem 'json_pure', '= 2.0.1'
+    # addressable 2.4.0 requires ruby 1.9.0. Lock to 2.3.8.
+    gem 'addressable', '= 2.3.8'
+  else
+    gem 'json'
+  end
+end

data/README.md

@@ -174,6 +174,11 @@ If you find a bug in puppet-lint or its results, please create an issue in the
 [repo issues tracker](https://github.com/rodjek/puppet-lint/issues/).  Bonus
 points will be awarded if you also include a patch that fixes the issue.
 
+## Executing puppet-lint tests suite
+
+    bundle exec rspec [spec/puppet-lint/a_single_test.rb]
+
+
 ## Thank You
 
 Many thanks to the following people for contributing to puppet-lint
@@ -187,7 +192,7 @@ As well as the many people who have reported the issues they've had!
 
 ## License
 
-Copyright (c) 2011 Tim Sharpe
+Copyright (c) 2011-2016 Tim Sharpe
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/puppet-lint.rb

@@ -166,7 +166,7 @@ class PuppetLint
 
     if @code.empty?
       @problems = []
-      @manifest = []
+      @manifest = ''
       return
     end
 

data/lib/puppet-lint/checks.rb

@@ -58,16 +58,12 @@ class PuppetLint::Checks
       problems = klass.run
 
       if PuppetLint.configuration.fix
-        checks_run << klass
+        @problems.concat(klass.fix_problems)
       else
         @problems.concat(problems)
       end
     end
 
-    checks_run.each do |check|
-      @problems.concat(check.fix_problems)
-    end
-
     @problems
   end
 

data/lib/puppet-lint/lexer.rb

@@ -62,6 +62,7 @@ class PuppetLint
       :MATCH   => true,
       :NOMATCH => true,
       :COMMA   => true,
+      :LBRACK  => true,
     }
 
     # Internal: An Array of Arrays containing tokens that can be described by
@@ -69,6 +70,7 @@ class PuppetLint
     # name of the token as a Symbol and a regular expression describing the
     # value of the token.
     KNOWN_TOKENS = [
+      [:TYPE, /\A(Integer|Float|Boolean|Regexp|String|Array|Hash|Resource|Class|Collection|Scalar|Numeric|CatalogEntry|Data|Tuple|Struct|Optional|NotUndef|Variant|Enum|Pattern|Any|Callable|Type|Runtime|Undef|Default)/],
       [:CLASSREF, /\A(((::){0,1}[A-Z][-\w]*)+)/],
       [:NUMBER, /\A\b((?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?))\b/],
       [:NAME, /\A(((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*)/],
@@ -168,7 +170,7 @@ class PuppetLint
         end
 
         unless found
-          if var_name = chunk[/\A\$((::)?([\w-]+::)*[\w-]+(\[.+?\])*)/, 1]
+          if var_name = chunk[/\A\$((::)?([\w]+::)*[\w]+(\[.+?\])*)/, 1]
             length = var_name.size + 1
             tokens << new_token(:VARIABLE, var_name, length)
 
@@ -344,7 +346,7 @@ class PuppetLint
             tokens << new_token(:DQMID, value, value.size, :line => line, :column => token_column)
           end
           if ss.scan(/\{/).nil?
-            var_name = ss.scan(/(::)?([\w-]+::)*[\w-]+/)
+            var_name = ss.scan(/(::)?([\w]+::)*[\w]+/)
             if var_name.nil?
               token_column = column + ss.pos - 1
               tokens << new_token(:DQMID, "$", 1, :line => line, :column => token_column)

data/lib/puppet-lint/optparser.rb

@@ -94,8 +94,12 @@ class PuppetLint::OptParser
 
       opts.on('--only-checks CHECKS', 'A comma separated list of checks that should be run') do |checks|
         enable_checks = checks.split(',').map(&:to_sym)
-        (PuppetLint.configuration.checks - enable_checks).each do |check|
-          PuppetLint.configuration.send("disable_#{check}")
+        (PuppetLint.configuration.checks).each do |check|
+          if enable_checks.include? check
+            PuppetLint.configuration.send("enable_#{check}")
+          else
+            PuppetLint.configuration.send("disable_#{check}")
+          end
         end
       end
 
@@ -103,6 +107,11 @@ class PuppetLint::OptParser
         opts.on("--no-#{check}-check", "Skip the #{check} check.") do
           PuppetLint.configuration.send("disable_#{check}")
         end
+        unless PuppetLint.configuration.send("#{check}_enabled?")
+          opts.on("--#{check}-check", "Enable the #{check} check.") do
+            PuppetLint.configuration.send("enable_#{check}")
+          end
+        end
       end
 
       opts.load('/etc/puppet-lint.rc')

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

@@ -83,13 +83,14 @@ PuppetLint.new_check(:class_inherits_from_params_class) do
     end
   end
 end
+PuppetLint.configuration.send('disable_class_inherits_from_params_class')
 
 # Public: Test the manifest tokens for any parameterised classes or defined
 # types that take parameters and record a warning if there are any optional
 # parameters listed before required parameters.
 PuppetLint.new_check(:parameter_order) do
   def check
-    defined_type_indexes.each do |class_idx|
+    (class_indexes + defined_type_indexes).each do |class_idx|
       unless class_idx[:param_tokens].nil?
         paren_stack = []
         class_idx[:param_tokens].each_with_index do |token, i|
@@ -197,6 +198,9 @@ PuppetLint.new_check(:variable_scope) do
     'stage',
     'subscribe',
     'tag',
+    'facts',
+    'trusted',
+    'server_facts',
   ]
   POST_VAR_TOKENS = Set[:COMMA, :EQUALS, :RPAREN]
 

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

@@ -37,19 +37,17 @@ PuppetLint.new_check(:star_comments) do
 
   def fix(problem)
     comment_lines = problem[:token].value.strip.split("\n").map(&:strip)
+    
     first_line = comment_lines.shift
     problem[:token].type = :COMMENT
     problem[:token].value = " #{first_line}"
 
-    index = tokens.index(problem[:token].next_token)
+    index = tokens.index(problem[:token].next_token) || 1
     comment_lines.reverse.each do |line|
-      [
-        PuppetLint::Lexer::Token.new(:COMMENT, " #{line}", 0, 0),
-        PuppetLint::Lexer::Token.new(:INDENT, problem[:token].prev_token.value.dup, 0, 0),
-        PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0),
-      ].each do |new_token|
-        tokens.insert(index, new_token)
-      end
+      indent = problem[:token].prev_token.nil? ? nil : problem[:token].prev_token.value.dup
+      tokens.insert(index, PuppetLint::Lexer::Token.new(:COMMENT, " #{line}", 0, 0))
+      tokens.insert(index, PuppetLint::Lexer::Token.new(:INDENT, indent, 0, 0)) if indent
+      tokens.insert(index, PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0))
     end
   end
 end

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

@@ -25,6 +25,7 @@ end
 PuppetLint.new_check(:ensure_first_param) do
   def check
     resource_indexes.each do |resource|
+      next if [:CLASS].include? resource[:type].type
       ensure_attr_index = resource[:param_tokens].index { |param_token|
         param_token.value == 'ensure'
       }
@@ -87,7 +88,7 @@ PuppetLint.new_check(:unquoted_file_mode) do
 
   def check
     resource_indexes.each do |resource|
-      if resource[:type].value == "file"
+      if resource[:type].value == "file" or resource[:type].value == "concat"
         resource[:param_tokens].select { |param_token|
           param_token.value == 'mode' &&
             TOKEN_TYPES.include?(param_token.next_code_token.next_code_token.type)
@@ -120,7 +121,7 @@ PuppetLint.new_check(:file_mode) do
 
   def check
     resource_indexes.each do |resource|
-      if resource[:type].value == "file"
+      if resource[:type].value == "file" or resource[:type].value == "concat"
         resource[:param_tokens].select { |param_token|
           param_token.value == 'mode'
         }.each do |param_token|
@@ -184,7 +185,7 @@ PuppetLint.new_check(:ensure_not_symlink_target) do
       PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0),
       PuppetLint::Lexer::Token.new(:INDENT, problem[:param_token].prev_token.value.dup, 0, 0),
       PuppetLint::Lexer::Token.new(:NAME, 'target', 0, 0),
-      PuppetLint::Lexer::Token.new(:WHITESPACE, problem[:param_token].next_token.value.dup, 0, 0),
+      PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', 0, 0),
       PuppetLint::Lexer::Token.new(:FARROW, '=>', 0, 0),
       PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', 0, 0),
     ].reverse.each do |new_token|

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

@@ -1,13 +1,13 @@
 # Public: Test the manifest tokens for variables that contain a dash and
 # record a warning for each instance found.
 PuppetLint.new_check(:variable_contains_dash) do
-  VARIABLE_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
+  VARIABLE_DASH_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
 
   def check
     tokens.select { |r|
-      VARIABLE_TYPES.include? r.type
+      VARIABLE_DASH_TYPES.include? r.type
     }.each do |token|
-      if token.value.gsub(/\[.+?\]/, '').match(/-/)
+      if not token.next_token.nil? and Set[:DQMID, :DQPOST, :MINUS].include? token.next_token.type and token.next_token.value.start_with? '-'
         notify :warning, {
           :message => 'variable contains a dash',
           :line    => token.line,
@@ -17,3 +17,21 @@ PuppetLint.new_check(:variable_contains_dash) do
     end
   end
 end
+
+PuppetLint.new_check(:variable_is_lowercase) do
+  VARIABLE_LOWERCASE_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
+
+  def check
+    tokens.select { |r|
+      VARIABLE_LOWERCASE_TYPES.include? r.type
+    }.each do |token|
+      if token.value.gsub(/\[.+?\]/, '').match(/[A-Z]/)
+        notify :warning, {
+          :message => 'variable contains an uppercase letter',
+          :line    => token.line,
+          :column  => token.column,
+        }
+      end
+    end
+  end
+end

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

@@ -68,6 +68,26 @@ PuppetLint.new_check(:'140chars') do
   end
 end
 
+# Public: Test the raw manifest string for lines containing more than 80
+# characters. This is DISABLED by default and behaves like the default
+# 140chars check by excepting URLs and template() calls.
+PuppetLint.new_check(:'80chars') do
+  def check
+    manifest_lines.each_with_index do |line, idx|
+      unless line =~ /:\/\// || line =~ /template\(/
+        if line.scan(/./mu).size > 80
+          notify :warning, {
+            :message => 'line has more than 80 characters',
+            :line    => idx + 1,
+            :column  => 80,
+          }
+        end
+      end
+    end
+  end
+end
+PuppetLint.configuration.send("disable_80chars")
+
 # Public: Check the manifest tokens for any indentation not using 2 space soft
 # tabs and record an error for each instance found.
 PuppetLint.new_check(:'2sp_soft_tabs') do
@@ -128,7 +148,7 @@ PuppetLint.new_check(:arrow_alignment) do
             unless arrow_tok.column == indent_depth[indent_depth_idx] || level_tokens[indent_depth_idx].size == 1
               arrows_on_line = level_tokens[indent_depth_idx].select { |t| t.line == arrow_tok.line }
               notify :warning, {
-                :message        => 'indentation of => is not properly aligned',
+                :message        => "indentation of => is not properly aligned (expected in column #{indent_depth[indent_depth_idx]}, but found it in column #{arrow_tok.column})",
                 :line           => arrow_tok.line,
                 :column         => arrow_tok.column,
                 :token          => arrow_tok,

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

@@ -78,6 +78,10 @@ class PuppetLint
             linter.file = puppet_file
             linter.run
             linter.print_problems
+
+            if PuppetLint.configuration.fix && !linter.problems.any? { |e| e[:check] == :syntax }
+              IO.write(puppet_file, linter.manifest)
+            end
           end
           abort if linter.errors? || (
             linter.warnings? && PuppetLint.configuration.fail_on_warnings

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/puppet-lint.gemspec

@@ -14,10 +14,7 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rake', '~> 10.0'
-  s.add_development_dependency 'rspec', '~> 3.0'
-  s.add_development_dependency 'rspec-its', '~> 1.0'
-  s.add_development_dependency 'rspec-collection_matchers', '~> 1.0'
+  s.add_development_dependency 'github_changelog_generator'
 
   s.authors = ['Tim Sharpe']
   s.email = 'tim@sharpe.id.au'

data/spec/puppet-lint/bin_spec.rb

@@ -99,7 +99,7 @@ describe PuppetLint::Bin do
 
   context 'when specifying a specific check to run' do
     let(:args) { [
-      '--only-check', 'parameter_order',
+      '--only-checks', 'parameter_order',
       'spec/fixtures/test/manifests/warning.pp',
       'spec/fixtures/test/manifests/fail.pp',
     ] }

data/spec/puppet-lint/lexer_spec.rb

@@ -579,6 +579,32 @@ describe PuppetLint::Lexer do
     end
   end
 
+  context ':TYPE' do
+    it 'should match Data Types' do
+      token = @lexer.tokenise('Integer').first
+      expect(token.type).to eq(:TYPE)
+      expect(token.value).to eq('Integer')
+    end
+
+    it 'should match Catalog Types' do
+      token = @lexer.tokenise('Resource').first
+      expect(token.type).to eq(:TYPE)
+      expect(token.value).to eq('Resource')
+    end
+
+    it 'should match Abstract Types' do
+      token = @lexer.tokenise('Collection').first
+      expect(token.type).to eq(:TYPE)
+      expect(token.value).to eq('Collection')
+    end
+
+    it 'should match Platform Types' do
+      token = @lexer.tokenise('Callable').first
+      expect(token.type).to eq(:TYPE)
+      expect(token.value).to eq('Callable')
+    end
+  end
+
   context ':CLASSREF' do
     it 'should match single capitalised alphanumeric term' do
       token = @lexer.tokenise('One').first
@@ -767,6 +793,18 @@ describe PuppetLint::Lexer do
       expect(token.value).to eq('this is \\/ a regex')
     end
 
+    it 'should be allowed as a param to a data type' do
+      tokens = @lexer.tokenise('Foo[/bar/]')
+      expect(tokens[2].type).to eq(:REGEX)
+      expect(tokens[2].value).to eq('bar')
+    end
+
+    it 'should be allowed as a param to an optional data type' do
+      tokens = @lexer.tokenise('Optional[Regexp[/^puppet/]]')
+      expect(tokens[4].type).to eq(:REGEX)
+      expect(tokens[4].value).to eq('^puppet')
+    end
+
     it 'should not match chained division' do
       tokens = @lexer.tokenise('$x = $a/$b/$c')
       expect(tokens.select { |r| r.type == :REGEX }).to be_empty

data/spec/puppet-lint/plugins/check_classes/parameter_order_spec.rb

@@ -3,71 +3,75 @@ require 'spec_helper'
 describe 'parameter_order' do
   let(:msg) { 'optional parameter listed before required parameter' }
 
-  context 'define with attrs in order' do
-    let(:code) { "define foo($bar, $baz='gronk') { }" }
+  ['define', 'class'].each do |type|
+    context "#{type} with attrs in order" do
+      let(:code) { "#{type} foo($bar, $baz='gronk') { }" }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  context 'define with parameter that calls a function' do
-    let(:code) { "define foo($bar=extlookup($name)) {}" }
+    context "#{type} with parameter that calls a function" do
+      let(:code) { "#{type} foo($bar=extlookup($name)) {}" }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  context 'define with attrs out of order' do
-    let(:code) { "define foo($bar='baz', $gronk) { }" }
+    context "#{type} with attrs out of order" do
+      let(:code) { "#{type} foo($bar='baz', $gronk) { }" }
 
-    it 'should only detect a single problem' do
-      expect(problems).to have(1).problem
-    end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    it 'should create a warning' do
-      expect(problems).to contain_warning(msg).on_line(1).in_column(24)
+      col = (type == "class" ? 23 : 24)
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(col)
+      end
     end
-  end
 
-  context 'class/define parameter set to another variable' do
-    let(:code) { "
-      define foo($bar, $baz = $name, $gronk=$::fqdn) {
-      }"
-    }
+    context "#{type} parameter set to another variable" do
+      let(:code) { "
+        #{type} foo($bar, $baz = $name, $gronk=$::fqdn) {
+        }"
+      }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  context 'class/define parameter set to another variable with incorrect order' do
-    let(:code) { "
-      define foo($baz = $name, $bar, $gronk=$::fqdn) {
-      }"
-    }
+    context "#{type} parameter set to another variable with incorrect order" do
+      let(:code) { "
+        #{type} foo($baz = $name, $bar, $gronk=$::fqdn) {
+        }"
+      }
 
-    it 'should only detect a single problem' do
-      expect(problems).to have(1).problem
-    end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    it 'should create a warning' do
-      expect(problems).to contain_warning(msg).on_line(2).in_column(32)
+      col = (type == "class" ? 33 : 34)
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(2).in_column(col)
+      end
     end
-  end
 
-  context 'issue-101' do
-    let(:code) { "
-      define b (
-        $foo,
-        $bar='',
-        $baz={}
-      ) { }
-    " }
+    context 'issue-101' do
+      let(:code) { "
+        #{type} b (
+          $foo,
+          $bar='',
+          $baz={}
+        ) { }
+      " }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
   end
 end