halyard-puppet-lint 1.2.0

data/lib/puppet-lint/monkeypatches.rb

@@ -0,0 +1,2 @@
+require 'puppet-lint/monkeypatches/string_prepend'
+require 'puppet-lint/monkeypatches/string_percent'

data/lib/puppet-lint/monkeypatches/string_percent.rb

@@ -0,0 +1,52 @@
+# If we are using an older ruby version, we back-port the basic functionality
+# we need for formatting output: 'somestring' % <hash>
+begin
+  if ('%{test}' % {:test => 'replaced'} == 'replaced')
+    # If this works, we are all good to go.
+  end
+rescue
+  # If the test failed (threw a error), monkeypatch String.
+  # Most of this code came from http://www.ruby-forum.com/topic/144310 but was
+  # simplified for our use.
+
+  # Basic implementation of 'string' % { } like we need it. needs work.
+  class String
+    Percent = instance_method '%' unless defined? Percent
+    def % *a, &b
+      a.flatten!
+
+      string = case a.last
+      when Hash
+        expand a.pop
+      else
+        self
+      end
+
+      if a.empty?
+        string
+      else
+        Percent.bind(string).call(a, &b)
+      end
+
+    end
+    def expand! vars = {}
+      loop do
+        changed = false
+        vars.each do |var, value|
+          var = var.to_s
+          var.gsub! %r/[^a-zA-Z0-9_]/, ''
+          [
+            %r/\%\{#{ var }\}/,
+          ].each do |pat|
+            changed = gsub! pat, "#{ value }"
+          end
+        end
+        break unless changed
+      end
+      self
+    end
+    def expand opts = {}
+      dup.expand! opts
+    end
+  end
+end

data/lib/puppet-lint/monkeypatches/string_prepend.rb

@@ -0,0 +1,13 @@
+unless String.respond_to?('prepend')
+  # Internal: Monkey patching String.
+  class String
+    # Internal: Prepends a String to self.
+    #
+    # lead - The String to prepend self with.
+    #
+    # Returns a String which is lead and self concatenated.
+    def prepend(lead)
+      self.replace "#{lead}#{self}"
+    end
+  end
+end

data/lib/puppet-lint/optparser.rb

@@ -0,0 +1,118 @@
+require 'optparse'
+
+# Public: Contains the puppet-lint option parser so that it can be used easily
+# in multiple places.
+class PuppetLint::OptParser
+  HELP_TEXT = <<-EOF
+    puppet-lint
+
+    Basic Command Line Usage:
+      puppet-lint [OPTIONS] PATH
+
+            PATH                         The path to the Puppet manifest.
+
+    Option:
+  EOF
+
+  # Public: Initialise a new puppet-lint OptionParser.
+  #
+  # Returns an OptionParser object.
+  def self.build
+    OptionParser.new do |opts|
+      opts.banner = HELP_TEXT
+
+      opts.on('--version', 'Display the current version.') do
+        PuppetLint.configuration.display_version = true
+      end
+
+      opts.on('-c', '--config FILE', 'Load puppet-lint options from file.') do |file|
+        opts.load(file)
+      end
+
+      opts.on('--with-context', 'Show where in the manifest the problem is.') do
+        PuppetLint.configuration.with_context = true
+      end
+
+      opts.on('--with-filename', 'Display the filename before the warning.') do
+        PuppetLint.configuration.with_filename = true
+      end
+
+      opts.on('--fail-on-warnings', 'Return a non-zero exit status for warnings') do
+        PuppetLint.configuration.fail_on_warnings = true
+      end
+
+      opts.on('--error-level LEVEL', [:all, :warning, :error],
+              'The level of error to return (warning, error or all).') do |el|
+        PuppetLint.configuration.error_level = el
+      end
+
+      opts.on('--show-ignored', 'Show problems that have been ignored by control comments') do
+        PuppetLint.configuration.show_ignored = true
+      end
+
+      opts.on('--relative', 'Compare module layout relative to the module root') do
+        PuppetLint.configuration.relative = true
+      end
+
+      opts.on('-l', '--load FILE', 'Load a file containing custom puppet-lint checks.') do |f|
+        load f
+      end
+
+      opts.on('--load-from-puppet MODULEPATH', 'Load plugins from the given Puppet module path.') do |path|
+        path.split(':').each do |p|
+          Dir["#{p}/*/lib/puppet-lint/plugins/*.rb"].each do |file|
+            load file
+          end
+        end
+      end
+
+      opts.on('-f', '--fix', 'Attempt to automatically fix errors') do
+        PuppetLint.configuration.fix = true
+      end
+
+      opts.on('--log-format FORMAT',
+              'Change the log format.', 'Overrides --with-filename.',
+              'The following placeholders can be used:',
+              '%{filename} - Filename without path.',
+              '%{path}     - Path as provided to puppet-lint.',
+              '%{fullpath} - Expanded path to the file.',
+              '%{line}     - Line number.',
+              '%{column}   - Column number.',
+              '%{kind}     - The kind of message (warning, error).',
+              '%{KIND}     - Uppercase version of %{kind}.',
+              '%{check}    - The name of the check.',
+              '%{message}  - The message.'
+      ) do |format|
+        if format.include?('%{linenumber}')
+          $stderr.puts "DEPRECATION: Please use %{line} instead of %{linenumber}"
+        end
+        PuppetLint.configuration.log_format = format
+      end
+
+      opts.separator ''
+      opts.separator '    Checks:'
+
+      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}")
+        end
+      end
+
+      PuppetLint.configuration.checks.each do |check|
+        opts.on("--no-#{check}-check", "Skip the #{check} check.") do
+          PuppetLint.configuration.send("disable_#{check}")
+        end
+      end
+
+      opts.load('/etc/puppet-lint.rc')
+      begin
+        opts.load(File.expand_path('~/.puppet-lint.rc')) if ENV['HOME']
+      rescue Errno::EACCES
+        # silently skip loading this file if HOME is set to a directory that
+        # the user doesn't have read access to.
+      end
+      opts.load('.puppet-lint.rc')
+    end
+  end
+end

