puppet-lint 2.3.0 → 2.3.1

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

@@ -5,18 +5,19 @@
 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
+      next if class_idx[:inherited_token].nil?
 
-        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
+      inherited_module_name = class_idx[:inherited_token].value.split('::').reject(&:empty?).first
+      class_module_name = class_idx[:name_token].value.split('::').reject(&:empty?).first
+
+      next if 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

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

@@ -5,19 +5,20 @@
 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
+      next unless class_idx[:name_token].value.include?('-')
 
-        notify :error, {
-          :message => "#{obj_type} name containing a dash",
-          :line    => class_idx[:name_token].line,
-          :column  => class_idx[:name_token].column,
-        }
-      end
+      obj_type = if class_idx[:type] == :CLASS
+                   'class'
+                 else
+                   '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

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

@@ -5,20 +5,21 @@
 PuppetLint.new_check(:names_containing_uppercase) do
   def check
     (class_indexes + defined_type_indexes).each do |class_idx|
-      if class_idx[:name_token].value =~ /[A-Z]/
-        if class_idx[:type] == :CLASS
-          obj_type = 'class'
-        else
-          obj_type = 'defined type'
-        end
+      next unless class_idx[:name_token].value =~ %r{[A-Z]}
 
-        notify :error, {
-          :message => "#{obj_type} '#{class_idx[:name_token].value}' contains illegal uppercase",
-          :line    => class_idx[:name_token].line,
-          :column  => class_idx[:name_token].column,
-          :token   => class_idx[:name_token],
-        }
-      end
+      obj_type = if class_idx[:type] == :CLASS
+                   'class'
+                 else
+                   'defined type'
+                 end
+
+      notify(
+        :error,
+        :message => "#{obj_type} '#{class_idx[:name_token].value}' contains illegal uppercase",
+        :line    => class_idx[:name_token].line,
+        :column  => class_idx[:name_token].column,
+        :token   => class_idx[:name_token],
+      )
     end
   end
 

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

@@ -11,17 +11,16 @@ PuppetLint.new_check(:nested_classes_or_defines) do
       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'
+        next unless TOKENS.include?(token.type)
+        next 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
+        notify(
+          :warning,
+          :message => "#{type} defined inside a class",
+          :line    => token.line,
+          :column  => token.column,
+        )
       end
     end
   end

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

@@ -6,39 +6,48 @@
 PuppetLint.new_check(:parameter_order) do
   def check
     (class_indexes + defined_type_indexes).each do |class_idx|
-      unless class_idx[:param_tokens].nil?
-        paren_stack = []
-        hash_or_array_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
-          elsif token.type == :LBRACE || token.type == :LBRACK
-            hash_or_array_stack.push(true)
-          elsif token.type == :RBRACE || token.type == :RBRACK
-            hash_or_array_stack.pop
-          end
-          next if (! hash_or_array_stack.empty?)
-          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
+      next if class_idx[:param_tokens].nil?
+
+      paren_stack = []
+      hash_or_array_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
+        elsif token.type == :LBRACE || token.type == :LBRACK
+          hash_or_array_stack.push(true)
+        elsif token.type == :RBRACE || token.type == :RBRACK
+          hash_or_array_stack.pop
         end
+
+        next unless hash_or_array_stack.empty? && paren_stack.empty?
+        next unless required_parameter?(token)
+
+        prev_tokens = class_idx[:param_tokens][0..i]
+        next if prev_tokens.rindex { |r| r.type == :EQUALS }.nil?
+
+        msg = 'optional parameter listed before required parameter'
+        notify(
+          :warning,
+          :message => msg,
+          :line    => token.line,
+          :column  => token.column,
+        )
       end
     end
   end
+
+  def required_parameter?(token)
+    return false unless token.type == :VARIABLE
+
+    data_type = token.prev_token_of(:TYPE, :skip_blocks => true)
+    return false if data_type && data_type.value == 'Optional'
+
+    if token.next_code_token.nil? || [:COMMA, :RPAREN].include?(token.next_code_token.type)
+      return !(token.prev_code_token && token.prev_code_token.type == :EQUALS)
+    end
+
+    false
+  end
 end

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

