puppet-lint-module_reference-check 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 165ae50c695f4525d85426dea4ec555b9d4f44b7321f642d86783277319787fb
+  data.tar.gz: 952b6da27bc82a66b29a23df6bae49ecd16e742750a94cb75f0ce0d4646af1f8
+SHA512:
+  metadata.gz: 96cdff2aed65b20e028d2093dc27668a7b32c8479ad3f552bc9bbdc59f655a6858d3ee2a36713367b949242978cd048854e0cb2c0a2b6cabd6d8c78caf476587
+  data.tar.gz: 124c80e7b55984c5a06d2fc5ecf70e192625d8984003d2f9277fbce6d4130e08028c4ce6140d4ae1105d44e6d155e6d9eee7ec7ef704212a6424204841c3f3ad

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,27 @@
+# Puppet lint module reference check
+
+This checks whether used modules are properly referenced in the comments by these rules:
+
+- All internal prefixed with profile:: or role:: based on the Puppet role/profile concept) modules have to be 
+  referenced using a @see tag
+- All component modules have to be referenced like the following
+  - All used classes and defined types need to be gathered in a comma-separated list of regexps in a @ref tag
+  - The full module name (vendor-module) has to be referenced in a @note tag
+  - At minimum one @see tag with a reference to the puppet forge page of the component module
+  - Example:
+    ```
+    # @ref apache.*,a2mod
+    # @note puppetlabs-apache
+    # @see https://forge.puppet.com/modules/puppetlabs/apache
+    ```
+- Modules referenced by features (using our own role::include_features function) have to be referenced with @see
+- The module references have to be sorted alphabetically and grouped by this:
+  - component module
+  - internal modules
+  - modules referenced by features
+
+## Usage
+
+To use the plugin, add the following line to the Gemfile:
+
+    gem 'puppet-lint-module_reference-check'

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet-lint-module_reference-check/reference'
+
+# 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 - 1
+  while token_pointer >= 0
+    break unless %i[COMMENT NEWLINE].include? tokens[token_pointer].type
+
+    comments.append(tokens[token_pointer])
+    token_pointer -= 1
+  end
+  comments.reject { |comment| comment.type == :NEWLINE }.reverse!
+end
+
+def get_first_index_of_type(comments, type, feature_refs)
+  comments.each_with_index do |comment, index|
+    comment.match(/@see (?<name>\S+)/) do |match|
+      next if feature_refs.any? { |ref| ref[:name] == match.named_captures['name'] }
+      return index if match.named_captures['name'].match?(INTERNAL_MODULE_REGEXP) && type == REF_TYPE_ENUM[:internal]
+      return index if !match.named_captures['name'].match?(INTERNAL_MODULE_REGEXP) && type == REF_TYPE_ENUM[:component]
+    end
+  end
+  0
+end
+
+PuppetLint.new_check(:module_reference) do
+  def initialize
+    @workflow = Reference.new
+    # noinspection RubySuperCallWithoutSuperclassInspection
+    super
+  end
+
+  def warn(message, line = 1, column = 1)
+    notify :warning, { message: message, line: line, column: column }
+    false
+  end
+
+  def check_sees_exist(references, comments)
+    references.each do |reference|
+      next if comments.any? { |comment| comment.match?("^@see #{reference[:name]}\\s?") }
+
+      return warn(
+        "Module #{reference[:name]} not referenced in the comments",
+        reference[:token].line,
+        reference[:token].column
+      )
+    end
+    true
+  end
+
+  def check_reference_order(references, comments, below_index)
+    references.each do |reference|
+      if comments.find_index { |comment| comment.match?("^@see #{reference[:name]}\\s?") } < below_index
+        return warn("Reference to #{reference[:name]} was found higher than #{comments[below_index]}")
+      end
+    end
+    true
+  end
+
+  def check_internal_references(comments)
+    internal_references = @workflow.references.filter { |ref| ref[:type] == REF_TYPE_ENUM[:internal] }
+    return false unless check_sees_exist(internal_references, comments)
+    return false unless check_reference_order(
+      internal_references,
+      comments,
+      get_first_index_of_type(
+        comments,
+        REF_TYPE_ENUM[:component],
+        @workflow.references.filter { |ref| ref[:type] == REF_TYPE_ENUM[:feature] }
+      )
+    )
+
+    true
+  end
+
+  def find_ref_index(name, comments)
+    comments.each_with_index do |comment, index|
+      comment.match(/^@ref (?<ref_regexps>.+)\s?/) do |match|
+        match.named_captures['ref_regexps'].split(',').each do |ref_regexp|
+          return index if name.match?(ref_regexp)
+        end
+      end
+    end
+    nil
+  end
+
+  def check_component_references(comments)
+    component_refs = @workflow.references.filter { |ref| ref[:type] == REF_TYPE_ENUM[:component] }
+    component_refs.each do |reference|
+      ref_index = find_ref_index(reference[:name], comments)
+      return warn("Can't find @ref tag for reference #{reference[:name]}") if ref_index.nil?
+      return warn("Missing @note tag for reference #{reference[:name]}") unless comments[ref_index + 1].match?(/@note/)
+      return warn("Missing @see tag for reference #{reference[:name]}") unless comments[ref_index + 2].match?(/@see/)
+      next if comments[ref_index + 2].include?('https://forge.puppet.com/')
+
+      return warn("First @see for reference #{reference[:name]} is not the Puppet forge")
+    end
+    true
+  end
+
+  def check_feature_references(comments)
+    feature_refs = @workflow.references.filter { |ref| ref[:type] == REF_TYPE_ENUM[:feature] }
+    return false unless check_sees_exist(feature_refs, comments)
+    return false unless check_reference_order(
+      feature_refs,
+      comments,
+      get_first_index_of_type(
+        comments,
+        REF_TYPE_ENUM[:internal],
+        @workflow.references.filter { |ref| ref[:type] == REF_TYPE_ENUM[:feature] }
+      )
+    )
+
+    true
+  end
+
+  def get_relevant_name(captures, comments, index)
+    return_object = {
+      name: captures['name'],
+      type: nil
+    }
+    if captures['type'] == 'see' && (index == 0 || index > 0 && !comments[index - 1].match(/@note/))
+      return return_object if captures['name'].match?(%r(https?://))
+
+      reference = @workflow.references.select { |ref| ref[:name] == captures['name'] }
+      return warn("Can't find referenced module #{captures['name']}") if reference.empty?
+
+      return_object[:type] = reference.first[:type]
+    else
+      @workflow
+        .references
+        .select { |ref| ref[:type] == REF_TYPE_ENUM[:component] }
+        .each do |ref|
+        next unless captures['name'].split(',').any? { |refmatch| ref[:name].match?(refmatch) }
+
+        comments[index + 1].match(/^@note (?<name>.+)$/) do |matchdata|
+          return_object[:name] = matchdata['name']
+          return_object[:type] = ref[:type]
+          break
+        end
+      end
+    end
+    return_object
+  end
+
+  def check_order(comments)
+    last_comment = nil
+    current_type = REF_TYPE_ENUM[:component]
+    comments.each_with_index do |comment, index|
+      comment.match(/@(?<type>see|ref) (?<name>\S+)/) do |match|
+        ref_object = get_relevant_name(match.named_captures, comments, index)
+        return false unless ref_object
+
+        current_comment = ref_object[:name]
+        return warn("No relevant name found for #{comment}") if current_comment.nil?
+        next if current_comment.match?('https?://')
+
+        if ref_object[:type] != current_type
+          last_comment = nil
+          current_type = ref_object[:type]
+        end
+        last_comment = current_comment if last_comment.nil?
+        return warn("#{current_comment} sorted after #{last_comment}") if last_comment > current_comment
+      end
+    end
+  end
+
+  # Check class or defined type indexes
+  def check_indexes(indexes)
+    indexes.each do |index|
+      comments = get_comments(tokens, index[:start] - 1)
+                 .map { |comment| comment.value.strip }
+                 .filter { |comment| comment.match?(/^@(see|note|ref)/) }
+      begin
+        @workflow.process(tokens[index[:start], index[:end]])
+      rescue InvalidTokenForState => e
+        warn(e.message, e.token.line, e.token.column)
+      end
+      return false unless check_internal_references(comments)
+      return false unless check_component_references(comments)
+      return false unless check_feature_references(comments)
+      return false unless check_order(comments)
+    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-module_reference-check/reference.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'reference_workflow'
+
+REF_TYPE_ENUM = {
+  internal: 0,
+  component: 1,
+  feature: 2
+}.freeze
+
+INTERNAL_MODULE_REGEXP = /^(role|profile)::/.freeze
+
+# Comment received in an invalid state
+class InvalidTokenForState < StandardError
+  def initialize(token, state)
+    @token = token
+    @state = state
+    super "Can not process the token '#{@token.value.strip}' in the state #{@state}"
+  end
+
+  attr_reader :token
+end
+
+# A utility class to process tokens and analyze includes
+class Reference
+  def initialize
+    @workflow = ReferenceWorkflow.new(self)
+
+    reset
+  end
+
+  def reset
+    @current_token = nil
+    @references = []
+  end
+
+  def get_body_start(tokens)
+    params_started = false
+    params_ended = false
+    params_brackets = 0
+    tokens.each_with_index do |token, index|
+      params_started = true if token.type == :LPAREN && !params_started
+      params_brackets += 1 if token.type == :LPAREN && params_started
+      params_brackets -= 1 if token.type == :RPAREN && params_started
+      params_ended = true if params_started && params_brackets.zero?
+      return index + 1 if params_ended && token.type == :LBRACE
+    end
+    warn('No class or type body found')
+  end
+
+  def process(tokens)
+    tokens = tokens.drop(get_body_start(tokens))
+    feature_includes = []
+    tokens.reject { |token| %i[WHITESPACE NEWLINE INDENT].include? token.type }.each do |token|
+      @current_token = token
+      @workflow.got_include if token.value == 'include'
+      @workflow.got_class if token.value == 'class'
+      @workflow.got_features_start if token.value == 'role::include_features'
+      @workflow.got_feature if token.type == :LBRACK && @workflow.current == :awaiting_feature
+      @workflow.got_feature_end if token.type == :RBRACK && @workflow.current == :awaiting_feature_include
+      @workflow.got_features_end(feature_includes) if token.type == :RBRACE && @workflow.current == :got_feature_start
+      next unless %i[NAME SSTRING].include?(token.type)
+      next if %w[include class role::include_features].include?(token.value)
+
+      # noinspection RubyCaseWithoutElseBlockInspection
+      case @workflow.current
+      when :awaiting_include_name
+        @workflow.got_include_name(token.value)
+      when :awaiting_class_name
+        @workflow.got_class_name(token.value)
+      when :awaiting_feature_include
+        feature_includes.append(token.value)
+      end
+    end
+  end
+
+  def got_include_name_trigger(include_name)
+    @references.append(
+      {
+        type: include_name.match(INTERNAL_MODULE_REGEXP) ? REF_TYPE_ENUM[:internal] : REF_TYPE_ENUM[:component],
+        name: include_name,
+        token: @current_token
+      }
+    )
+  end
+
+  def got_class_name_trigger(class_name)
+    @references.append(
+      {
+        type: class_name.match(INTERNAL_MODULE_REGEXP) ? REF_TYPE_ENUM[:internal] : REF_TYPE_ENUM[:component],
+        name: class_name,
+        token: @current_token
+      }
+    )
+  end
+
+  def got_features_end_trigger(feature_includes)
+    feature_includes.each do |include_name|
+      @references.append(
+        {
+          type: REF_TYPE_ENUM[:feature],
+          name: include_name,
+          token: @current_token
+        }
+      )
+    end
+  end
+
+  def invalid_state
+    raise InvalidTokenForState.new @current_token, @workflow.current
+  end
+
+  attr_reader :references
+end

data/lib/puppet-lint-module_reference-check/reference_workflow.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'finite_machine'
+
+# A workflow to describe includes and class declarations
+class ReferenceWorkflow < FiniteMachine::Definition
+  initial :start
+
+  event :got_include, from: :start, to: :awaiting_include_name
+  event :got_include_name, from: :awaiting_include_name, to: :start
+
+  event :got_class, from: :start, to: :awaiting_class_name
+  event :got_class_name, from: :awaiting_class_name, to: :start
+
+  event :got_features_start, from: :start, to: :awaiting_feature
+  event :got_feature, from: :awaiting_feature, to: :awaiting_feature_include
+  event :got_feature_end, from: :awaiting_feature_include, to: :got_feature_start
+  event :got_features_end, from: :got_feature_start, to: :start
+
+  on_before(:got_include_name) { |_, include_name| target.got_include_name_trigger(include_name) }
+  on_before(:got_class_name) { |_, class_name| target.got_class_name_trigger(class_name) }
+  on_before(:got_features_end) { |_, feature_includes| target.got_features_end_trigger(feature_includes) }
+
+  handle FiniteMachine::InvalidStateError, with: -> { target.invalid_state }
+end

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+describe 'module_reference' do
+  context 'valid code' do
+    let(:code) do
+      <<~CODE
+        # @ref apache
+        # @note puppetlabs-apache
+        # @see https://forge.puppet.com/modules/puppetlabs/apache
+        #
+        # @see profile::test
+        #
+        # @see profile::testfeature - Feature "test"
+        class test () {
+          include profile::test
+          class {
+            'apache':
+          }
+          include apache
+
+          role::include_features({
+            'testfeature' => [
+              profile::testfeature,
+            ],
+          })
+        }
+      CODE
+    end
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'code with missing internal link' do
+    let(:code) do
+      <<~CODE
+        class test () {
+          include profile::test
+        }
+      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('Module profile::test not referenced in the comments').on_line(2).in_column(11)
+    end
+  end
+
+  context 'code with missing component link' do
+    let(:code) do
+      <<~CODE
+        class test () {
+          class {
+            'apache':
+          }
+        }
+      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('Can\'t find @ref tag for reference apache').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with wrong component @see' do
+    let(:code) do
+      <<~CODE
+        # @ref apache
+        # @note puppetlabs-apache
+        # @see https://example.com
+        class test () {
+          class {
+            'apache':
+          }
+        }
+      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('First @see for reference apache is not the Puppet forge').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with internal references sorted before component references' do
+    let(:code) do
+      <<~CODE
+        # @see profile::test
+        #
+        # @ref apache
+        # @note puppetlabs-apache
+        # @see https://forge.puppet.com/modules/puppetlabs/apache
+        #
+        # @see profile::testfeature - Feature "test"
+        class test () {
+          include profile::test
+          class {
+            'apache':
+          }
+          include apache
+
+          role::include_features({
+            'testfeature' => [
+              profile::testfeature,
+            ],
+          })
+        }
+      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('Reference to profile::test was found higher than @see https://forge.puppet.com/modules/puppetlabs/apache').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with feature references sorted before internal references' do
+    let(:code) do
+      <<~CODE
+        # @ref apache
+        # @note puppetlabs-apache
+        # @see https://forge.puppet.com/modules/puppetlabs/apache
+        #
+        # @see profile::testfeature - Feature "test"
+        #
+        # @see profile::test
+        class test () {
+          include profile::test
+          class {
+            'apache':
+          }
+          include apache
+
+          role::include_features({
+            'testfeature' => [
+              profile::testfeature,
+            ],
+          })
+        }
+      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('Reference to profile::testfeature was found higher than @see profile::test').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with reference to unused module' do
+    let(:code) do
+      <<~CODE
+        # @ref apache
+        # @note puppetlabs-apache
+        # @see https://forge.puppet.com/modules/puppetlabs/apache
+        #
+        # @see profile::test
+        #
+        # @see profile::testfeature - Feature "test"
+        class test () {
+          include profile::test
+          class {
+            'apache':
+          }
+          include apache
+        }
+      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('Can\'t find referenced module profile::testfeature').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with unsorted component references' do
+    let(:code) do
+      <<~CODE
+        # @ref postgresql
+        # @note puppetlabs-postgresql
+        # @see https://forge.puppet.com/modules/puppetlabs/postgresql
+        #
+        # @ref apache
+        # @note puppetlabs-apache
+        # @see https://forge.puppet.com/modules/puppetlabs/apache
+        class test () {
+          class {
+            'apache':
+          }
+          include postgresql
+        }
+      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('puppetlabs-apache sorted after puppetlabs-postgresql').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with unsorted internal references' do
+    let(:code) do
+      <<~CODE
+        # @see profile::b
+        # @see profile::a
+        class test () {
+          include profile::a
+          include profile::b
+        }
+      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('profile::a sorted after profile::b').on_line(1).in_column(1)
+    end
+  end
+
+  context 'code with unsorted feature references' do
+    let(:code) do
+      <<~CODE
+        # @see profile::b
+        # @see profile::a
+        class test () {
+          role::include_features({
+            'testfeature' => [
+              profile::a,
+              profile::b
+            ],
+          })
+        }
+      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('profile::a sorted after profile::b').on_line(1).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-module_reference-check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dennis Ploeger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-06-03 00:00:00.000000000 Z
+dependencies:
+- !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: 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: 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: 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-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: 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: 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: |2
+      A puppet-lint plugin to check that manifest files contain valid reference comments for included
+      modules.
+email: develop@dieploegers.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/puppet-lint-module_reference-check/reference.rb
+- lib/puppet-lint-module_reference-check/reference_workflow.rb
+- lib/puppet-lint/plugins/check_module_reference.rb
+- spec/puppet-lint/plugins/check_module_reference_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dodevops/puppet-lint-module_reference-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 the @see and @note comments for included modules.
+test_files:
+- spec/spec_helper.rb
+- spec/puppet-lint/plugins/check_module_reference_spec.rb