puppet-lint-absolute_classname-check 0.2.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4532e4c27bf29b9453d7eec0a3f4c8422a67fa96df7860ed9da6e3ebf563064
-  data.tar.gz: 3682dba2b87f038de61698113b4613f2920e7aea24df9b1b8668d7c67dc50c14
+  metadata.gz: 8151b5f2ac93aa1535818002c3f0a9a506c2de42a4e48c34aa178de66e306f77
+  data.tar.gz: 35557e3d473126306e915a2938d1f76c7e63894e8f037ec441989380cf93afd8
 SHA512:
-  metadata.gz: 361e65365e7e9b00825a6fb4008b98c049b611d662aef04991211f0df1f6ba02fab47cfd954ff39ca80778c6d66c39126c4b5cb4d1315aae052b1aad86a3c11e
-  data.tar.gz: 1dbf8a874f4c5e6f29ed49e587ee5a6e0ed0db80822b52a8d6d67d7c334dc0fd4842061e645f128233449ee4702f1aaf4f814db0f5d035e6f92e1fa17ddb838c
+  metadata.gz: 258fdd9e006ba53677ffcf094656e8ee4d2a8e5578e0cac65add4be569a91f7c9bf27728199dd5705e4de350f58a363d2244c8ab69bb149ff25498192bfa1b5e
+  data.tar.gz: 9ece5d2055e39f6dd4cbe737d9aad9627b2bb22a3c2bd598d1cd32a2381e5f978a5522f4bd36de9c48d0b3feaa5cca3291f368ca47404a2f0d03d410482fee8d

data/README.md

@@ -10,6 +10,17 @@ puppet-lint-absolute_classname-check
 
 A puppet-lint plugin to check that classes are included by their absolute name.
 
