puppet-lint 2.3.0 → 2.3.1

data/lib/puppet-lint/plugins/check_nodes/unquoted_node_name.rb

@@ -9,28 +9,28 @@ PuppetLint.new_check(:unquoted_node_name) do
       node_token_idx = tokens.index(node)
       node_lbrace_tok = tokens[node_token_idx..-1].find { |token| token.type == :LBRACE }
       if node_lbrace_tok.nil?
-        notify :error, {
+        notify(
+          :error,
           :check    => :syntax,
           :message  => 'Syntax error (try running `puppet parser validate <file>`)',
           :line     => node.line,
           :column   => node.column,
-        }
+        )
         next
       end
 
       node_lbrace_idx = tokens.index(node_lbrace_tok)
 
       tokens[node_token_idx..node_lbrace_idx].select { |token|
-        token.type == :NAME
+        token.type == :NAME && token.value != 'default'
       }.each do |token|
-        unless token.value == 'default'
-          notify :warning, {
-            :message => 'unquoted node name found',
-            :line    => token.line,
-            :column  => token.column,
-            :token   => token,
-          }
-        end
+        notify(
+          :warning,
+          :message => 'unquoted node name found',
+          :line    => token.line,
+          :column  => token.column,
+          :token   => token,
+        )
       end
     end
   end

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

@@ -8,7 +8,7 @@ PuppetLint.new_check(:duplicate_params) do
       seen_params = {}
       level = 0
 
-      resource[:tokens].each_with_index do |token, idx|
+      resource[:tokens].each do |token|
         case token.type
         when :LBRACE
           level += 1
@@ -22,11 +22,12 @@ PuppetLint.new_check(:duplicate_params) do
           next unless prev_token.type == :NAME
 
           if (seen_params[level] ||= Set.new).include?(prev_token.value)
-            notify :error, {
+            notify(
+              :error,
               :message => 'duplicate parameter found in resource',
               :line    => prev_token.line,
               :column  => prev_token.column,
-            }
+            )
           else
             seen_params[level] << prev_token.value
           end

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

@@ -6,22 +6,22 @@
 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'
-      }
+      next if [:CLASS].include?(resource[:type].type)
 
-      unless ensure_attr_index.nil?
-        if ensure_attr_index > 0
-          ensure_token = resource[:param_tokens][ensure_attr_index]
-          notify :warning, {
-            :message  => "ensure found on line but it's not the first attribute",
-            :line     => ensure_token.line,
-            :column   => ensure_token.column,
-            :resource => resource,
-          }
-        end
+      ensure_attr_index = resource[:param_tokens].index do |param_token|
+        param_token.value == 'ensure'
       end
+
+      next if ensure_attr_index.nil? || ensure_attr_index.zero?
+
+      ensure_token = resource[:param_tokens][ensure_attr_index]
+      notify(
+        :warning,
+        :message  => "ensure found on line but it's not the first attribute",
+        :line     => ensure_token.line,
+        :column   => ensure_token.column,
+        :resource => resource,
+      )
     end
   end
 
@@ -31,7 +31,7 @@ PuppetLint.new_check(:ensure_first_param) do
     ensure_param_name_token = first_param_comma_token.next_token_of(:NAME, :value => 'ensure')
     ensure_param_comma_token = ensure_param_name_token.next_token_of([:COMMA, :SEMIC])
 
-    if first_param_name_token.nil? or first_param_comma_token.nil? or ensure_param_name_token.nil? or ensure_param_comma_token.nil?
+    if first_param_name_token.nil? || first_param_comma_token.nil? || ensure_param_name_token.nil? || ensure_param_comma_token.nil?
       raise PuppetLint::NoFix
     end
 
@@ -54,12 +54,11 @@ PuppetLint.new_check(:ensure_first_param) do
     ensure_param_comma_token.next_token = next_token
 
     next_code_token = first_param_comma_token.next_code_token
-    first_param_comma_code_token = ensure_param_comma_token.next_code_token
     ensure_param_comma_token.next_code_token = next_code_token
 
     # Update index
-    ensure_tmp = tokens.slice!(ensure_param_name_idx..ensure_param_comma_idx-1)
-    first_tmp = tokens.slice!(first_param_name_idx..first_param_comma_idx-1)
+    ensure_tmp = tokens.slice!(ensure_param_name_idx..ensure_param_comma_idx - 1)
+    first_tmp = tokens.slice!(first_param_name_idx..first_param_comma_idx - 1)
     ensure_tmp.reverse_each do |item|
       tokens.insert(first_param_name_idx, item)
     end

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

@@ -6,21 +6,22 @@
 PuppetLint.new_check(:ensure_not_symlink_target) do
   def check
     resource_indexes.each do |resource|
