puppet-lint-absolute_classname-check 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8151b5f2ac93aa1535818002c3f0a9a506c2de42a4e48c34aa178de66e306f77
-  data.tar.gz: 35557e3d473126306e915a2938d1f76c7e63894e8f037ec441989380cf93afd8
+  metadata.gz: 0f8457df6a20dcdc3263f3a9d07c24a46affe2ead023a08da5ae0ed52dc22763
+  data.tar.gz: 34e1a29a81bffae3cdcb73d47837576778d3ca36146d196822e7b59795b06254
 SHA512:
-  metadata.gz: 258fdd9e006ba53677ffcf094656e8ee4d2a8e5578e0cac65add4be569a91f7c9bf27728199dd5705e4de350f58a363d2244c8ab69bb149ff25498192bfa1b5e
-  data.tar.gz: 9ece5d2055e39f6dd4cbe737d9aad9627b2bb22a3c2bd598d1cd32a2381e5f978a5522f4bd36de9c48d0b3feaa5cca3291f368ca47404a2f0d03d410482fee8d
+  metadata.gz: 8f84c2b01a0d6d5eaa56279b24459889f3e00be262dfb931c9e5ad0f9b9f24bc7b4eeb7c8975d7e66ddea506837828a82b0f8fc1968cf8afb8886f6ff70b9e0c
+  data.tar.gz: 2a804b84105435ff4be5e344e2b9cb95270c7d3ecda64e733cff498eb77f4379988119504b8a7f7a66599af2998c7ef91d1a07b491bfb7b9f6062bc5ac0fa62a

data/README.md

