puppet-lint-param_comment-check 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 001c0354a4c8e6d8d852d3f07122cf01f80603b17aaa8eebe9954ea4566704b6
+  data.tar.gz: 2502c094ecbbebca5c3986ec25f8f1a2563b55cf1d430d8abe575e9d637abfe0
+SHA512:
+  metadata.gz: 60175714324271adf92951be259db9ad0dc292c35681784058d7f8b1e5dbec2ecb01c589186c89938aaec72ca62ccef50c7c5d96a2a67c33f08420c5f5f978a4
+  data.tar.gz: 5a15fc0ea2b159d6d41470b0f74267d1a74d518f840da822c1e94544b258c78314f3a36e491c9d885e05ca2b68d6da00495305f20b6c39fba379901b263355d7

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 DO! DevOps
+
+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,41 @@
+# Puppet lint param check
+
+This is an extensive, opinionated check for valid parameter comments. It checks if the following criteria are matched:
+
+- All parameters are documented
+- @param-tags are separated from another by one empty line
+- The description of a @param tag is always indented in the next line
+- The @option comments directly follow the corresponding hash @param tag without a separator
+- @param tags are sorted like the parameters they document
+
+```
+# @param mandatory
+#   A mandatory parameter
+# @option mandatory [String] hashkey
+#   A key of the hash "mandatory" named "hashkey".
+#
+# @param withdefault
+#   A parameter with a default value
+#
+# @param optional
+#   An optional parameter
+
+class my_class {
+    Hash $mandatory,
+    Boolean $withdefault = false,
+    Optional[String] $optional = undef,
+```
+
+## Development
+
+This check uses a finite state machine to work through the expected list of parameters.
+
+The workflow used by the fsm can be visualized like this:
+
+![](docs/param_workflow.drawio.png)
+
+## Usage
+
+To use the plugin, add the following line to the Gemfile:
+
+    gem 'puppet-lint-summary_param-check'

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet-lint-param_comment-check/param_workflow'
+require_relative '../../puppet-lint-param_comment-check/param_comments'
+
+# The empty data of a parameter
+EMPTY_PARAM = {
+  name: '',
+  type: '',
+  has_default: false,
+  default: ''
+}.freeze
+
+# Find the header comments for a class or a defined type
+#
+# @param tokens The list of all tokens
+# @param token_start The index of the token to start from upwards
+# @return The head comments
+def get_comments(tokens, token_start)
+  comments = []
+  token_pointer = token_start
+  while token_pointer >= 0
+    comments.append(tokens[token_pointer]) if tokens[token_pointer].type == :COMMENT
+    token_pointer -= 1
+  end
+  comments.reverse
+end
+
+# Analyze a parameter token
+#
+# @param token The token to analyze
+# @param current_param the data object for the currently analyzed parameter
+def analyze_param_token(token, current_param)
+  # noinspection RubyCaseWithoutElseBlockInspection
+  case token.type
+  when :VARIABLE
+    current_param[:name] = token.value
+  when :CLASSREF
+    current_param[:type] = token.value
+  when :EQUALS
+    current_param[:has_default] = true
+    current_param[:default] = token.next_token.value
+  end
+  current_param
+end
+
+# Analyze the parameters of a class or a defined type
+#
+# @param param_tokens The parameter tokens to analyze
+def analyze_params(param_tokens)
+  params = []
+  current_param = EMPTY_PARAM.dup
+  param_tokens.reject { |token| %i[WHITESPACE NEWLINE].include? token.type }.each do |token|
+    current_param = analyze_param_token(token, current_param) unless token.type == :COMMA
+    if token.type == :COMMA
+      params.append(current_param)
+      current_param = EMPTY_PARAM.dup
+    end
+  end
+  params
+end
+
+# Find, which parameters in the long list are missing in the short list and return their names
+#
+# @param long_list The list containing all parameters
+# @param short_list The list missing some parameters
+# @return The names of the missing parameters
+def get_missing_parameters(long_list, short_list)
+  long_list.reject { |param| short_list.any? { |short_list_param| short_list_param[:name] == param[:name] } }
+           .map { |param| param[:name] }
+end
+
+PuppetLint.new_check(:param_comment) do # rubocop:disable Metrics/BlockLength
+  def initialize
+    @comment_engine = ParamComments.new
+    # noinspection RubySuperCallWithoutSuperclassInspection
+    super
+  end
+
+  # A shortcut to add a new Puppetlint warning
+  def warn(message, line = 1, column = 1)
+    notify :warning, { message: message, line: line, column: column }
+    false
+  end
+
+  # Check if the comments are formatted correctly by piping them through the fsm workflow
+  def check_comment_format(comments)
+    begin
+      @comment_engine.process(comments)
+    rescue InvalidCommentForState, OptionDoesntMatchHash => e
+      return warn(e.message, e.comment.line, e.comment.column)
+    end
+    true
+  end
+
+  # Check the header lines of parameters or hash options
+  def check_param_option_headers(comments)
+    comments.each do |comment|
+      next unless comment.value.match?(/@param/) || comment.value.match?(/@option/)
+      next if comment.value.strip.match?(REGEXP_PARAM_HEADER) || comment.value.strip.match?(REGEXP_OPTION_HEADER)
+
+      return warn('Invalid param or hash option header', comment.line, comment.column)
+    end
+    true
+  end
+
+  # Check comments
+  def check_comments(comments)
+    return false unless check_param_option_headers(comments)
+    return false unless check_comment_format(comments)
+
+    true
+  end
+
+  # Check if parameters and parameter comments match
+  def check_parameters_count(params)
+    param_comments = @comment_engine.params
+    if params.length > param_comments.length
+      missing_params = get_missing_parameters(params, param_comments)
+      return warn("Missing parameter documentation for #{missing_params.join(',')}")
+    elsif params.length < param_comments.length
+      missing_params = get_missing_parameters(param_comments, params)
+      return warn("Documented but unused parameters found: #{missing_params.join(',')}")
+    end
+    true
+  end
+
+  # Check if the parameter comments are ordered like the parameters
+  def check_comment_order(params)
+    param_comments = @comment_engine.params
+    param_comments.each_with_index do |param, index|
+      return false unless param[:name] == params[index][:name]
+    end
+    true
+  end
+
+  # Check class or defined type indexes
+  def check_indexes(indexes)
+    indexes.each do |index|
+      comments = get_comments(tokens, index[:start])
+      params = analyze_params(index[:param_tokens])
+      return false unless check_comments(comments)
+      return false unless check_parameters_count(params)
+      return warn('Parameters sorted wrong') unless check_comment_order(params)
+    end
+    true
+  end
+
+  # Run the check
+  def check
+    return unless check_indexes(class_indexes)
+    return unless check_indexes(defined_type_indexes)
+  end
+end