data/lib/puppet-lint/plugins.rb

@@ -0,0 +1,74 @@
+require 'pathname'
+
+class PuppetLint
+  # Public: Various methods that implement puppet-lint's plugin system
+  #
+  # Examples
+  #
+  #   PuppetLint::Plugins.load_spec_helper
+  class Plugins
+    # Internal: Find any gems containing puppet-lint plugins and load them.
+    #
+    # Returns nothing.
+    def self.load_from_gems
+      gem_directories.select { |path|
+        (path + 'puppet-lint/plugins').directory?
+      }.each do |gem_path|
+        Dir["#{(gem_path + 'puppet-lint/plugins').to_s}/*.rb"].each do |file|
+          load file
+        end
+      end
+    end
+
+    # Public: Load the puppet-lint spec_helper.rb
+    #
+    # Returns nothings.
+    def self.load_spec_helper
+      gemspec = gemspecs.select { |spec| spec.name == 'puppet-lint' }.first
+      load Pathname.new(gemspec.full_gem_path) + 'spec/spec_helper.rb'
+    end
+  private
+    # Internal: Check if RubyGems is loaded and available.
+    #
+    # Returns true if RubyGems is available, false if not.
+    def self.has_rubygems?
+      defined? ::Gem
+    end
+
+    # Internal: Retrieve a list of avaliable gemspecs.
+    #
+    # Returns an Array of Gem::Specification objects.
+    def self.gemspecs
+      @gemspecs ||= if Gem::Specification.respond_to?(:latest_specs)
+        Gem::Specification.latest_specs
+      else
+        Gem.searcher.init_gemspecs
+      end
+    end
+
+    # Internal: Retrieve a list of available gem paths from RubyGems.
+    #
+    # Returns an Array of Pathname objects.
+    def self.gem_directories
+      if has_rubygems?
+        gemspecs.reject { |spec| spec.name == 'puppet-lint' }.map do |spec|
+          Pathname.new(spec.full_gem_path) + 'lib'
+        end
+      else
+        []
+      end
+    end
+  end
+end
+
+require 'puppet-lint/plugins/check_classes'
+require 'puppet-lint/plugins/check_comments'
+require 'puppet-lint/plugins/check_conditionals'
+require 'puppet-lint/plugins/check_documentation'
+require 'puppet-lint/plugins/check_strings'
+require 'puppet-lint/plugins/check_variables'
+require 'puppet-lint/plugins/check_whitespace'
+require 'puppet-lint/plugins/check_resources'
+require 'puppet-lint/plugins/check_nodes'
+
+PuppetLint::Plugins.load_from_gems

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

