puppet-lint-manifest_whitespace-check 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d91ac8fb2a3196f56aa2e30c76acdfa62f1b318
+  data.tar.gz: a8a98d0f46aada6c955650901e3fe9cdec2b565d
+SHA512:
+  metadata.gz: f1bd0c7f396ce8307204b2fbb4b843cf570fecc32181a0c1ddf6095f60642f3518a072508d496d5b3af9fd84581180340736b1f212e41be3b64d3d9253807d1d
+  data.tar.gz: d3484a2404a91a7d558a1a8fb57c95e42f26abd43a8db0d5ba98cb6bdaefea39048b353cdf269dac72df4eeaca873759775117548d52c65c9c48088042798dcb

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Tim Sharpe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# puppet-lint manifest whitespace check
+
+Adds a new puppet-lint check to verify a number of whitespace issues (newlines etc.)
+
+These checks are very opinionated.
+
+**--fix support: Yes**
+
+## Installation
+
+To use this plugin, add the following line to the Gemfile in your Puppet code
+base and run `bundle install`.
+
+```ruby
+gem 'puppet-lint-manifest_whitespace-check'
+```
+
+## Usage
+
+This plugin provides a number of new checks to `puppet-lint`.
+
+### manifest_whitespace_class_opening_curly_brace
+
+> There should be a single space before the opening curly bracket of a class body.
+
+Good examples:
+
+```puppet
+class myclass (
+  # the parameters
+) {
+  # the body
+}
+
+class myclass {
+  # the body
+}
+```
+
+Bad examples:
+
+```puppet
+class myclass (
+  # the parameters
+)
+{
+  # the body
+}
+
+class myclass (
+  # the parameters
+){
+  # the body
+}
+
+class myclass
+{
+  # the body
+}
+```
+
+### manifest_whitespace_missing_newline_end_of_file
+
+> There should be a single newline at the end of a manifest.
+
+Not zero, not two or more. Be advised: this single newline is implicit at the end of your last line of code. This check does not add a single empty line!
+
+### manifest_whitespace_double_newline_end_of_file
+
+> There should be a single newline at the end of a manifest.
+
+Not zero, not two or more. Be advised: this single newline is implicit at the end of your last line of code. This check does not add a single empty line!
+
+### manifest_whitespace_arrows_single_space_after
+
+> There should be a single space after an arrow.
+
+When you list resource parameters or build a hash, you usually use arrow operators (`=>`). There are checks that make sure your arrows are aligned, but this check will ensure the number of spaces after your arrows is consistently 1.
+
+### manifest_whitespace_newline_beginning_of_file
+
+> There should not be a newline at the beginning of a manifest.
+
+There should not be empty lines at the beginning of your file.
+
+### manifest_whitespace_class_name_single_space_before
+
+> There should be a single space between the class or defined resource statement and the name.
+
+Good examples:
+
+```puppet
+class myclass (
+  # the parameters
+) {
+  # the body
+}
+
+class myclass {
+  # the body
+}
+```
+
+Bad example:
+
+```puppet
+class  myclass (
+  # the parameters
+) {
+  # the body
+}
+```
+
+### manifest_whitespace_class_name_single_space_after
+
+> There should be a single space between the class or resource name and the first bracket.
+
+Good examples:
+
+```puppet
+class myclass (
+  # the parameters
+) {
+  # the body
+}
+
+class myclass {
+  # the body
+}
+```
+
+Bad example:
+
+```puppet
+class myclass(
+  # the parameters
+){
+  # the body
+}
+
+class myclass  (
+  # the parameters
+){
+  # the body
+}
+
+class myclass
+(
+  # the parameters
+){
+  # the body
+}
+```

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_arrows_single_space_after) do
+  def check
+    tokens.select { |token| token.type == :FARROW }.each do |token|
+      next_token = token.next_token
+
+      next unless next_token && !is_single_space(next_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space after an arrow',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+
+    if token.type == :WHITESPACE
+      token.value = ' '
+      return
+    end
+
+    add_token(tokens.index(token), new_single_space)
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_class_name_single_space_before) do
+  def check
+    (class_indexes + defined_type_indexes).each do |class_idx|
+      class_token = class_idx[:tokens].first
+      name_token = class_token.next_token_of(:NAME)
+      next unless name_token
+
+      next_token = class_token.next_token
+      next unless tokens.index(name_token) != tokens.index(class_token) + 2 ||
+                  !is_single_space(next_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space between the class or defined resource statement and the name',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    raise PuppetLint::NoFix if problem[:token].type != :WHITESPACE
+
+    problem[:token].value = ' '
+  end
+end
+
+PuppetLint.new_check(:manifest_whitespace_class_name_single_space_after) do
+  def check
+    (class_indexes + defined_type_indexes).each do |class_idx|
+      class_token = class_idx[:tokens].first
+      name_token = class_token.next_token_of(:NAME)
+      next unless name_token
+
+      next_token = name_token.next_token
+      bracket_token = name_token.next_token_of(%i[LPAREN LBRACE])
+      next unless tokens.index(name_token) != tokens.index(bracket_token) - 2 ||
+                  !is_single_space(next_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space between the class or resource name and the first bracket',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    bracket_token = token.prev_token.next_token_of(%i[LPAREN LBRACE])
+
+    if token == bracket_token
+      add_token(tokens.index(bracket_token), new_single_space)
+      return
+    end
+
+    while token != bracket_token
+      unless %i[WHITESPACE INDENT NEWLINE].include?(token.type)
+        raise PuppetLint::NoFix
+      end
+
+      remove_token(token)
+      token = token.next_token
+    end
+
+    add_token(tokens.index(bracket_token), new_single_space)
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_class_opening_curly_brace) do
+  def check
+    (class_indexes + defined_type_indexes).each do |class_idx|
+      class_token = class_idx[:tokens].first
+      bracket_token = class_token.next_token_of(:LBRACE)
+      prev_token = bracket_token.prev_token
+      prev_code_token = bracket_token.prev_token_of(:RPAREN)
+
+      next unless prev_code_token
+      next unless tokens.index(prev_code_token) != tokens.index(bracket_token) - 2 ||
+                  !is_single_space(prev_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space before the opening curly bracket of a class body',
+        line: bracket_token.line,
+        column: bracket_token.column,
+        token: bracket_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    prev_code_token = token.prev_token_of(:RPAREN).next_token
+
+    while token != prev_code_token
+      unless %i[WHITESPACE INDENT NEWLINE].include?(prev_code_token.type)
+        raise PuppetLint::NoFix
+      end
+
+      remove_token(prev_code_token)
+      prev_code_token = prev_code_token.next_token
+    end
+
+    add_token(tokens.index(token), new_single_space)
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_newline_beginning_of_file) do
+  def check
+    tokens.each do |token|
+      return if token.type != :NEWLINE
+
+      notify(
+        :error,
+        message: 'there should not be a newline at the beginning of a manifest',
+        line: token.line,
+        column: token.column,
+        token: token,
+      )
+    end
+  end
+
+  def fix(problem)
+    remove_token(problem[:token])
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_missing_newline_end_of_file) do
+  def check
+    last_token = tokens.last
+
+    if last_token.type != :NEWLINE
+      notify(
+        :error,
+        message: 'there should be a single newline at the end of a manifest',
+        line: last_token.line,
+        column: last_token.column,
+        token: last_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    index = tokens.index(problem[:token])
+    tokens.insert(index + 1, PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0))
+  end
+end
+
+PuppetLint.new_check(:manifest_whitespace_double_newline_end_of_file) do
+  def check
+    last_token = tokens.last
+
+    if last_token.type == :NEWLINE
+      while last_token.prev_token && last_token.prev_token.type == :NEWLINE
+        notify(
+          :error,
+          message: 'there should be a single newline at the end of a manifest',
+          line: last_token.line,
+          column: last_token.column,
+          token: last_token,
+        )
+
+        last_token = last_token.prev_token
+      end
+    end
+  end
+
+  def fix(problem)
+    tokens.delete(problem[:token])
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+def is_single_space(token)
+  token.type == :WHITESPACE && token.value == ' '
+end
+
+def new_single_space
+  PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', 0, 0)
+end