data/lib/puppet-lint-param_comment-check/param_comments.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# The empty data of a parameter
+EMPTY_PARAM_COMMENT = {
+  name: '',
+  description: '',
+  options: []
+}.freeze
+
+# The empty data of a hash option
+EMPTY_OPTION_COMMENT = {
+  name: '',
+  type: '',
+  description: ''
+}.freeze
+
+# A regular expression describing a parameter header
+REGEXP_PARAM_HEADER = /^@param (?<name>[^ ]+)$/.freeze
+
+# A regular expression describing a hash option header
+REGEXP_OPTION_HEADER = /^@option (?<hash_name>[^ ]+) \[(?<type>[^\]]+)\] :(?<name>[^ ]+)$/.freeze
+
+# Comment received in an invalid state
+class InvalidCommentForState < StandardError
+  def initialize(comment, state)
+    @comment = comment
+    @state = state
+    super "Invalid state #{@state} for comment #{@comment.value.strip}"
+  end
+
+  attr_reader :comment
+end
+
+# Unexpected comment found
+class UnexpectedComment < StandardError
+  def initialize(comment)
+    @comment = comment
+    super "Unexpected comment #{@comment.value}"
+  end
+
+  attr_reader :comment
+end
+
+# The hash referenced in an option doesn't match the current parameter
+class OptionDoesntMatchHash < StandardError
+  def initialize(comment)
+    @comment = comment
+    super "Option references wrong hash #{@comment.value.strip}"
+  end
+
+  attr_reader :comment
+end
+
+# A helper to analyze parameter comments using the ParamWorkflow fsm
+class ParamComments
+  def initialize
+    @workflow = ParamWorkflow.new(self)
+
+    @current_param = nil
+    @current_option = nil
+    @in_option = false
+    @params_have_started = false
+    @params = []
+  end
+
+  # Walk through every comment and transition the workflow fsm accordingly
+  #
+  # @param comments A list of Comment tokens appearing before the class/defined type header
+  def process(comments) # rubocop:disable Metrics/MethodLength
+    @current_comment = PuppetLint::Lexer::Token.new(:COMMENT, '', 1, 1)
+    comments.each do |comment|
+      @current_comment = comment
+      # noinspection RubyCaseWithoutElseBlockInspection
+      case comment.value
+      when /@param/ # A parameter comment header
+        @workflow.got_header(comment)
+      when /@option/ # A hash option
+        @workflow.got_option_header(comment) if @params_have_started
+      when /^\s*$/ # An empty or whitespace-only comment, thus interpreted as a separator
+        @workflow.got_separator(comment) if @params_have_started
+      when / {2}[^ ]+/ # A description. Either for the parameter or a hash option
+        @workflow.got_description(comment) if @params_have_started && !@in_option
+        @workflow.got_option_description(comment) if @params_have_started && @in_option
+      end
+    end
+    @params.append(@current_param) unless @current_param.nil?
+  end
+
+  # Called before the got_header event. Interpret the parameter header comment
+  def got_header_trigger(_, comment)
+    @params_have_started = true
+    @current_param[:options].append(@current_option) if @in_option && !@current_option.nil?
+    @params.append(@current_param) unless @current_param.nil?
+    @current_param = EMPTY_PARAM_COMMENT.dup
+    @current_option = nil
+    @in_option = false
+    comment.value.strip.match(REGEXP_PARAM_HEADER) do |match|
+      @current_param[:name] = match.named_captures['name'].strip
+    end
+  end
+
+  # Called before either the got_description or get_option_description event. Add a description to the
+  # current parameter or hash option
+  def got_description_trigger(_, comment)
+    return unless @params_have_started
+
+    @current_option[:description] += comment.value.strip if @in_option
+    @current_param[:description] += comment.value.strip unless @in_option
+  end
+
+  # Called before the got_option_header event. Interpret a hash option comment
+  def got_option_header_trigger(_, comment) # rubocop:disable Metrics/AbcSize
+    return unless @params_have_started
+
+    @current_param[:options].append(@current_option) if @in_option && !@current_option.nil?
+    @in_option = true
+    @current_option = EMPTY_OPTION_COMMENT.dup
+    comment.value.strip.match(REGEXP_OPTION_HEADER) do |match|
+      raise OptionDoesntMatchHash, comment unless match.named_captures['hash_name'] == @current_param[:name]
+
+      @current_option[:name] = match.named_captures['name']
+      @current_option[:type] = match.named_captures['type']
+    end
+  end
+
+  # Called when an invalid state transition would happen
+  def invalid_state
+    raise InvalidCommentForState.new(@current_comment, @workflow.current)
+  end
+
+  # The list of analyzed parameters in the comments
+  attr_reader :params
+end

