puppet-lint-use_ensure_packages-check 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 429d64b939da27bc66f50a566fd01afbc3a0822a
+  data.tar.gz: 7f06639bcb642f4ad70590b2de8d486ce64970cf
+SHA512:
+  metadata.gz: 13062a56166ba14cea81eac802baf04104c1af6d8bce6cffb489ef85b89ba3fe06906b01c830df7ad5c880a1c78fa4b8b38b5c2800a4695b83869a05b8bba78b
+  data.tar.gz: 06a37b1250c9c3d13570b9bd886698aa475111dc5a5131e2d8d0bb89d6fa19d76b5d53d5b76d1f0fd289781813e6b5c52d7d3ba3db61e5fc7e4e8b0331f993fe

data/README.md

@@ -0,0 +1,35 @@
+# puppet-lint use ensure_packages check
+
+[![Build Status](https://travis-ci.org/ninech/puppet-lint-use_ensure_packages-check.svg?branch=master)](https://travis-ci.org/ninech/puppet-lint-use_ensure_packages-check)
+
+## Installation
+
+To use this plugin, add the following like to the Gemfile in your Puppet code
+base and run `bundle install`.
+
+```ruby
+gem 'puppet-lint-use_ensure_packages-check'
+```
+
+## Usage
+
+This plugin provides a new check to `puppet-lint`.
+
+### use_ensure_packages
+
+**--fix support: yes**
+
+This check will raise a error for constructs like the following.
+
+```
+  if ! defined(Package['foo']) {
+    package { 'foo': }
+  }
+```
+
+And offer you the option to rewrite it to use ensure_packages with the **--fix**
+option. This would be transformed into the following.
+
+```
+  ensure_packages(['foo'])
+```

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

@@ -0,0 +1,167 @@
+PuppetLint.new_check(:use_ensure_packages) do
+  TYPE_SEQUENCE_START = [
+    # if ! defined ( Package[NAME])
+    :IF, :NOT, :NAME, :LPAREN, :CLASSREF, :LBRACK, :SSTRING, :RBRACK, :RPAREN,
+    # { package {NAME:
+    :LBRACE, :NAME, :LBRACE, :SSTRING, :COLON
+  ].freeze
+  TYPE_SEQUENCE_END = [
+    # } }
+    :RBRACE, :RBRACE
+  ].freeze
+  VALUE_SEQUENCE = { 2 => 'defined', 4 => 'Package', 10 => 'package' }.freeze
+  NAME_INDEX = 6
+
+  OPTINAL_CONTENT = [
+    { # ensure => installed
+      sequence: [:NAME, :FARROW, :NAME],
+      values: { 0 => 'ensure', 2 => 'installed' }
+    },
+    { # ensure => installed;
+      sequence: [:NAME, :FARROW, :NAME, :SEMIC],
+      values: { 0 => 'ensure', 2 => 'installed' }
+    },
+    { # ensure => present
+      sequence: [:NAME, :FARROW, :NAME],
+      values: { 0 => 'ensure', 2 => 'present' }
+    },
+    { # ensure => present;
+      sequence: [:NAME, :FARROW, :NAME, :SEMIC],
+      values: { 0 => 'ensure', 2 => 'present' }
+    }
+  ].freeze
+
+  FORMATTING_TOKENS = PuppetLint::Lexer::FORMATTING_TOKENS
+
+  def check
+    if_indexes.each do |cond|
+      next if check_if(cond)
+
+      notify :warning,
+             message: 'ensure_packages should be used',
+             line: cond[:tokens].first.line,
+             column: cond[:tokens].first.column
+    end
+  end
+
+  def check_if(cond)
+    tokens = filter_code_tokens(cond[:tokens])
+
+    # Test start of patterns
+    return true unless match_tokens(tokens, TYPE_SEQUENCE_START, VALUE_SEQUENCE)
+
+    # Test end of pattern
+    return true unless match_tokens(tokens.last(2), TYPE_SEQUENCE_END, {})
+
+    tokens = tokens.slice(Range.new(TYPE_SEQUENCE_START.size,
+                                    -TYPE_SEQUENCE_END.size - 1))
+
+    return false if tokens.empty?
+
+    return true unless OPTINAL_CONTENT.index do |c|
+      match_tokens(tokens, c[:sequence], c[:values])
+    end
+
+    false
+  end
+
+  def match_tokens(tokens, type, value)
+    tokens.first(type.size).map(&:type) == type &&
+      value.values == value.keys.map { |i| tokens[i].value }
+  end
+
+  def fix(problem)
+    cond = if_indexes.select do |c|
+      c[:tokens].first.line == problem[:line] &&
+        c[:tokens].first.column == problem[:column]
+    end.first
+
+    package_name = filter_code_tokens(cond[:tokens])[NAME_INDEX].value
+
+    remove_tokens(cond[:start], cond[:end])
+
+    new_tokens = ensure_packages_tokens(package_name)
+
+    insert_tokens(cond[:start], new_tokens)
+
+    PuppetLint::Data.tokens = tokens
+
+    merge_if_possible(cond[:start])
+  end
+
+  def merge_if_possible(idx)
+    target = find_function('ensure_packages').keep_if do |func|
+      func[:tokens].last.next_code_token == tokens[idx] &&
+        func[:tokens].last.next_code_token != func[:tokens].first
+    end
+
+    return if target.empty?
+
+    # Count non :SSTRING, :COMMA tokens to ensure there are no parameters
+    return unless 5 == filter_code_tokens(target.first[:tokens]).count do |t|
+      ![:SSTRING, :COMMA].include?(t.type)
+    end
+
+    start_idx = tokens.first(idx).rindex { |t| t.type == :SSTRING } + 1
+
+    remove_tokens(start_idx, idx + 2)
+    insert_tokens(start_idx, [PuppetLint::Lexer::Token.new(:COMMA, ',', 0, 0)])
+  end
+
+  def find_function(name)
+    PuppetLint::Data.function_indexes.keep_if do |func|
+      func[:tokens].first.type == :NAME &&
+        func[:tokens].first.value == name
+    end
+  end
+
+  def tokens_idx(obj)
+    tokens.index(obj)
+  end
+
+  def remove_tokens(from, to)
+    num = to - from + 1
+    tokens.slice!(from, num)
+    fix_linked_list
+  end
+
+  def insert_tokens(idx, new_tokens)
+    tokens.insert(idx, *new_tokens)
+    fix_linked_list
+  end
+
+  def ensure_packages_tokens(name)
+    [
+      PuppetLint::Lexer::Token.new(:NAME, 'ensure_packages', nil, nil),
+      PuppetLint::Lexer::Token.new(:LPAREN, '(', nil, nil),
+      PuppetLint::Lexer::Token.new(:LBRACK, '[', nil, nil),
+      PuppetLint::Lexer::Token.new(:SSTRING, name, nil, nil),
+      PuppetLint::Lexer::Token.new(:RBRACK, ']', nil, nil),
+      PuppetLint::Lexer::Token.new(:RPAREN, ')', nil, nil)
+    ]
+  end
+
+  def fix_linked_list
+    tokens.each_cons(2) do |a, b|
+      a.next_token = b
+      b.prev_token = a
+    end
+
+    filter_formating_tokens(tokens).each_cons(2) do |a, b|
+      a.next_code_token = b
+      b.prev_code_token = a
+    end
+  end
+
+  def filter_code_tokens(tokens)
+    tokens.delete_if { |token| FORMATTING_TOKENS.key? token.type }
+  end
+
+  def filter_formating_tokens(tokens)
+    tokens.select { |token| !FORMATTING_TOKENS.key? token.type }
+  end
+
+  def if_indexes
+    PuppetLint::Data.definition_indexes(:IF)
+  end
+end

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

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+describe 'use_ensure_packages' do
+  context 'with fix disabled' do
+    context 'if not defined package' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': }
+        }"
+      end
+
+      it 'should detect the problem' do
+        expect(problems).to have(1).problems
+      end
+    end
+
+    context 'if not defined package ensure installed' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': ensure => installed }
+        }"
+      end
+
+      it 'should detect the problem' do
+        expect(problems).to have(1).problems
+      end
+    end
+
+    context 'if not defined package ensure installed' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': ensure => installed; }
+        }"
+      end
+
+      it 'should detect the problem' do
+        expect(problems).to have(1).problems
+      end
+    end
+
+    context 'if not defined package ensure installed' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': ensure => present }
+        }"
+      end
+
+      it 'should detect the problem' do
+        expect(problems).to have(1).problems
+      end
+    end
+
+    context 'if not defined package ensure installed' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': ensure => present; }
+        }"
+      end
+
+      it 'should detect the problem' do
+        expect(problems).to have(1).problems
+      end
+    end
+
+    context 'if not defined package twice' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': }
+        }
+        use { 'foo': }
+        if ! defined (Package['bar']) {
+          package {'bar': }
+        }"
+      end
+
+      it 'should detect the problem' do
+        expect(problems).to have(2).problems
+      end
+    end
+
+    context 'if not defined file' do
+      let(:code) do
+        "if ! defined (File['foo']) {
+          File {'foo': }
+        }"
+      end
+
+      it 'should not detect any problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+  end
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'if not defined package' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': }
+        }"
+      end
+      let(:expected_code) do
+        "ensure_packages(['foo'])"
+      end
+
+      it 'should solve the problem' do
+        expect(manifest).to eq(expected_code)
+      end
+    end
+
+    context 'if not defined package ensure installed' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': ensure => installed }
+        }"
+      end
+      let(:expected_code) do
+        "ensure_packages(['foo'])"
+      end
+
+      it 'should solve the problem' do
+        expect(manifest).to eq(expected_code)
+      end
+    end
+
+    context 'if not defined package twice' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': }
+        }
+        use { 'foo': }
+        if ! defined (Package['bar']) {
+          package {'bar': }
+        }"
+      end
+      let(:expected_code) do
+        "ensure_packages(['foo'])
+        use { 'foo': }
+        ensure_packages(['bar'])"
+      end
+
+      it 'should solve the problem' do
+        expect(manifest).to eq(expected_code)
+      end
+    end
+
+    context 'merge generated ensure_packages statements' do
+      let(:code) do
+        "if ! defined (Package['foo']) {
+          package {'foo': }
+        }
+        if ! defined (Package['bar']) {
+          package {'bar': }
+        }"
+      end
+      let(:expected_code) do
+        "ensure_packages(['foo','bar'])"
+      end
+
+      it 'should solve the problem' do
+        expect(manifest).to eq(expected_code)
+      end
+    end
+
+    context 'merge to pre existing ensure_packages' do
+      let(:code) do
+        "ensure_packages(['foo'])
+        if ! defined (Package['bar']) {
+          package {'bar': }
+        }"
+      end
+      let(:expected_code) do
+        "ensure_packages(['foo','bar'])"
+      end
+
+      it 'should solve the problem' do
+        expect(manifest).to eq(expected_code)
+      end
+    end
+
+    context 'do not merge to pre existing ensure_packages with arguments' do
+      let(:code) do
+        "ensure_packages(['foo'], {'ensure' => 'present'})
+         if ! defined (Package['bar']) {
+           package {'bar': }
+         }"
+      end
+      let(:expected_code) do
+        "ensure_packages(['foo'], {'ensure' => 'present'})
+         ensure_packages(['bar'])"
+      end
+
+      it 'should solve the problem' do
+        expect(manifest).to eq(expected_code)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'puppet-lint'
+require 'simplecov'
+require 'simplecov-console'
+
+PuppetLint::Plugins.load_spec_helper
+
+SimpleCov.formatter = SimpleCov::Formatter::Console
+SimpleCov.start do
+  add_filter '/spec'
+  add_filter '.bundle'
+  add_filter '/vendor'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: puppet-lint-use_ensure_packages-check
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marius Rieder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puppet-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.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: rspec-json_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    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-console
+  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 contains if ! defined (Package
+  statements.\n"
+email: marius.rieder@nine.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/puppet-lint/plugins/check_use_ensure_packages.rb
+- spec/puppet-lint/plugins/check_use_ensure_packages_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ninech/puppet-lint-use_ensure_packages-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: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A puppet-lint plugin for "if !defined(Package" syntax.
+test_files:
+- spec/puppet-lint/plugins/check_use_ensure_packages_spec.rb
+- spec/spec_helper.rb