puppet-lint-params_not_optional_with_undef-check 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e51d0fd67328a2d9e2eca7c0798c84900e18e4a7e23d51cbefc29bc7001a91b
+  data.tar.gz: 8d16522f020be9b8bf050bfc4f4acebbf11a36f8c498432fd57671c634d9e3c9
+SHA512:
+  metadata.gz: 4a3afe7e9ab3f25ae81f14c9fba670e900ae7ca25289c1aae372909ef4697f6b0fba77d9af39a804874b5d3ab4199231a785f95b7ab3ba5ff3fca4317a565bdc
+  data.tar.gz: 8e78e50a68fc44cdd039fe226f5d9ef67dc46a3850f468f29536d334480016261ad3ae8c01826541fa7ab5829b00a65e17cf72e71d67ae5d6462d62ca5afbf50

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Tim Meusel
+
+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,106 @@
+# puppet-lint-params_not_optional_with_undef-check
+
+[![License](https://img.shields.io/github/license/voxpupuli/puppet-lint-params_not_optional_with_undef-check.svg)](https://github.com/voxpupuli/puppet-lint-params_not_optional_with_undef-check/blob/master/LICENSE)
+[![Test](https://github.com/voxpupuli/puppet-lint-params_not_optional_with_undef-check/actions/workflows/test.yml/badge.svg)](https://github.com/voxpupuli/puppet-lint-params_not_optional_with_undef-check/actions/workflows/test.yml)
+[![Release](https://github.com/voxpupuli/puppet-lint-params_not_optional_with_undef-check/actions/workflows/release.yml/badge.svg)](https://github.com/voxpupuli/puppet-lint-params_not_optional_with_undef-check/actions/workflows/release.yml)
+[![RubyGem Version](https://img.shields.io/gem/v/puppet-lint-params_not_optional_with_undef-check.svg)](https://rubygems.org/gems/puppet-lint-params_not_optional_with_undef-check)
+[![RubyGem Downloads](https://img.shields.io/gem/dt/puppet-lint-params_not_optional_with_undef-check.svg)](https://rubygems.org/gems/puppet-lint-params_not_optional_with_undef-check)
+[![Donated by Tim Meusel](https://img.shields.io/badge/donated%20by-Tim%20%27bastelfreak%27%20Meusel-fb7047.svg)](#transfer-notice)
+
+A puppet-lint plugin to check for parameters without Optional as type but undef
+as value.
+
+## Installing
+
+### From the command line
+
+```shell
+$ gem install puppet-lint-params_not_optional_with_undef-check
+```
+
+### In a Gemfile
+
+```ruby
+gem 'puppet-lint-params_not_optional_with_undef-check', require: false
+```
+
+## Checks
+
+### Parameter assigned to the empty string
+
+According the the Vox Pupuli best practices, a class parameter with the string
+datatype should default to `undef` and not `''`, if it's optional. The
+recommendations are documented at [voxpupuli.org](https://voxpupuli.org/docs/reviewing_pr/).
+
+#### What you have done
+
+```puppet
+class foo (
+  String $bar = undef,
+) {
+  # logic
+}
+```
+
+#### What you should have done
+
+```puppet
+class foo (
+  Optional[String[1]] $bar = undef,
+) {
+  # logic
+}
+```
+
+or:
+
+```puppet
+class foo (
+  String[1] $bar = 'value',
+) {
+  # logic
+}
+```
+
+#### Disabling the check
+
+To disable this check, you can add `--no-params_not_optional_with_undef-check` to your puppet-lint command line.
+
+```shell
+$ puppet-lint --no-empty_string_assignment-check path/to/file.pp
+```
+
+Alternatively, if you’re calling puppet-lint via the Rake task, you should insert the following line to your `Rakefile`.
+
+```ruby
+PuppetLint.configuration.send('params_not_optional_with_undef')
+```
+
+You can also disable it inline:
+
+```puppet
+class foo (
+  String $baz = '', # lint:ignore:params_empty_string_assignment
+) {
+  # awesome logic here
+}
+```
+
+## Transfer Notice
+
+This plugin was originally authored by [Tim 'bastelfreak' Meusel](https://github.com/bastelfreak).
+The maintainer preferred that Vox Pupuli take ownership of the module for future improvement and maintenance.
+
+## License
+
+This gem is licensed under the MIT license.
+
+## Release information
+
+To make a new release, please do:
+* update the version in the gemspec file
+* Install gems with `bundle install --with release --path .vendor`
+* generate the changelog with `bundle exec rake changelog`
+* Check if the new version matches the closed issues/PRs in the changelog
+* Create a PR with it
+* After it got merged, push a tag. GitHub actions will do the actual release to rubygems and GitHub Packages

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

@@ -0,0 +1,129 @@
+# this code is based on:
+# https://github.com/voxpupuli/puppet-lint-empty_string-check
+# https://github.com/voxpupuli/puppet-lint-optional_default-check
+
+# frozen_string_literal: true
+
+PuppetLint.new_check(:params_not_optional_with_undef) do
+  def check
+    class_indexes.concat(defined_type_indexes).each do |idx|
+      params = extract_params(idx)
+      params.each do |param|
+        default_value = extract_default_value_tokens(param)
+        type = extract_type_tokens(param)
+
+        next unless type.size.positive? && # The parameter has a type
+                    type[0].type == :TYPE && type[0].value != 'Optional' && # That type is not Optional
+                    default_value.size.positive? &&                         # There is a default set
+                    (default_value.map(&:type) & %i[DOT LPAREN]).none? &&   # That default doesn't contain a call to a function
+                    default_value[0].type == :UNDEF &&                      # It is undef
+
+                    notify(
+                      :warning,
+                      message: 'Not optional parameter defaults to undef',
+                      line: param.line,
+                      column: param.column,
+                    )
+      end
+    end
+  end
+
+  private
+
+  # Returns an array of parameter tokens
+  def extract_params(idx)
+    params = []
+    return params if idx[:param_tokens].nil?
+
+    e = idx[:param_tokens].each
+    begin
+      while (ptok = e.next)
+        next unless ptok.type == :VARIABLE
+
+        params << ptok
+        nesting = 0
+        # skip to the next parameter to avoid finding default values of variables
+        loop do
+          ptok = e.next
+          case ptok.type
+          when :LPAREN, :LBRACK
+            nesting += 1
+          when :RPAREN, :RBRACK
+            nesting -= 1
+          when :COMMA
+            break unless nesting.positive?
+          end
+        end
+      end
+    rescue StopIteration; end # rubocop:disable Lint/SuppressedException
+    params
+  end
+
+  # Returns array of tokens that cover the value that the parameter token has as its default
+  # Search forward to find value assigned to this parameter
+  # We want to find the thing after `=` and before `,`
+  def extract_default_value_tokens(ptok)
+    value_tokens = []
+    token = ptok.next_code_token
+    nesting = 0
+    while token
+      case token.type
+      when :LPAREN, :LBRACK
+        nesting += 1
+      when :RBRACK
+        nesting -= 1
+      when :RPAREN
+        nesting -= 1
+        if nesting.negative?
+          # This is the RPAREN at the end of the parameters. There wasn't a COMMA
+          last_token = token.prev_code_token
+          break
+        end
+      when :EQUALS
+        first_token = token.next_code_token
+      when :COMMA
+        unless nesting.positive?
+          last_token = token.prev_code_token
+          break
+        end
+      end
+      token = token.next_token
+    end
+    value_tokens = tokens[tokens.find_index(first_token)..tokens.find_index(last_token)] if first_token && last_token
+    value_tokens
+  end
+
+  # Returns an array of tokens that cover the data type of the parameter ptok
+  # Search backwards until we either bump into a comma (whilst not nested), or reach the opening LPAREN
+  def extract_type_tokens(ptok)
+    type_tokens = []
+    token = ptok.prev_code_token
+    nesting = 0
+    while token
+      case token.type
+      when :LBRACK
+        nesting += 1
+      when :LPAREN
+        nesting += 1
+        if nesting.positive?
+          # This is the LPAREN at the start of the parameter list
+          first_token = token.next_code_token
+          last_token = ptok.prev_code_token
+          break
+        end
+      when :RBRACK, :RPAREN
+        nesting -= 1
+      when :COMMA
+        if nesting.zero?
+          first_token = token.next_code_token
+          last_token = ptok.prev_code_token
+          break
+        end
+      end
+
+      token = token.prev_code_token
+    end
+    type_tokens = tokens[tokens.find_index(first_token)..tokens.find_index(last_token)] if first_token && last_token
+    type_tokens
+  end
+end

data/spec/puppet-lint/plugins/check_params_not_optional_with_undef/check_params_not_optional_with_undef_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+describe 'params_not_optional_with_undef' do
+  let(:msg) { 'Not optional parameter defaults to undef' }
+
+  context 'with fix disabled' do
+    context 'class definition without empty strings' do
+      let(:code) do
+        <<-EOS
+        class foo ( $bar = 'baz' ) { }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'class definition with String type and undef value' do
+      let(:code) do
+        <<-EOS
+        class foo ( String[0] $bar = undef ) { }
+        EOS
+      end
+
+      it 'detects one problem' do
+        expect(problems).to have(1).problem
+      end
+    end
+
+    context 'class definition with empty strings and loose Variant datatype 1' do
+      let(:code) do
+        <<-EOS
+        class foo ( Variant[String[0], Integer] $bar = undef ) { }
+        EOS
+      end
+
+      it 'detects one problem' do
+        expect(problems).to have(1).problem
+      end
+    end
+
+    context 'class definition with empty strings and loose Variant datatype 2' do
+      let(:code) do
+        <<-EOS
+        class foo ( Variant[Any, Optional] $bar = undef ) { }
+        EOS
+      end
+
+      it 'detects one problem' do
+        expect(problems).to have(1).problem
+      end
+    end
+
+    context 'class internal variable without empty strings' do
+      let(:code) do
+        <<-EOS
+        class foo ( ) { $bar = 'baz' }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'class definition with empty strings' do
+      let(:code) do
+        <<-EOS
+        class foo ( String $bar = undef ) { }
+        EOS
+      end
+
+      it 'detects a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'creates a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(28)
+      end
+    end
+
+    context 'class internal variable with empty strings' do
+      let(:code) do
+        <<-EOS
+        class foo ( ) { $bar = '' }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    context 'class definition with value and minimal string length at 0' do
+      let(:code) do
+        <<-EOS
+        class foo ( String[0] $var = 'public' ) { }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    context 'class definition with value and no minimal string length' do
+      let(:code) do
+        <<-EOS
+        class foo ( String $var = 'public' ) { }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    # this usecase was reported on slack
+    context 'class definition with value and string interpolation and values' do
+      let(:code) do
+        <<-EOS
+        class foo (
+          String $install_path = 'bla',
+          String $bin_path = "${install_path}/public",
+          ) {
+            # code
+          }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    context 'class definition with value and string interpolation and not all values' do
+      let(:code) do
+        <<-EOS
+        class foo (
+          String $install_path,
+          String $bin_path = "${install_path}/public",
+          ) {
+            # code
+          }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    context 'class definition with value and string interpolation and not all values and types' do
+      let(:code) do
+        <<-EOS
+        class foo (
+          String $install_path,
+          String[1] $bin_path = "${install_path}/public",
+          ) {
+            # code
+          }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    context 'class definition with value and string interpolation and not all values and types' do
+      let(:code) do
+        <<-EOS
+        define bar::foo (
+          String $install_path,
+          String[1] $bin_path = "${install_path}/public",
+          ) {
+            # code
+          }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+
+    context 'class definition with value and string interpolation and not all values and types' do
+      let(:code) do
+        <<-EOS
+        define profiles::host_api::nexus::managed::gem_installation (
+          String $gem_source,
+          String $gem_name,
+          String $version,
+          String $user,
+          String $group,
+          String $install_path,
+          String[1] $bin_path = "${install_path}/bin",
+          Boolean $add_bin_stub = false,
+        ) {
+          # code
+        }
+        EOS
+      end
+
+      it 'does not detect any problems' do
+        expect(problems).to have(0).problem
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'puppet-lint'
+require 'rspec/collection_matchers'
+
+PuppetLint::Plugins.load_spec_helper

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: puppet-lint-params_not_optional_with_undef-check
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Vox Pupuli
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puppet-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-json_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+email: voxpupuli@groups.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/puppet-lint/plugins/params_not_optional_with_undef.rb
+- spec/puppet-lint/plugins/check_params_not_optional_with_undef/check_params_not_optional_with_undef_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/voxpupuli/puppet-lint-params_not_optional_with_undef-check
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A puppet-lint plugin to check for class parameters with undef as value but
+  not Optional type
+test_files: []