@@ -0,0 +1,285 @@
+# Public: Test the manifest tokens for any right-to-left (<-) chaining
+# operators and record a warning for each instance found.
+PuppetLint.new_check(:right_to_left_relationship) do
+  def check
+    tokens.select { |r| r.type == :OUT_EDGE }.each do |token|
+      notify :warning, {
+        :message =>  'right-to-left (<-) relationship',
+        :line    => token.line,
+        :column  => token.column,
+      }
+    end
+  end
+end
+
+# Public: Test the manifest tokens for any classes or defined types that are
+# not in an appropriately named file for the autoloader to detect and record
+# an error of each instance found.
+PuppetLint.new_check(:autoloader_layout) do
+  def check
+    unless fullpath.nil? || fullpath == ''
+      (class_indexes + defined_type_indexes).each do |class_idx|
+        title_token = class_idx[:name_token]
+        split_title = title_token.value.split('::')
+        mod = split_title.first
+        if split_title.length > 1
+          expected_path = "/#{mod}/manifests/#{split_title[1..-1].join('/')}.pp"
+        else
+          expected_path = "/#{title_token.value}/manifests/init.pp"
+        end
+
+        if PuppetLint.configuration.relative
+          expected_path = expected_path.gsub(/^\//,'').split('/')[1..-1].join('/')
+        end
+
+        unless fullpath.end_with? expected_path
+          notify :error, {
+            :message => "#{title_token.value} not in autoload module layout",
+            :line    => title_token.line,
+            :column  => title_token.column,
+          }
+        end
+      end
+    end
+  end
+end
+
+# Public: Check the manifest tokens for any classes or defined types that
+# have a dash in their name and record an error for each instance found.
+PuppetLint.new_check(:names_containing_dash) do
+  def check
+    (class_indexes + defined_type_indexes).each do |class_idx|
+      if class_idx[:name_token].value.include? '-'
+        if class_idx[:type] == :CLASS
+          obj_type = 'class'
+        else
+          obj_type = 'defined type'
+        end
+
+        notify :error, {
+          :message => "#{obj_type} name containing a dash",
+          :line    => class_idx[:name_token].line,
+          :column  => class_idx[:name_token].column,
+        }
+      end
+    end
+  end
+end
+
+# Public: Check the manifest tokens for any classes that inherit a params
+# subclass and record a warning for each instance found.
+PuppetLint.new_check(:class_inherits_from_params_class) do
+  def check
+    class_indexes.each do |class_idx|
+      unless class_idx[:inherited_token].nil?
+        if class_idx[:inherited_token].value.end_with? '::params'
+          notify :warning, {
+            :message => 'class inheriting from params class',
+            :line    => class_idx[:inherited_token].line,
+            :column  => class_idx[:inherited_token].column,
+          }
+        end
+      end
+    end
+  end
+end
+
+# 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|
+      unless class_idx[:param_tokens].nil?
+        paren_stack = []
+        class_idx[:param_tokens].each_with_index do |token, i|
+          if token.type == :LPAREN
+            paren_stack.push(true)
+          elsif token.type == :RPAREN
+            paren_stack.pop
+          end
+          next unless paren_stack.empty?
+
+          if token.type == :VARIABLE
+            if token.next_code_token.nil? || [:COMMA, :RPAREN].include?(token.next_code_token.type)
+              prev_tokens = class_idx[:param_tokens][0..i]
+              unless prev_tokens.rindex { |r| r.type == :EQUALS }.nil?
+                unless token.prev_code_token.nil? or token.prev_code_token.type == :EQUALS
+                  msg = 'optional parameter listed before required parameter'
+                  notify :warning, {
+                    :message => msg,
+                    :line    => token.line,
+                    :column  => token.column,
+                  }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Public: Test the manifest tokens for any classes that inherit across
+# namespaces and record a warning for each instance found.
+PuppetLint.new_check(:inherits_across_namespaces) do
+  def check
+    class_indexes.each do |class_idx|
+      unless class_idx[:inherited_token].nil?
+        inherited_module_name = class_idx[:inherited_token].value.split('::').reject { |r| r.empty? }.first
+        class_module_name = class_idx[:name_token].value.split('::').reject { |r| r.empty? }.first
+
+        unless class_module_name == inherited_module_name
+          notify :warning, {
+            :message => "class inherits across module namespaces",
+            :line    => class_idx[:inherited_token].line,
+            :column  => class_idx[:inherited_token].column,
+          }
+        end
+      end
+    end
+  end
+end
+
+# Public: Test the manifest tokens for any classes or defined types that are
+# defined inside another class.
+PuppetLint.new_check(:nested_classes_or_defines) do
+  TOKENS = Set[:CLASS, :DEFINE]
+
+  def check
+    class_indexes.each do |class_idx|
+      # Skip the first token so that we don't pick up the first :CLASS
+      class_tokens = class_idx[:tokens][1..-1]
+
+      class_tokens.each do |token|
+        if TOKENS.include?(token.type)
+          if token.next_code_token.type != :LBRACE
+            type = token.type == :CLASS ? 'class' : 'defined type'
+
+            notify :warning, {
+              :message => "#{type} defined inside a class",
+              :line    => token.line,
+              :column  => token.column,
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+# Public: Test the manifest tokens for any variables that are referenced in
+# the manifest.  If the variables are not fully qualified or one of the
+# variables automatically created in the scope, check that they have been
+# defined in the local scope and record a warning for each variable that has
+# not.
+PuppetLint.new_check(:variable_scope) do
+  DEFAULT_SCOPE_VARS = Set[
+    'name',
+    'title',
+    'module_name',
+    'environment',
+    'clientcert',
+    'clientversion',
+    'servername',
+    'serverip',
+    'serverversion',
+    'caller_module_name',
+    'alias',
+    'audit',
+    'before',
+    'loglevel',
+    'noop',
+    'notify',
+    'require',
+    'schedule',
+    'stage',
+    'subscribe',
+    'tag',
+  ]
+  POST_VAR_TOKENS = Set[:COMMA, :EQUALS, :RPAREN]
+
+  def check
+    variables_in_scope = DEFAULT_SCOPE_VARS.clone
+
+    (class_indexes + defined_type_indexes).each do |idx|
+      referenced_variables = Set[]
+      object_tokens = idx[:tokens]
+
+      unless idx[:param_tokens].nil?
+        idx[:param_tokens].each do |token|
+          if token.type == :VARIABLE
+            if POST_VAR_TOKENS.include? token.next_code_token.type
+              variables_in_scope << token.value
+            end
+          end
+        end
+      end
+
+      future_parser_scopes = {}
+      in_pipe = false
+      temp_scope_vars = []
+
+      object_tokens.each do |token|
+        if token.type == :VARIABLE
+          if in_pipe
+            temp_scope_vars << token.value
+          else
+            if token.next_code_token.type == :EQUALS
+              variables_in_scope << token.value
+            else
+              referenced_variables << token
+            end
+          end
+        elsif token.type == :PIPE
+          in_pipe = !in_pipe
+
+          if in_pipe
+            temp_scope_vars = []
+          else
+            start_idx = tokens.find_index(token)
+            end_token = nil
+            brace_depth = 0
+
+            tokens[start_idx..-1].each do |sub_token|
+              case sub_token.type
+              when :LBRACE
+                brace_depth += 1
+              when :RBRACE
+                brace_depth -= 1
+                if brace_depth == 0
+                  end_token = sub_token
+                  break
+                end
+              end
+            end
+
+            future_parser_scopes.merge!(Hash[(token.line..end_token.line).to_a.map { |i| [i, temp_scope_vars] }])
+          end
+        end
+      end
+
+      msg = "top-scope variable being used without an explicit namespace"
+      referenced_variables.each do |token|
+        unless future_parser_scopes[token.line].nil?
+          next if future_parser_scopes[token.line].include?(token.value)
+        end
+
+        unless token.value.include? '::'
+          unless token.value =~ /^(facts|trusted)\[.+\]/
+            unless variables_in_scope.include? token.value.gsub(/\[.+\]\Z/, '')
+              unless token.value =~ /\A\d+\Z/
+                notify :warning, {
+                  :message => msg,
+                  :line    => token.line,
+                  :column  => token.column,
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end