@@ -5,11 +5,12 @@
 PuppetLint.new_check(:right_to_left_relationship) do
   def check
     tokens.select { |r| r.type == :OUT_EDGE }.each do |token|
-      notify :warning, {
+      notify(
+        :warning,
         :message =>  'right-to-left (<-) relationship',
         :line    => token.line,
         :column  => token.column,
-      }
+      )
     end
   end
 end

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

@@ -43,11 +43,10 @@ PuppetLint.new_check(:variable_scope) do
 
       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
+          next unless token.type == :VARIABLE
+          next unless POST_VAR_TOKENS.include?(token.next_code_token.type)
+
+          variables_in_scope << token.value
         end
       end
 
@@ -72,10 +71,10 @@ PuppetLint.new_check(:variable_scope) do
                 brack_depth += 1
               when :LBRACK
                 brack_depth -= 1
-                break if brack_depth == 0
-              when :COMMA
+                break if brack_depth.zero?
+              when :COMMA # rubocop:disable Lint/EmptyWhen
                 # ignore
-              else  # unexpected
+              else # unexpected
                 break
               end
             end
@@ -102,7 +101,7 @@ PuppetLint.new_check(:variable_scope) do
                 brace_depth += 1
               when :RBRACE
                 brace_depth -= 1
-                if brace_depth == 0
+                if brace_depth.zero?
                   end_token = sub_token
                   break
                 end
@@ -118,25 +117,23 @@ PuppetLint.new_check(:variable_scope) do
         end
       end
 
-      msg = "top-scope variable being used without an explicit namespace"
+      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.gsub(/\[.+\]\Z/, ''))
+          next if future_parser_scopes[token.line].include?(token.value.gsub(%r{\[.+\]\Z}, ''))
         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
+        next if token.value.include?('::')
+        next if token.value =~ %r{^(facts|trusted)\[.+\]}
+        next if variables_in_scope.include?(token.value.gsub(%r{\[.+\]\Z}, ''))
+        next if token.value =~ %r{\A\d+\Z}
+
+        notify(
+          :warning,
+          :message => msg,
+          :line    => token.line,
+          :column  => token.column,
+        )
       end
     end
   end

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

@@ -7,12 +7,13 @@ PuppetLint.new_check(:slash_comments) do
     tokens.select { |token|
       token.type == :SLASH_COMMENT
     }.each do |token|
-      notify :warning, {
+      notify(
+        :warning,
         :message => '// comment found',
         :line    => token.line,
         :column  => token.column,
         :token   => token,
-      }
+      )
     end
   end
 

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

@@ -7,12 +7,13 @@ PuppetLint.new_check(:star_comments) do
     tokens.select { |token|
       token.type == :MLCOMMENT
     }.each do |token|
-      notify :warning, {
+      notify(
+        :warning,
         :message => '/* */ comment found',
         :line    => token.line,
         :column  => token.column,
         :token   => token,
-      }
+      )
     end
   end
 
@@ -26,9 +27,9 @@ PuppetLint.new_check(:star_comments) do
     index = tokens.index(problem[:token].next_token) || 1
     comment_lines.reverse.each do |line|
       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))
+      add_token(index, PuppetLint::Lexer::Token.new(:COMMENT, " #{line}", 0, 0))
+      add_token(index, PuppetLint::Lexer::Token.new(:INDENT, indent, 0, 0)) if indent
+      add_token(index, PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0))
     end
   end
 end

data/lib/puppet-lint/plugins/check_conditionals/case_without_default.rb

@@ -7,37 +7,38 @@ PuppetLint.new_check(:case_without_default) do
     case_indexes = []
 
     tokens.each_index do |token_idx|
