puppet-lint 2.3.5 → 2.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2f7f4e8237599a2215c6e0b7b80126c6ed43cc2
-  data.tar.gz: 91aa136ffbc1370e60d999d9d0f591df2fbbb0f3
+  metadata.gz: 299ce7a01574b87c32ac76798f691800ef27fc2c
+  data.tar.gz: 4f3f73a44040dbfc0d6f3b2bfb6535b000d3bdf1
 SHA512:
-  metadata.gz: e109be5cd7d30e0660fbc0b839d69e1bcd19870b12a31889076999deb2a0d7fe8519e28e874be556c6ebe9345a5df6a968acbf0c87ba1438d14f63bbb836264e
-  data.tar.gz: 8d65ef648c28a084e13b2450f0bebb69e2ee9ca937a6fee09ad5762c309da27f2496fbb7adf5b6bcc3117e3a2b4a65b790681073ab3956661a508d7586503fcf
+  metadata.gz: 920ee6f31d30184faf6c288902f53387bba45df38976a854c7e837647520e8162e140303fad43a6b7de70be4c1b3efd1cede9fc2f93b377e0773442f66fe239d
+  data.tar.gz: ab9bb35509a161c70c73b4880b737e39416884d6709c166df95817b3fd6f6efce5329ca856f50644705907c776b631c61f658ecfa2bae1c7972e79310fc45cb4

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Change Log
 