-      if resource[:type].value == "file"
-        resource[:param_tokens].select { |param_token|
-          param_token.value == 'ensure'
-        }.each do |ensure_token|
-          value_token = ensure_token.next_code_token.next_code_token
-          if value_token.value.start_with? '/'
-            notify :warning, {
-              :message     => 'symlink target specified in ensure attr',
-              :line        => value_token.line,
-              :column      => value_token.column,
-              :param_token => ensure_token,
-              :value_token => value_token,
-            }
-          end
-        end
+      next unless resource[:type].value == 'file'
+
+      resource[:param_tokens].select { |param_token|
+        param_token.value == 'ensure'
+      }.each do |ensure_token|
+        value_token = ensure_token.next_code_token.next_code_token
+        next unless value_token.value.start_with?('/')
+
+        notify(
+          :warning,
+          :message     => 'symlink target specified in ensure attr',
+          :line        => value_token.line,
+          :column      => value_token.column,
+          :param_token => ensure_token,
+          :value_token => value_token,
+        )
       end
     end
   end
@@ -37,7 +38,7 @@ PuppetLint.new_check(:ensure_not_symlink_target) do
       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|
+    ].reverse_each do |new_token|
       tokens.insert(index, new_token)
     end
   end

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

@@ -4,39 +4,38 @@
 #
 # https://docs.puppet.com/guides/style_guide.html#file-modes
 PuppetLint.new_check(:file_mode) do
-  MSG = 'mode should be represented as a 4 digit octal value or symbolic mode'
-  SYM_RE = "([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*"
+  MSG = 'mode should be represented as a 4 digit octal value or symbolic mode'.freeze
+  SYM_RE = '([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*'.freeze
   IGNORE_TYPES = Set[:VARIABLE, :UNDEF, :FUNCTION_NAME]
-  MODE_RE = Regexp.new(/\A([0-7]{4}|#{SYM_RE})\Z/)
+  MODE_RE = %r{\A([0-7]{4}|#{SYM_RE})\Z}
 
   def check
     resource_indexes.each do |resource|
-      if resource[:type].value == "file" or resource[:type].value == "concat"
-        resource[:param_tokens].select { |param_token|
-          param_token.value == 'mode'
-        }.each do |param_token|
-          value_token = param_token.next_code_token.next_code_token
+      next unless resource[:type].value == 'file' || resource[:type].value == 'concat'
 
-          break if IGNORE_TYPES.include?(value_token.type)
-          break if value_token.value =~ MODE_RE
+      resource[:param_tokens].select { |param_token|
+        param_token.value == 'mode'
+      }.each do |param_token|
+        value_token = param_token.next_code_token.next_code_token
 
-          notify :warning, {
-            :message => MSG,
-            :line    => value_token.line,
-            :column  => value_token.column,
-            :token   => value_token,
-          }
-        end
+        break if IGNORE_TYPES.include?(value_token.type)
+        break if value_token.value =~ MODE_RE
+
+        notify(
+          :warning,
+          :message => MSG,
+          :line    => value_token.line,
+          :column  => value_token.column,
+          :token   => value_token,
+        )
       end
     end
   end
 
   def fix(problem)
-    if problem[:token].value =~ /\A[0-7]{3}\Z/
-      problem[:token].type = :SSTRING
-      problem[:token].value = "0#{problem[:token].value.to_s}"
-    else
-      raise PuppetLint::NoFix
-    end
+    raise PuppetLint::NoFix unless problem[:token].value =~ %r{\A[0-7]{3}\Z}
+
+    problem[:token].type = :SSTRING
+    problem[:token].value = "0#{problem[:token].value}"
   end
 end

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

@@ -8,19 +8,20 @@ PuppetLint.new_check(:unquoted_file_mode) do
 
   def check
     resource_indexes.each do |resource|
-      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)
-        }.each do |param_token|
-          value_token = param_token.next_code_token.next_code_token
-          notify :warning, {
-            :message => 'unquoted file mode',
-            :line    => value_token.line,
-            :column  => value_token.column,
-            :token   => value_token,
-          }
-        end
+      next unless resource[:type].value == 'file' || 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)
+      }.each do |param_token|
+        value_token = param_token.next_code_token.next_code_token
+        notify(
+          :warning,
+          :message => 'unquoted file mode',
+          :line    => value_token.line,
+          :column  => value_token.column,
+          :token   => value_token,
+        )
       end
     end
   end

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

@@ -5,14 +5,15 @@
 PuppetLint.new_check(:unquoted_resource_title) do
   def check
     title_tokens.each do |token|
-      if token.type == :NAME
-        notify :warning, {
-          :message => 'unquoted resource title',
-          :line    => token.line,
-          :column  => token.column,
-          :token   => token,
-        }
-      end
+      next unless token.type == :NAME
+
+      notify(
+        :warning,
+        :message => 'unquoted resource title',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      )
     end
   end
 

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

@@ -4,20 +4,20 @@
 #
 # https://docs.puppet.com/guides/style_guide.html#quoting
 PuppetLint.new_check(:double_quoted_strings) do