+
+## Table of contents
+
+* [Installing](#installing)
+  * [From the command line](#from-the-command-line)
+  * [In a Gemfile](#in-a-gemfile)
+* [Checks](#checks)
+  * [Relative class name inclusion](#relative-class-name-inclusion)
+* [Transfer notice](#transfer-notice)
+* [Release Informaion](#release-information)
+
 ## Installing
 
 ### From the command line
@@ -28,7 +39,7 @@ 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). This plugin is **not** recommended for use with Puppet code that has dropped support for Puppet 3 (EOL 20161231).
+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).
 
 #### What you have done
 
@@ -42,6 +53,14 @@ include foobar
 include ::foobar
 ```
 
+#### Reverse this check
+
+This check can be reversed to check for Puppet > 4.
+
+```ruby
+PuppetLint.configuration.absolute_classname_reverse = true
+```
+
 #### Disabling the check
 
 To disable this check, you can add `--no-relative_classname_inclusion-check` to your puppet-lint command line.
@@ -63,3 +82,13 @@ The maintainer preferred that Puppet Community take ownership of the module for
 Existing pull requests and issues were transferred over, please fork and continue to contribute here instead of Camptocamp.
 
 Previously: https://github.com/camptocamp/puppet-lint-absolute_classname-check
+
+## Release information
+
+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
+* After it got merged, push a tag. Travis will do the actual release

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

@@ -1,10 +1,19 @@
 PuppetLint.new_check(:relative_classname_inclusion) do
   def check
     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?
         next if s.type == :FARROW
+
         in_function = 0
         while s.type != :NEWLINE
           n = s.next_code_token
@@ -13,12 +22,12 @@ PuppetLint.new_check(:relative_classname_inclusion) do
               in_function += 1
             elsif in_function > 0 && n && n.type == :RPAREN
               in_function -= 1
-            elsif in_function == 0 && s.value !~ /^::/
+            elsif in_function.zero? && s.value !~ /#{pattern}/
               notify :warning, {
-                :message => 'class included by relative name',
-                :line    => s.line,
-                :column  => s.column,
-                :token   => s,
+                message: message,
+                line: s.line,
+                column: s.column,
+                token: s
               }
             end
           end
@@ -27,21 +36,26 @@ 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 !~ /^::/
+          if (s.type == :NAME || s.type == :SSTRING) && s.value !~ /#{pattern}/
             notify :warning, {
-              :message => 'class included by relative name',
-              :line    => s.line,
-              :column  => s.column,
-              :token   => s,
+              message: message,
+              line: s.line,
+              column: s.column,
+              token: s
             }
           end
           s = s.next_token
         end
       end
     end
-  end 
+  end
 
   def fix(problem)
-    problem[:token].value = '::'+problem[:token].value
+    reverse = PuppetLint.configuration.absolute_classname_reverse || false
+    problem[:token].value = if reverse
+                              problem[:token].value[2..-1]
+                            else
+                              '::' + problem[:token].value
+                            end
   end
 end

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

@@ -1,199 +1,425 @@
 require 'spec_helper'
 
 describe 'relative_classname_inclusion' do
-  let(:msg) { 'class included by relative name' }
+  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'))
+    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')
+          include ::foo, ::bar
+          include('::foo', '::bar')
 
-        class { '::foobar': }
+          class { '::foobar': }
 
-        class foobar {
-        }
+          class foobar {
+          }
 
-        contain ::foobar
-        contain('::foobar')
-        contain(foobar(baz))
-        contain(foobar('baz'))
+          contain ::foobar
+          contain('::foobar')
+          contain(foobar(baz))
+          contain(foobar('baz'))
 
-        require ::foobar
-        require('::foobar')
-        require(foobar(baz))
-        require(foobar('baz'))
-        EOS
-      end
+          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
+        it 'should not detect any problems' do
+          expect(problems).to have(0).problems
+        end
       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
+      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
       end
 
-      it 'should detect 7 problems' do
-        expect(problems).to have(7).problems
+      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
 
-      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(3).in_column(17)
-        expect(problems).to contain_warning(msg).on_line(4).in_column(17)
-        expect(problems).to contain_warning(msg).on_line(5).in_column(17)
-        expect(problems).to contain_warning(msg).on_line(6).in_column(17)
-        expect(problems).to contain_warning(msg).on_line(7).in_column(17)
+      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
 
-    context 'when the require metadata parameter is used' do
-      let(:code) do
-        <<-EOS
-        file { '/path':
-          ensure  => present,
-          require => Shellvar['http_proxy'],
-        }
-        EOS
+    context 'with fix enabled' do
+      before do
+        PuppetLint.configuration.fix = true
       end
 
-      it 'should detect no problems' do
-        expect(problems).to have(0).problems
+      after do
+        PuppetLint.configuration.fix = false
+      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
+      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
       end
     end
 
-    context 'when require is a hash key' do
+    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
-        $defaults = {
-          require => Exec['apt_update'],
-        }
-        $defaults = {
-          'require' => Exec['apt_update'],
-        }
+        lookup(foo, {merge => unique}).include
         EOS
       end
 
-      it 'should detect no problems' do
+      it 'should not detect any problems' do
         expect(problems).to have(0).problems
       end
     end
   end
 
-  context 'with fix enabled' do
+  describe '(reversed)' do
     before do
-      PuppetLint.configuration.fix = true
+      PuppetLint.configuration.absolute_classname_reverse = true
     end
+    let(:msg) { 'class included by absolute name (::$class)' }
 
-    after do
-      PuppetLint.configuration.fix = false
-    end
+    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'))
 
-    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')
 
-        include ::foo, ::bar
-        include('::foo', '::bar')
+          class { '::foobar': }
 
-        class { '::foobar': }
+          class foobar {
+          }
 
-        class foobar {
-        }
+          contain ::foobar
+          contain('::foobar')
+          contain(foobar(baz))
+          contain(foobar('baz'))
 
-        contain ::foobar
-        contain('::foobar')
-        contain(foobar(baz))
-        contain(foobar('baz'))
+          require ::foobar
+          require('::foobar')
+          require(foobar(baz))
+          require(foobar('baz'))
+          EOS
+        end
 
-        require ::foobar
-        require('::foobar')
-        require(foobar(baz))
-        require(foobar('baz'))
-        EOS
+        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
 
-      it 'should not detect any problems' do
-        expect(problems).to have(0).problems
+      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
+
+      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 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
 
-    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
+    context 'with fix enabled' do
+      before do
+        PuppetLint.configuration.fix = true
       end
 
-      it 'should detect 7 problems' do
-        expect(problems).to have(7).problems
+      after do
+        PuppetLint.configuration.fix = false
       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(3).in_column(17)
-        expect(problems).to contain_fixed(msg).on_line(4).in_column(17)
-        expect(problems).to contain_fixed(msg).on_line(5).in_column(17)
-        expect(problems).to contain_fixed(msg).on_line(6).in_column(17)
-        expect(problems).to contain_fixed(msg).on_line(7).in_column(17)
+      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
       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
-        )
+      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
       end
     end
-  end
 
-  describe '(#12) behavior of lookup("foo", {merge => unique}).include' do
-    let(:msg) { '(#12) class included with lookup("foo", {merge => unique}).include' }
+    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
+      let(:code) do
+        <<-EOS
+        lookup(foo, {merge => unique}).include
+        EOS
+      end
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-lint-absolute_classname-check
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Vox Pupuli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-06 00:00:00.000000000 Z
+date: 2019-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet-lint
@@ -114,8 +114,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |2
-      A puppet-lint plugin to check that classes are included by their absolute name.
+description: "    A puppet-lint plugin to check that classes are included by their
+  absolute name.\n"
 email: voxpupuli@groups.io
 executables: []
 extensions: []
@@ -145,12 +145,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: A puppet-lint plugin to check that classes are included by their absolute
   name.
 test_files:
-- spec/puppet-lint/plugins/check_absolute_classname/relative_classname_inclusion_spec.rb
 - spec/spec_helper.rb
+- spec/puppet-lint/plugins/check_absolute_classname/relative_classname_inclusion_spec.rb