+## [2.3.6](https://github.com/rodjek/puppet-lint/tree/2.3.6) (2018-07-09)
+[Full Changelog](https://github.com/rodjek/puppet-lint/compare/2.3.5...2.3.6)
+
+**Fixed bugs:**
+
+- --fix does not work with require arrows in certain situations [\#799](https://github.com/rodjek/puppet-lint/issues/799)
+- Error with --fix when no whitespace before hashrocket in resource attribute list [\#798](https://github.com/rodjek/puppet-lint/issues/798)
+- puppet-lint --fix strips comments when fixing arrow\_on\_right\_operand\_line [\#792](https://github.com/rodjek/puppet-lint/issues/792)
+- Crash report, reason unclear [\#781](https://github.com/rodjek/puppet-lint/issues/781)
+- crash in fix mode with multiple trailing arrows [\#776](https://github.com/rodjek/puppet-lint/issues/776)
+- Error negative argument if opening brace on the same line and following element longer [\#771](https://github.com/rodjek/puppet-lint/issues/771)
+- ArgumentError: negative argument [\#723](https://github.com/rodjek/puppet-lint/issues/723)
+
+**Merged pull requests:**
+
+- \(\#771\) Handle arrow alignment when arrow column \< opening brace column... [\#819](https://github.com/rodjek/puppet-lint/pull/819) ([rodjek](https://github.com/rodjek))
+- Less aggressive fix method for arrow\_on\_right\_operand\_line [\#817](https://github.com/rodjek/puppet-lint/pull/817) ([rodjek](https://github.com/rodjek))
+- Check if token still exists before fixing trailing\_whitespace [\#816](https://github.com/rodjek/puppet-lint/pull/816) ([rodjek](https://github.com/rodjek))
+- Run all the checks before fixing problems [\#815](https://github.com/rodjek/puppet-lint/pull/815) ([rodjek](https://github.com/rodjek))
+
 ## [2.3.5](https://github.com/rodjek/puppet-lint/tree/2.3.5) (2018-03-27)
 [Full Changelog](https://github.com/rodjek/puppet-lint/compare/2.3.4...2.3.5)
 

data/appveyor.yml

@@ -14,6 +14,10 @@ environment:
     - RUBY_VERSION: 23-x64
     - RUBY_VERSION: 24-x64
 
+matrix:
+  allow_failures:
+    - RUBY_VERSION: 193
+
 install:
   - SET PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
   - SET LOG_SPEC_ORDER=true

data/lib/puppet-lint/checks.rb

@@ -54,11 +54,15 @@ class PuppetLint::Checks
   def run(fileinfo, data)
     load_data(fileinfo, data)
 
+    checks_run = []
     enabled_checks.each do |check|
       klass = PuppetLint.configuration.check_object[check].new
       # FIXME: shadowing #problems
       problems = klass.run
+      checks_run << [klass, problems]
+    end
 
+    checks_run.each do |klass, problems|
       if PuppetLint.configuration.fix
         @problems.concat(klass.fix_problems)
       else

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

@@ -9,7 +9,7 @@ PuppetLint.new_check(:arrow_on_right_operand_line) do
 
       notify(
         :warning,
-        :message =>  'arrow should be on the right operand\'s line',
+        :message => "arrow should be on the right operand's line",
         :line    => token.line,
         :column  => token.column,
         :token   => token
@@ -18,27 +18,22 @@ PuppetLint.new_check(:arrow_on_right_operand_line) do
   end
 
   def fix(problem)
-    token = problem[:token]
+    return if problem[:token].nil?
 
-    prev_code_token = token.prev_code_token
-    next_code_token = token.next_code_token
-    indent_token = prev_code_token.prev_token_of(:INDENT)
+    arrow_token = problem[:token]
+    left_operand_token = arrow_token.prev_code_token
+    right_operand_token = arrow_token.next_code_token
 
-    # Delete all tokens between the two code tokens the anchor is between
-    temp_token = prev_code_token
-    while (temp_token = temp_token.next_token) && (temp_token != next_code_token)
-      remove_token(temp_token) unless temp_token == token
-    end
-
-    # Insert a newline and an indent before the arrow
-    index = tokens.index(token)
-    newline_token = PuppetLint::Lexer::Token.new(:NEWLINE, "\n", token.line, 0)
-    add_token(index, newline_token)
-    add_token(index + 1, indent_token) if indent_token
+    # Move arrow token to just before the right operand
+    remove_token(arrow_token)
+    right_operand_index = tokens.index(right_operand_token)
+    add_token(right_operand_index, arrow_token)
+    whitespace_token = PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', right_operand_token.line, 3)
+    add_token(right_operand_index + 1, whitespace_token)
 
-    # Insert a space between the arrow and the following code token
-    index = tokens.index(token)
-    whitespace_token = PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', token.line, 3)
-    add_token(index + 1, whitespace_token)
+    # Remove trailing whitespace after left operand (if it exists)
+    return unless left_operand_token.next_token.type == :WHITESPACE
+    trailing_whitespace_token = left_operand_token.next_token
+    remove_token(trailing_whitespace_token) if [:NEWLINE, :WHITESPACE].include?(trailing_whitespace_token.next_token.type)
   end
 end

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

@@ -25,7 +25,6 @@ PuppetLint.new_check(:arrow_alignment) do
 
       resource_tokens.each do |token|
         if token.type == :FARROW
-          (level_tokens[level_idx] ||= []) << token
           param_token = token.prev_code_token
 
           if param_token.type == :DQPOST
@@ -48,12 +47,18 @@ PuppetLint.new_check(:arrow_alignment) do
                                       end
           end
 
-          this_arrow_column = param_column[level_idx] + param_length + 1
+          if (level_tokens[level_idx] ||= []).any? { |t| t.line == token.line }
+            this_arrow_column = param_column[level_idx] + param_length + 1
+          else
+            this_arrow_column = param_token.column + param_token.to_manifest.length
+            this_arrow_column += 1 unless param_token.type == :DQPOST
+          end
 
           if arrow_column[level_idx] < this_arrow_column
             arrow_column[level_idx] = this_arrow_column
           end
 
+          (level_tokens[level_idx] ||= []) << token
         elsif token.type == :LBRACE
           level_idx += 1
           arrow_column << 0
@@ -96,12 +101,21 @@ PuppetLint.new_check(:arrow_alignment) do
       # indent the parameter to the correct depth
       problem[:token].prev_code_token.prev_token.type = :INDENT
       problem[:token].prev_code_token.prev_token.value = ' ' * problem[:newline_indent]
+
+      end_param_idx = tokens.index(problem[:token].prev_code_token)
+      start_param_idx = tokens.index(problem[:token].prev_token_of([:INDENT, :NEWLINE]))
+      param_length = tokens[start_param_idx..end_param_idx].map { |r| r.to_manifest.length }.reduce(0) { |sum, x| sum + x } + 1
+      new_ws_len = problem[:arrow_column] - param_length
+    else
+      new_ws_len = if problem[:token].prev_token.type == :WHITESPACE
+                     problem[:token].prev_token.to_manifest.length
+                   else
+                     0
+                   end
+      new_ws_len += (problem[:arrow_column] - problem[:token].column)
     end
 
-    end_param_idx = tokens.index(problem[:token].prev_code_token)
-    start_param_idx = tokens.index(problem[:token].prev_token_of([:INDENT, :NEWLINE])) + 1
-    param_length = tokens[start_param_idx..end_param_idx].map { |r| r.to_manifest.length }.reduce(0) { |sum, x| sum + x }
-    new_ws_len = (problem[:arrow_column] - (problem[:newline_indent] + param_length + 1))
+    raise PuppetLint::NoFix if new_ws_len < 0
     new_ws = ' ' * new_ws_len
 
     if problem[:token].prev_token.type == :WHITESPACE

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

@@ -20,6 +20,8 @@ PuppetLint.new_check(:trailing_whitespace) do
   end
 
   def fix(problem)
+    return if problem[:token].nil?
+
     prev_token = problem[:token].prev_token
     next_token = problem[:token].next_token
     prev_token.next_token = next_token

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '2.3.5'.freeze
+  VERSION = '2.3.6'.freeze
 end

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

@@ -1,22 +1,37 @@
 require 'spec_helper'
 
 describe 'arrow_on_right_operand_line' do
+  msg = "arrow should be on the right operand's line"
+
   { 'chain' => '->', 'subscribe chain' => '~>' }.each do |name, operator|
     context "#{name} operator" do
       context 'both operands on same line' do
-        let(:code) { "Package['httpd'] #{operator} Service['httpd']" }
+        let(:code) do
+          <<-END
+            Package['httpd'] #{operator} Service['httpd']
+          END
+        end
 
-        it { expect(problems).to have(0).problems }
+        it 'should not detect any problems' do
+          expect(problems).to have(0).problems
+        end
       end
 
       context 'arrow on the line of left operand' do
         let(:code) do
-          "
+          <<-END
             Package['httpd']  #{operator}
-            Service['httpd']"
+            Service['httpd']
+          END
         end
 
-        it { expect(problems).to have(1).problems }
+        it 'should detect a 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(31)
+        end
 
         context 'with fix enabled' do
           before do
@@ -28,12 +43,19 @@ describe 'arrow_on_right_operand_line' do
           end
 
           let(:fixed) do
-            "
-            Package['httpd']
-            #{operator} Service['httpd']"
+            <<-END.gsub(%r{^ {2}}, '')
+              Package['httpd']
+              #{operator} Service['httpd']
+            END
+          end
+
+          it 'should fix the problem' do
+            expect(problems).to contain_fixed(msg).on_line(1).in_column(31)
           end
 
-          it { expect(manifest).to eq(fixed) }
+          it 'should move the arrow to before the right operand' do
+            expect(manifest).to eq(fixed)
+          end
         end
       end
 
@@ -45,7 +67,99 @@ describe 'arrow_on_right_operand_line' do
           END
         end
 
-        it { expect(problems).to have(0).problems }
+        it 'should not detect any problems' do
+          expect(problems).to have(0).problems
+        end
+      end
+
+      context 'arrow on the line of left operand with comment in between' do
+        let(:code) do
+          <<-END
+            Package['httpd'] #{operator}
+
+            # a comment
+            # another comment
+            Service['httpd']
+          END
+        end
+
+        it 'should detect a 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(30)
+        end
+
+        context 'with fix enabled' do
+          before(:each) do
+            PuppetLint.configuration.fix = true
+          end
+
+          after(:each) do
+            PuppetLint.configuration.fix = false
+          end
+
+          let(:fixed) do
+            <<-END.gsub(%r{^ {2}}, '')
+              Package['httpd']
+
+              # a comment
+              # another comment
+              #{operator} Service['httpd']
+            END
+          end
+
+          it 'should fix the problem' do
+            expect(problems).to contain_fixed(msg).on_line(1).in_column(30)
+          end
+
+          it 'should move the arrow to before the right operand' do
+            expect(manifest).to eq(fixed)
+          end
+        end
+      end
+
+      context 'arrow on the line of the left operand with a comment following the arrow' do
+        let(:code) do
+          <<-END
+            Package['httpd'] #{operator} # something
+            Service['httpd']
+          END
+        end
+
+        it 'should detect a 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(30)
+        end
+
+        context 'with fix enabled' do
+          before(:each) do
+            PuppetLint.configuration.fix = true
+          end
+
+          after(:each) do
+            PuppetLint.configuration.fix = false
+          end
+
+          let(:fixed) do
+            <<-END.gsub(%r{^ {2}}, '')
+              Package['httpd'] # something
+              #{operator} Service['httpd']
+            END
+          end
+
+          it 'should fix the problem' do
+            expect(problems).to contain_fixed(msg).on_line(1).in_column(30)
+          end
+
+          it 'should move the arrow to before the right operand' do
+            expect(manifest).to eq(fixed)
+          end
+        end
       end
     end
   end

data/spec/puppet-lint/plugins/check_whitespace/arrow_alignment_spec.rb

@@ -967,5 +967,42 @@ describe 'arrow_alignment' do
         expect(manifest).to eq(fixed)
       end
     end
+
+    context 'negative argument' do
+      let(:code) do
+        <<-END
+          res { 'a':
+            x => { 'a' => '',
+              'ab' => '',
+            }
+          }
+        END
+      end
+
+      # TODO: This is not the desired behaviour, but adjusting the check to
+      # properly format the hashes will need to wait until a major version
+      # bump.
+      let(:fixed) do
+        <<-END
+          res { 'a':
+            x => { 'a' => '',
+              'ab'     => '',
+            }
+          }
+        END
+      end
+
+      it 'should detect a problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the problems' do
+        expect(problems).to contain_fixed(format(msg, 24, 20)).on_line(3).in_column(20)
+      end
+
+      it 'should realign the arrows' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-lint
 version: !ruby/object:Gem::Version
-  version: 2.3.5
+  version: 2.3.6
 platform: ruby
 authors:
 - Tim Sharpe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-27 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Checks your Puppet manifests against the Puppetlabs