+  ESCAPE_CHAR_RE = %r{(\\\$|\\"|\\'|'|\r|\t|\\t|\n|\\n|\\\\)}
+
   def check
     tokens.select { |token|
-      token.type == :STRING
-    }.map { |token|
-      [token, token.value.gsub(' '*token.column, "\n")]
-    }.select { |token, sane_value|
-      sane_value[/(\\\$|\\"|\\'|'|\r|\t|\\t|\n|\\n|\\\\)/].nil?
-    }.each do |token, sane_value|
-      notify :warning, {
+      token.type == :STRING &&
+        token.value.gsub(' ' * token.column, "\n")[ESCAPE_CHAR_RE].nil?
+    }.each do |token|
+      notify(
+        :warning,
         :message => 'double quoted string containing no variables',
         :line    => token.line,
         :column  => token.column,
         :token   => token,
-      }
+      )
     end
   end
 

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

@@ -7,57 +7,44 @@ PuppetLint.new_check(:only_variable_string) do
 
   def check
     tokens.each_with_index do |start_token, start_token_idx|
-      if start_token.type == :DQPRE and start_token.value == ''
-        var_token = start_token.next_token
-        if VAR_TYPES.include? var_token.type
-          eos_offset = 2
-          loop do
-            eos_token = tokens[start_token_idx + eos_offset]
-            case eos_token.type
-            when :LBRACK
-              eos_offset += 3
-            when :DQPOST
-              if eos_token.value == ''
-                if eos_token.next_code_token && eos_token.next_code_token.type == :FARROW
-                  break
-                end
-                notify :warning, {
-                  :message     => 'string containing only a variable',
-                  :line        => var_token.line,
-                  :column      => var_token.column,
-                  :start_token => start_token,
-                  :var_token   => var_token,
-                  :end_token   => eos_token,
-                }
-              end
-              break
-            else
+      next unless start_token.type == :DQPRE && start_token.value == ''
+
+      var_token = start_token.next_token
+      next unless VAR_TYPES.include?(var_token.type)
+
+      eos_offset = 2
+      loop do
+        eos_token = tokens[start_token_idx + eos_offset]
+        case eos_token.type
+        when :LBRACK
+          eos_offset += 3
+        when :DQPOST
+          if eos_token.value == ''
+            if eos_token.next_code_token && eos_token.next_code_token.type == :FARROW
               break
             end
+            notify(
+              :warning,
+              :message     => 'string containing only a variable',
+              :line        => var_token.line,
+              :column      => var_token.column,
+              :start_token => start_token,
+              :var_token   => var_token,
+              :end_token   => eos_token,
+            )
           end
+          break
+        else
+          break
         end
       end
     end
   end
 
   def fix(problem)
-    prev_token = problem[:start_token].prev_token
-    prev_code_token = problem[:start_token].prev_code_token
-    next_token = problem[:end_token].next_token
-    next_code_token = problem[:end_token].next_code_token
-    var_token = problem[:var_token]
-
-    tokens.delete(problem[:start_token])
-    tokens.delete(problem[:end_token])
+    remove_token(problem[:start_token])
+    remove_token(problem[:end_token])
 
-    prev_token.next_token = var_token unless prev_token.nil?
-    prev_code_token.next_code_token = var_token unless prev_code_token.nil?
-    next_code_token.prev_code_token = var_token unless next_code_token.nil?
-    next_token.prev_token = var_token unless next_token.nil?
-    var_token.type = :VARIABLE
-    var_token.next_token = next_token
-    var_token.next_code_token = next_code_token
-    var_token.prev_code_token = prev_code_token
-    var_token.prev_token = prev_token
+    problem[:var_token].type = :VARIABLE
   end
 end

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

@@ -8,18 +8,19 @@ PuppetLint.new_check(:puppet_url_without_modules) do
     tokens.select { |token|
       (token.type == :SSTRING || token.type == :STRING || token.type == :DQPRE) && token.value.start_with?('puppet://')
     }.reject { |token|
-      token.value[/puppet:\/\/.*?\/(.+)/, 1].start_with?('modules/') unless token.value[/puppet:\/\/.*?\/(.+)/, 1].nil?
+      token.value[%r{puppet://.*?/(.+)}, 1].start_with?('modules/') unless token.value[%r{puppet://.*?/(.+)}, 1].nil?
     }.each do |token|
-      notify :warning, {
+      notify(
+        :warning,
         :message => 'puppet:// URL without modules/ found',
         :line    => token.line,
         :column  => token.column,
         :token   => token,
-      }
+      )
     end
   end
 
   def fix(problem)
-    problem[:token].value.gsub!(/(puppet:\/\/.*?\/)/, '\1modules/')
+    problem[:token].value.gsub!(%r{(puppet://.*?/)}, '\1modules/')
   end
 end

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

@@ -11,12 +11,13 @@ PuppetLint.new_check(:quoted_booleans) do
     tokens.select { |r|
       STRING_TYPES.include?(r.type) && BOOLEANS.include?(r.value)
     }.each do |token|
-      notify :warning, {
+      notify(
+        :warning,
         :message => 'quoted boolean value found',
         :line    => token.line,
         :column  => token.column,
         :token   => token,
-      }
+      )
     end
   end