data/spec/puppet-lint/plugins/manifest_whitespace_arrow_spaces_spec.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'manifest_whitespace_arrows_single_space_after' do
+  let(:single_space_msg) { 'there should be a single space after an arrow' }
+
+  context 'with two spaces' do
+    let(:code) do
+      <<~EOF
+        class { 'example2':
+          param1 =>  'value1',
+        }
+      EOF
+    end
+
+    context 'with fix disabled' do
+      it 'should detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should create a error' do
+        expect(problems).to contain_error(single_space_msg).on_line(2).in_column(12)
+      end
+    end
+
+    context 'with fix enabled' do
+      before do
+        PuppetLint.configuration.fix = true
+      end
+
+      after do
+        PuppetLint.configuration.fix = false
+      end
+
+      it 'should detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(single_space_msg)
+      end
+
+      it 'should fix the space' do
+        expect(manifest).to eq(
+          <<~EOF,
+            class { 'example2':
+              param1 => 'value1',
+            }
+          EOF
+        )
+      end
+    end
+  end
+
+  context 'with no spaces' do
+    let(:code) do
+      <<~EOF
+        class { 'example2':
+          param1 =>'value1',
+        }
+      EOF
+    end
+
+    context 'with fix disabled' do
+      it 'should detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should create a error' do
+        expect(problems).to contain_error(single_space_msg).on_line(2).in_column(12)
+      end
+    end
+
+    context 'with fix enabled' do
+      before do
+        PuppetLint.configuration.fix = true
+      end
+
+      after do
+        PuppetLint.configuration.fix = false
+      end
+
+      it 'should detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(single_space_msg)
+      end
+
+      it 'should fix the space' do
+        expect(manifest).to eq(
+          <<~EOF,
+            class { 'example2':
+              param1 => 'value1',
+            }
+          EOF
+        )
+      end
+    end
+  end
+
+  context 'with string as space' do
+    let(:code) do
+      <<~EOF
+        class { 'example2':
+          param1 =>' ',
+        }
+      EOF
+    end
+
+    context 'with fix disabled' do
+      it 'should detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should create a error' do
+        expect(problems).to contain_error(single_space_msg).on_line(2).in_column(12)
+      end
+    end
+
+    context 'with fix enabled' do
+      before do
+        PuppetLint.configuration.fix = true
+      end
+
+      after do
+        PuppetLint.configuration.fix = false
+      end
+
+      it 'should detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(single_space_msg)
+      end
+
+      it 'should fix the space' do
+        expect(manifest).to eq(
+          <<~EOF,
+            class { 'example2':
+              param1 => ' ',
+            }
+          EOF
+        )
+      end
+    end
+  end
+
+  context 'many resources' do
+    let(:code) do
+      <<~EOF
+        class { 'example2':
+          param1 =>'value1',
+          param2 => 'value2',
+          param3 =>   'value3',
+          param4 =>  'value4',
+        }
+      EOF
+    end
+
+    context 'with fix disabled' do
+      it 'should detect a single problem' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create a error' do
+        expect(problems).to contain_error(single_space_msg).on_line(2).in_column(12)
+        expect(problems).to contain_error(single_space_msg).on_line(4).in_column(12)
+        expect(problems).to contain_error(single_space_msg).on_line(5).in_column(12)
+      end
+    end
+
+    context 'with fix enabled' do
+      before do
+        PuppetLint.configuration.fix = true
+      end
+
+      after do
+        PuppetLint.configuration.fix = false
+      end
+
+      it 'should detect a single problem' do
+        expect(problems).to have(3).problem
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(single_space_msg)
+      end
+
+      it 'should fix the space' do
+        expect(manifest).to eq(
+          <<~EOF,
+            class { 'example2':
+              param1 => 'value1',
+              param2 => 'value2',
+              param3 => 'value3',
+              param4 => 'value4',
+            }
+          EOF
+        )
+      end
+    end
+  end
+
+  context 'valid cases' do
+    context 'correct arrow' do
+      let(:code) do
+        <<~EOF
+          class { 'example2':
+            param1 => 'value1',
+          }
+        EOF
+      end
+
+      it 'should detect a no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'in a string' do
+      let(:code) do
+        <<~EOF
+          "param1 =>    'value1'",
+        EOF
+      end
+
+      it 'should detect a no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'in a heredoc' do
+      let(:code) do
+        <<~EOF
+          $data = @("DATA"/L)
+            param1 =>    'value1',
+            | DATA
+        EOF
+      end
+
+      it 'should detect a no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+  end
+end