@@ -5,7 +5,6 @@ puppet-lint-absolute_classname-check
 [![Gem Version](https://img.shields.io/gem/v/puppet-lint-absolute_classname-check.svg)](https://rubygems.org/gems/puppet-lint-absolute_classname-check)
 [![Gem Downloads](https://img.shields.io/gem/dt/puppet-lint-absolute_classname-check.svg)](https://rubygems.org/gems/puppet-lint-absolute_classname-check)
 [![Coverage Status](https://img.shields.io/coveralls/voxpupuli/puppet-lint-absolute_classname-check.svg)](https://coveralls.io/r/voxpupuli/puppet-lint-absolute_classname-check?branch=master)
-[![Gemnasium](https://img.shields.io/gemnasium/voxpupuli/puppet-lint-absolute_classname-check.svg)](https://gemnasium.com/voxpupuli/puppet-lint-absolute_classname-check)
 [![Donated by Camptocamp](https://img.shields.io/badge/donated%20by-camptocamp-fb7047.svg)](#transfer-notice)
 
 A puppet-lint plugin to check that classes are included by their absolute name.
@@ -39,26 +38,18 @@ gem 'puppet-lint-absolute_classname-check', :require => false
 
 ### Relative class name inclusion
 
-Including a class by a relative name might lead to unexpected results [in Puppet 3](https://docs.puppet.com/puppet/3/lang_namespaces.html#relative-name-lookup-and-incorrect-name-resolution).
+Including a class by a relative name might lead to unexpected results [in Puppet 3](https://docs.puppet.com/puppet/3/lang_namespaces.html#relative-name-lookup-and-incorrect-name-resolution). That's why a lot of manifests explicitly include by the absolute name. Since Puppet 4 names are always absolute and this is no longer needed. This lint check helps to clean up your manifests.
 
 #### What you have done
 
 ```puppet
-include foobar
+include ::foobar
 ```
 
 #### What you should have done
 
 ```puppet
-include ::foobar
-```
-
-#### Reverse this check
-
-This check can be reversed to check for Puppet > 4.
-
-```ruby
-PuppetLint.configuration.absolute_classname_reverse = true
+include foobar
 ```
 
 #### Disabling the check
@@ -87,7 +78,6 @@ Previously: https://github.com/camptocamp/puppet-lint-absolute_classname-check
 
 To make a new release, please do:
 * Update the version in the `puppet-lint-absolute_classname-check.gemspec` file
-* Update the version in the Rakefile
 * Install gems with `bundle install --with release --path .vendor`
 * generate the changelog with `bundle exec rake changelog`
 * Create a PR with it

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

@@ -1,14 +1,8 @@
 PuppetLint.new_check(:relative_classname_inclusion) do
   def check
+    message = 'class included by absolute name (::$class)'
+
     tokens.each_with_index do |token, token_idx|
-      reverse = PuppetLint.configuration.absolute_classname_reverse || false
-      if reverse
-        pattern = '^(?!::)'
-        message = 'class included by absolute name (::$class)'
-      else
-        pattern = '^::'
-        message = 'class included by relative name'
-      end
       if [:NAME,:FUNCTION_NAME].include?(token.type) && ['include','contain','require'].include?(token.value)
         s = token.next_code_token
         next if s.nil?
@@ -22,7 +16,7 @@ PuppetLint.new_check(:relative_classname_inclusion) do
               in_function += 1
             elsif in_function > 0 && n && n.type == :RPAREN
               in_function -= 1
-            elsif in_function.zero? && s.value !~ /#{pattern}/
+            elsif in_function.zero? && s.value.start_with?('::')
               notify :warning, {
                 message: message,
                 line: s.line,
@@ -36,7 +30,7 @@ PuppetLint.new_check(:relative_classname_inclusion) do
       elsif token.type == :CLASS and token.next_code_token.type == :LBRACE
         s = token.next_code_token
         while s.type != :COLON
-          if (s.type == :NAME || s.type == :SSTRING) && s.value !~ /#{pattern}/
+          if (s.type == :NAME || s.type == :SSTRING) && s.value.start_with?('::')
             notify :warning, {
               message: message,
               line: s.line,
@@ -51,11 +45,6 @@ PuppetLint.new_check(:relative_classname_inclusion) do
   end
 
   def fix(problem)
-    reverse = PuppetLint.configuration.absolute_classname_reverse || false
-    problem[:token].value = if reverse
-                              problem[:token].value[2..-1]
-                            else
-                              '::' + problem[:token].value
-                            end
+    problem[:token].value = problem[:token].value[2..-1]
   end
 end

data/spec/puppet-lint/plugins/check_absolute_classname/relative_classname_inclusion_spec.rb

@@ -1,419 +1,202 @@
 require 'spec_helper'
 
 describe 'relative_classname_inclusion' do
-  describe '(default)' do
-    let(:msg) { 'class included by relative name' }
-
-    context 'with fix disabled' do
-      context 'when absolute names are used' do
-        let(:code) do
-          <<-EOS
-          include ::foobar
-          include('::foobar')
-          include(foobar(baz))
-          include(foobar('baz'))
-
-          include ::foo, ::bar
-          include('::foo', '::bar')
-
-          class { '::foobar': }
-
-          class foobar {
-          }
-
-          contain ::foobar
-          contain('::foobar')
-          contain(foobar(baz))
-          contain(foobar('baz'))
-
-          require ::foobar
-          require('::foobar')
-          require(foobar(baz))
-          require(foobar('baz'))
-          EOS
-        end
-
-        it 'should not detect any problems' do
-          expect(problems).to have(0).problems
-        end
-      end
+  let(:msg) { 'class included by absolute name (::$class)' }
+
+  context 'with fix disabled' do
+    context 'when absolute names are used' do
+      let(:code) do
+        <<-EOS
+        include ::foobar
+        include('::foobar')
+        include(foobar(baz))
+        include(foobar('baz'))
+
+        include ::foo, ::bar
+        include('::foo', '::bar')
+
+        class { '::foobar': }
 
-      context 'when relative names are used' do
-        let(:code) do
-          <<-EOS
-          include foobar
-          include(foobar)
-          class { 'foobar': }
-          contain foobar
-          contain(foobar)
-          require foobar
-          require(foobar)
-          EOS
-        end
-
-        it 'should detect 7 problems' do
-          expect(problems).to have(7).problems
-        end
-
-        it 'should create warnings' do
-          expect(problems).to contain_warning(msg).on_line(1).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(2).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(3).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(4).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(5).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(6).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(7).in_column(19)
-        end
+        class foobar {
+        }
+
+        contain ::foobar
+        contain('::foobar')
+        contain(foobar(baz))
+        contain(foobar('baz'))
+
+        require ::foobar
+        require('::foobar')
+        require(foobar(baz))
+        require(foobar('baz'))
+        EOS
       end
 
-      context 'when the require metadata parameter is used' do
-        let(:code) do
-          <<-EOS
-          file { '/path':
-            ensure  => present,
-            require => Shellvar['http_proxy'],
-          }
-          EOS
-        end
-
-        it 'should detect no problems' do
-          expect(problems).to have(0).problems
-        end
+      it 'should detect 11 problems' do
+        expect(problems).to have(11).problems
       end
 
-      context 'when require is a hash key' do
-        let(:code) do
-          <<-EOS
-          $defaults = {
-            require => Exec['apt_update'],
-          }
-          $defaults = {
-            'require' => Exec['apt_update'],
-          }
-          EOS
-        end
-
-        it 'should detect no problems' do
-          expect(problems).to have(0).problems
-        end
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(2).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(6).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(6).in_column(24)
+        expect(problems).to contain_warning(msg).on_line(7).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(7).in_column(26)
+        expect(problems).to contain_warning(msg).on_line(9).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(14).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(15).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(19).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(20).in_column(17)
       end
     end
 
-    context 'with fix enabled' do
-      before do
-        PuppetLint.configuration.fix = true
+    context 'when relative names are used' do
+      let(:code) do
+        <<-EOS
+        include foobar
+        include(foobar)
+        class { 'foobar': }
+        contain foobar
+        contain(foobar)
+        require foobar
+        require(foobar)
+        EOS
       end
 
-      after do
-        PuppetLint.configuration.fix = false
+      it 'should not detect a problem' do
+        expect(problems).to have(0).problems
       end
+    end
 
-      context 'when absolute names are used' do
-        let(:code) do
-          <<-EOS
-          include ::foobar
-          include('::foobar')
-          include(foobar(baz))
-          include(foobar('baz'))
-
-          include ::foo, ::bar
-          include('::foo', '::bar')
-
-          class { '::foobar': }
-
-          class foobar {
-          }
-
-          contain ::foobar
-          contain('::foobar')
-          contain(foobar(baz))
-          contain(foobar('baz'))
-
-          require ::foobar
-          require('::foobar')
-          require(foobar(baz))
-          require(foobar('baz'))
-          EOS
-        end
-
-        it 'should not detect any problems' do
-          expect(problems).to have(0).problems
-        end
+    context 'when the require metadata parameter is used' do
+      let(:code) do
+        <<-EOS
+        file { '/path':
+          ensure  => present,
+          require => Shellvar['http_proxy'],
+        }
+        EOS
       end
 
-      context 'when relative names are used' do
-        let(:code) do
-          <<-EOS
-          include foobar
-          include(foobar)
-          class { 'foobar': }
-          contain foobar
-          contain(foobar)
-          require foobar
-          require(foobar)
-          EOS
-        end
-
-        it 'should detect 7 problems' do
-          expect(problems).to have(7).problems
-        end
-
-        it 'should fix the problems' do
-          expect(problems).to contain_fixed(msg).on_line(1).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(2).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(3).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(4).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(5).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(6).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(7).in_column(19)
-        end
-
-        it 'should should add colons' do
-          expect(manifest).to eq(
-          <<-EOS
-          include ::foobar
-          include(::foobar)
-          class { '::foobar': }
-          contain ::foobar
-          contain(::foobar)
-          require ::foobar
-          require(::foobar)
-          EOS
-          )
-        end
+      it 'should detect no problems' do
+        expect(problems).to have(0).problems
       end
     end
 
-    describe '(#12) behavior of lookup("foo", {merge => unique}).include' do
-      let(:msg) { '(#12) class included with lookup("foo", {merge => unique}).include' }
-
+    context 'when require is a hash key' do
       let(:code) do
         <<-EOS
-        lookup(foo, {merge => unique}).include
+        $defaults = {
+          require => Exec['apt_update'],
+        }
+        $defaults = {
+          'require' => Exec['apt_update'],
+        }
         EOS
       end
 
-      it 'should not detect any problems' do
+      it 'should detect no problems' do
         expect(problems).to have(0).problems
       end
     end
   end
 
-  describe '(reversed)' do
+  context 'with fix enabled' do
     before do
-      PuppetLint.configuration.absolute_classname_reverse = true
+      PuppetLint.configuration.fix = true
     end
-    let(:msg) { 'class included by absolute name (::$class)' }
-
-    context 'with fix disabled' do
-      context 'when absolute names are used' do
-        let(:code) do
-          <<-EOS
-          include ::foobar
-          include('::foobar')
-          include(foobar(baz))
-          include(foobar('baz'))
-
-          include ::foo, ::bar
-          include('::foo', '::bar')
-
-          class { '::foobar': }
-
-          class foobar {
-          }
-
-          contain ::foobar
-          contain('::foobar')
-          contain(foobar(baz))
-          contain(foobar('baz'))
-
-          require ::foobar
-          require('::foobar')
-          require(foobar(baz))
-          require(foobar('baz'))
-          EOS
-        end
-
-        it 'should detect 11 problems' do
-          expect(problems).to have(11).problems
-        end
-
-        it 'should create warnings' do
-          expect(problems).to contain_warning(msg).on_line(1).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(2).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(6).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(6).in_column(26)
-          expect(problems).to contain_warning(msg).on_line(7).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(7).in_column(28)
-          expect(problems).to contain_warning(msg).on_line(9).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(14).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(15).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(19).in_column(19)
-          expect(problems).to contain_warning(msg).on_line(20).in_column(19)
-        end
-      end
 
-      context 'when relative names are used' do
-        let(:code) do
-          <<-EOS
-          include foobar
-          include(foobar)
-          class { 'foobar': }
-          contain foobar
-          contain(foobar)
-          require foobar
-          require(foobar)
-          EOS
-        end
-
-        it 'should not detect a problem' do
-          expect(problems).to have(0).problems
-        end
-      end
+    after do
+      PuppetLint.configuration.fix = false
+    end
 
-      context 'when the require metadata parameter is used' do
-        let(:code) do
-          <<-EOS
-          file { '/path':
-            ensure  => present,
-            require => Shellvar['http_proxy'],
-          }
-          EOS
-        end
-
-        it 'should detect no problems' do
-          expect(problems).to have(0).problems
-        end
-      end
+    context 'when absolute names are used' do
+      let(:code) do
+        <<-EOS
+        include ::foobar
+        include('::foobar')
+        include(foobar(baz))
+        include(foobar('baz'))
 
-      context 'when require is a hash key' do
-        let(:code) do
-          <<-EOS
-          $defaults = {
-            require => Exec['apt_update'],
-          }
-          $defaults = {
-            'require' => Exec['apt_update'],
-          }
-          EOS
-        end
-
-        it 'should detect no problems' do
-          expect(problems).to have(0).problems
-        end
-      end
-    end
+        include ::foo, ::bar
+        include('::foo', '::bar')
+
+        class { '::foobar': }
 
-    context 'with fix enabled' do
-      before do
-        PuppetLint.configuration.fix = true
+        class foobar {
+        }
+
+        contain ::foobar
+        contain('::foobar')
+        contain(foobar(baz))
+        contain(foobar('baz'))
+
+        require ::foobar
+        require('::foobar')
+        require(foobar(baz))
+        require(foobar('baz'))
+        EOS
       end
 
-      after do
-        PuppetLint.configuration.fix = false
+      it 'should detect 11 problems' do
+        expect(problems).to have(11).problems
       end
 
-      context 'when absolute names are used' do
-        let(:code) do
-          <<-EOS
-          include ::foobar
-          include('::foobar')
-          include(foobar(baz))
-          include(foobar('baz'))
-
-          include ::foo, ::bar
-          include('::foo', '::bar')
-
-          class { '::foobar': }
-
-          class foobar {
-          }
-
-          contain ::foobar
-          contain('::foobar')
-          contain(foobar(baz))
-          contain(foobar('baz'))
-
-          require ::foobar
-          require('::foobar')
-          require(foobar(baz))
-          require(foobar('baz'))
-          EOS
-        end
-
-        it 'should detect 11 problems' do
-          expect(problems).to have(11).problems
-        end
-
-        it 'should fix the problems' do
-          expect(problems).to contain_fixed(msg).on_line(1).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(2).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(6).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(6).in_column(26)
-          expect(problems).to contain_fixed(msg).on_line(7).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(7).in_column(28)
-          expect(problems).to contain_fixed(msg).on_line(9).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(14).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(15).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(19).in_column(19)
-          expect(problems).to contain_fixed(msg).on_line(20).in_column(19)
-        end
-
-        it 'should should remove colons' do
-          expect(manifest).to eq(
-          <<-EOS
-          include foobar
-          include('foobar')
-          include(foobar(baz))
-          include(foobar('baz'))
-
-          include foo, bar
-          include('foo', 'bar')
-
-          class { 'foobar': }
-
-          class foobar {
-          }
-
-          contain foobar
-          contain('foobar')
-          contain(foobar(baz))
-          contain(foobar('baz'))
-
-          require foobar
-          require('foobar')
-          require(foobar(baz))
-          require(foobar('baz'))
-          EOS
-          )
-        end
+      it 'should fix the problems' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(2).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(6).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(6).in_column(24)
+        expect(problems).to contain_fixed(msg).on_line(7).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(7).in_column(26)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(14).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(15).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(19).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(20).in_column(17)
       end
 
-      context 'when relative names are used' do
-        let(:code) do
-          <<-EOS
-          include foobar
-          include(foobar)
-          class { 'foobar': }
-          contain foobar
-          contain(foobar)
-          require foobar
-          require(foobar)
-          EOS
-        end
-
-        it 'should not detect any problems' do
-          expect(problems).to have(0).problems
-        end
+      it 'should should remove colons' do
+        expect(manifest).to eq(
+        <<-EOS
+        include foobar
+        include('foobar')
+        include(foobar(baz))
+        include(foobar('baz'))
+
+        include foo, bar
+        include('foo', 'bar')
+
+        class { 'foobar': }
+
+        class foobar {
+        }
+
+        contain foobar
+        contain('foobar')
+        contain(foobar(baz))
+        contain(foobar('baz'))
+
+        require foobar
+        require('foobar')
+        require(foobar(baz))
+        require(foobar('baz'))
+        EOS
+        )
       end
     end
 
-    describe '(#12) behavior of lookup("foo", {merge => unique}).include' do
-      let(:msg) { '(#12) class included with lookup("foo", {merge => unique}).include' }
-
+    context 'when relative names are used' do
       let(:code) do
         <<-EOS
-        lookup(foo, {merge => unique}).include
+        include foobar
+        include(foobar)
+        class { 'foobar': }
+        contain foobar
+        contain(foobar)
+        require foobar
+        require(foobar)
         EOS
       end
 
@@ -422,4 +205,18 @@ describe 'relative_classname_inclusion' do
       end
     end
   end
+
+  describe '(#12) behavior of lookup("foo", {merge => unique}).include' do
+    let(:msg) { '(#12) class included with lookup("foo", {merge => unique}).include' }
+
+    let(:code) do
+      <<-EOS
+      lookup(foo, {merge => unique}).include
+      EOS
+    end
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,5 @@
-unless RUBY_VERSION =~ /^1\.8/
-  require 'coveralls'
-  Coveralls.wear!
-end
+require 'coveralls'
+Coveralls.wear!
 
 require 'puppet-lint'
-
 PuppetLint::Plugins.load_spec_helper

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-lint-absolute_classname-check
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Vox Pupuli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-09 00:00:00.000000000 Z
+date: 2019-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet-lint
@@ -44,20 +44,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mime-types
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -138,14 +124,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubyforge_project: 
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A puppet-lint plugin to check that classes are included by their absolute