data/lib/puppet-lint-param_comment-check/param_workflow.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'finite_machine'
+
+# A finite state machine working through the expected parameter comments
+class ParamWorkflow < FiniteMachine::Definition
+  initial :start
+
+  event :got_header, from: :start, to: :awaiting_description
+  event :got_header, from: :awaiting_header, to: :awaiting_description
+  event :got_description, from: :awaiting_description, to: :awaiting_separator
+  event :got_separator, from: :awaiting_separator, to: :awaiting_header
+
+  # handling options
+  event :got_option_header, from: :awaiting_separator, to: :awaiting_option_description
+  event :got_option_description, from: :awaiting_option_description, to: :awaiting_separator
+
+  # for separators inside descriptions
+  event :got_description, from: :awaiting_header, to: :awaiting_separator
+  event :got_option_description, from: :awaiting_separator, to: :awaiting_separator
+
+  on_before(:got_header) { |event, comment| target.got_header_trigger(event, comment) }
+  on_before(:got_description) { |event, comment| target.got_description_trigger(event, comment) }
+  on_before(:got_option_description) { |event, comment| target.got_description_trigger(event, comment) }
+  on_before(:got_option_header) { |event, comment| target.got_option_header_trigger(event, comment) }
+
+  handle FiniteMachine::InvalidStateError, with: -> { target.invalid_state }
+end

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

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'param_comment' do
+  context 'valid code' do
+    let(:code) do
+      <<~CODE
+        # @summary
+        #   some class
+        #
+        # @param mandatory
+        #   A mandatory parameter
+        #
+        # @param withdefault
+        #   A parameter with a default value
+        #
+        #   A two paragraph description
+        #
+        # @param optional
+        #   An optional parameter
+
+        class my_class (
+            String $mandatory,
+            Boolean $withdefault = false,
+            Optional[String] $optional = undef,
+        ) {}
+      CODE
+    end
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'code with missing parameter comment' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        #
+        # @param withdefault
+        #   A parameter with a default value
+
+        class my_class (
+            String $mandatory,
+            Boolean $withdefault = false,
+            Optional[String] $optional = undef,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning('Missing parameter documentation for optional').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with additional parameter comment' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        #
+        # @param withdefault
+        #   A parameter with a default value
+
+        class my_class (
+            String $mandatory,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning('Documented but unused parameters found: withdefault').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with wrongly sorted parameter comments' do
+    let(:code) do
+      <<~CODE
+        # @param withdefault
+        #   A parameter with a default value
+        #
+        # @param mandatory
+        #   A mandatory parameter
+        #
+        # @param optional
+        #   An optional parameter
+
+        class my_class (
+            String $mandatory,
+            Boolean $withdefault = false,
+            Optional[String] $optional = undef,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning('Parameters sorted wrong').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with missing separator comment' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        # @param withdefault
+        #   A parameter with a default value
+        #
+        # @param optional
+        #   An optional parameter
+
+        class my_class (
+            String $mandatory,
+            Boolean $withdefault = false,
+            Optional[String] $optional = undef,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning('Invalid state awaiting_separator for comment @param withdefault')
+                            .on_line(3)
+                            .in_column(1)
+    end
+  end
+
+  context 'code with description in header' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory A mandatory parameter
+        class my_class (
+            String $mandatory,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning('Invalid param or hash option header')
+                            .on_line(1)
+                            .in_column(1)
+    end
+  end
+
+  context 'code with correct hash options' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        # @option mandatory [Boolean] :some_option
+        #   An option
+        class my_class (
+            Hash $mandatory,
+        ) {}
+      CODE
+    end
+
+    it 'should detect no problem' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'code with incorrect hash name' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        # @option mandatry [Boolean] :some_option
+        #   An option
+        class my_class (
+            Hash $mandatory,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning('Option references wrong hash @option mandatry [Boolean] :some_option')
+                            .on_line(3)
+                            .in_column(1)
+    end
+  end
+
+  context 'code with a separator between param and option' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        #
+        # @option mandatory [Boolean] :some_option
+        #   An option
+        class my_class (
+            Hash $mandatory,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning(
+                            'Invalid state awaiting_header for comment @option mandatory [Boolean] :some_option'
+                          )
+                            .on_line(4)
+                            .in_column(1)
+    end
+  end
+
+  context 'code with option description on the same line' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        # @option mandatory [Boolean] :some_option An option
+        class my_class (
+            Hash $mandatory,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning(
+                            'Invalid param or hash option header'
+                          )
+                            .on_line(3)
+                            .in_column(1)
+    end
+  end
+
+  context 'code with no separator between hash option and next parameter' do
+    let(:code) do
+      <<~CODE
+        # @param mandatory
+        #   A mandatory parameter
+        # @option mandatory [Boolean] :some_option
+        #   An option
+        # @param second
+        #   Something else
+        class my_class (
+            Hash $mandatory,
+            String $second,
+        ) {}
+      CODE
+    end
+
+    it 'should detect exactly one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create a warning' do
+      expect(problems).to contain_warning(
+                            'Invalid state awaiting_separator for comment @param second'
+                          )
+                            .on_line(5)
+                            .in_column(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.add_filter 'vendor'
+SimpleCov.start
+
+require 'puppet-lint'
+
+PuppetLint::Plugins.load_spec_helper

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: puppet-lint-param_comment-check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dennis Ploeger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puppet-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: finite_machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rubocop
+  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: simplecov
+  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'
+description: "    A puppet-lint plugin to check that manifest files contain properly
+  formatted @param comments.\n"
+email: develop@dieploegers.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/puppet-lint-param_comment-check/param_comments.rb
+- lib/puppet-lint-param_comment-check/param_workflow.rb
+- lib/puppet-lint/plugins/check_param_comment.rb
+- spec/puppet-lint/plugins/check_param_comment_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dodevops/puppet-lint-param_comment-check
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: '["A puppet-lint plugin to check @param comments", "    A puppet-lint plugin
+  to check that manifest files contain properly formatted @param comments.\n"]'
+test_files:
+- spec/spec_helper.rb
+- spec/puppet-lint/plugins/check_param_comment_spec.rb