-      if tokens[token_idx].type == :CASE
-        depth = 0
-        tokens[(token_idx + 1)..-1].each_index do |case_token_idx|
-          idx = case_token_idx + token_idx + 1
-          if tokens[idx].type == :LBRACE
-            depth += 1
-          elsif tokens[idx].type == :RBRACE
-            depth -= 1
-            if depth == 0
-              case_indexes << {:start => token_idx, :end => idx}
-              break
-            end
+      next unless tokens[token_idx].type == :CASE
+
+      depth = 0
+      tokens[(token_idx + 1)..-1].each_index do |case_token_idx|
+        idx = case_token_idx + token_idx + 1
+        if tokens[idx].type == :LBRACE
+          depth += 1
+        elsif tokens[idx].type == :RBRACE
+          depth -= 1
+          if depth.zero?
+            case_indexes << { :start => token_idx, :end => idx }
+            break
           end
         end
       end
     end
 
-    case_indexes.each_with_index do |kase,kase_index|
+    case_indexes.each_with_index do |kase, kase_index|
       case_tokens = tokens[kase[:start]..kase[:end]]
 
       case_indexes[(kase_index + 1)..-1].each do |successor_kase|
         case_tokens -= tokens[successor_kase[:start]..successor_kase[:end]]
       end
 
-      unless case_tokens.index { |r| r.type == :DEFAULT }
-        notify :warning, {
-          :message => 'case statement without a default case',
-          :line    => case_tokens.first.line,
-          :column  => case_tokens.first.column,
-        }
-      end
+      next if case_tokens.index { |r| r.type == :DEFAULT }
+
+      notify(
+        :warning,
+        :message => 'case statement without a default case',
+        :line    => case_tokens.first.line,
+        :column  => case_tokens.first.column,
+      )
     end
   end
 end

data/lib/puppet-lint/plugins/check_conditionals/selector_inside_resource.rb

@@ -6,19 +6,16 @@ PuppetLint.new_check(:selector_inside_resource) do
   def check
     resource_indexes.each do |resource|
       resource[:tokens].each do |token|
-        if token.type == :FARROW
-          if token.next_code_token.type == :VARIABLE
-            unless token.next_code_token.next_code_token.nil?
-              if token.next_code_token.next_code_token.type == :QMARK
-                notify :warning, {
-                  :message => 'selector inside resource block',
-                  :line    => token.line,
-                  :column  => token.column,
-                }
-              end
-            end
-          end
-        end
+        next unless token.type == :FARROW && token.next_code_token.type == :VARIABLE
+        next if token.next_code_token.next_code_token.nil?
+        next unless token.next_code_token.next_code_token.type == :QMARK
+
+        notify(
+          :warning,
+          :message => 'selector inside resource block',
+          :line    => token.line,
+          :column  => token.column,
+        )
       end
     end
   end

data/lib/puppet-lint/plugins/check_documentation/documentation.rb

@@ -9,25 +9,34 @@ PuppetLint.new_check(:documentation) do
 
   def check
     (class_indexes + defined_type_indexes).each do |item_idx|
-      prev_token = item_idx[:tokens].first.prev_token
-      while (!prev_token.nil?) && WHITESPACE_TOKENS.include?(prev_token.type)
-        prev_token = prev_token.prev_token
-      end
+      comment_token = find_comment_token(item_idx[:tokens].first)
 
-      unless (!prev_token.nil?) && COMMENT_TOKENS.include?(prev_token.type)
-        first_token = item_idx[:tokens].first
-        if first_token.type == :CLASS
-          type = 'class'
-        else
-          type = 'defined type'
-        end
+      next unless comment_token.nil?
 
-        notify :warning, {
-          :message => "#{type} not documented",
-          :line    => first_token.line,
-          :column  => first_token.column,
-        }
-      end
+      first_token = item_idx[:tokens].first
+      type = if first_token.type == :CLASS
+               'class'
+             else
+               'defined type'
+             end
+
+      notify(
+        :warning,
+        :message => "#{type} not documented",
+        :line    => first_token.line,
+        :column  => first_token.column,
+      )
+    end
+  end
+
+  def find_comment_token(start_token)
+    prev_token = start_token.prev_token
+    while !prev_token.nil? && WHITESPACE_TOKENS.include?(prev_token.type)
+      prev_token = prev_token.prev_token
     end
+
+    return if prev_token.nil?
+
+    prev_token if COMMENT_TOKENS.include?(prev_token.type)
   end
 end