puppet_rake_tasks 1.0.0

data/README.md

@@ -0,0 +1,57 @@
+# PuppetModuleTask
+
+TODO: Delete this and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'puppet_rake_tasks'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install puppet_rake_tasks
+
+## Usage
+
+### Simple usage:
+
+1. Add the ruby gem: `gem 'puppet_rake_tasks'`
+2. Require the depchecker in your `Rakefile`: `require 'puppet_rake_tasks/depchecker'`
+3. Create the task: `PuppetRakeTasks::DepChecker::Task.new`
+4. Profit: `rake exec depcheck
+
+### Advanced usage:
+
+Optionally, you can also configure the task:
+
+```ruby
+require 'puppet_rake_tasks/depchecker'
+PuppetRakeTasks::DepChecker::Task.new do |checker|
+  checker.fail_on_error = true
+  checker.modulepath = [
+    'site',
+    'modules'
+  ]
+  checker.ignore /.*/, { name: 'foo/bar', reason: :missing }
+end
+```
+
+## Development
+
+After checking out the repo, run `bundler install` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bundle console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/vStone/puppet_rake_tasks).
+
+## License
+
+The gem is available as open source under the terms of the [GPL-3 License](http://opensource.org/licenses/GPL-3.0).
+

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+desc 'Run rubocop'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.formatters = %w(fuubar offenses)
+  task.fail_on_error = true
+end
+
+RSpec::Core::RakeTask.new(:spec)
+YARD::Rake::YardocTask.new(:docs)
+
+task default: [:rubocop, :spec]

data/lib/puppet_rake_tasks/depchecker/filter.rb

@@ -0,0 +1,38 @@
+module PuppetRakeTasks
+  module DepChecker
+    class Resolver
+      # Apply ignore rules to incidents and return the filtered results
+      module Filter
+        # @return [Hash] list with filtered incidents (cached).
+        def filtered
+          @filtered ||= filter_incidents
+        end
+
+        private
+
+        # This method calls ignores_matches_incident for each issue and removes it
+        # if the result of the call is true. The ignores_matches_incident will loop
+        # all configured ignores (global/wildcards or specific for the module)
+        # @param issues [Array] An array with all issues related to the module to check.
+        # @param modulename [String] simple module name to filter incidents for.
+        # @return [Array] with filtered issues.
+        def filter_module_incidents(modulename, issues)
+          ## Reject all incidents that match an ignore rule
+          issues.reject do |incident|
+            ignores_matches_incident(modulename, incident)
+          end
+        end
+
+        # Loop all incidents and apply the ignore filters for each module.
+        # Modules without no incidents (emtpy array) are also removed from the result.
+        # @return [Hash] filtered incidents.
+        def filter_incidents
+          intermediate = incidents.update(incidents) do |modulename, issues|
+            filter_module_incidents(modulename, issues)
+          end
+          intermediate.reject { |_m, i| i.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/puppet_rake_tasks/depchecker/helpers.rb

@@ -0,0 +1,70 @@
+module PuppetRakeTasks
+  module DepChecker
+    # General helpers for various methods.
+    module Helpers
+      class << self
+        # Normalize paths split by `File::PATH_SEPARATOR` by making sure it always
+        # returns an array of paths.
+        # @param path [String,Array] A string or an array with paths.
+        # @return [Array] The normalized paths
+        def normalize_path(path)
+          if path.is_a?(String)
+            path.split(File::PATH_SEPARATOR)
+          else
+            [path].flatten
+          end
+        end
+
+        # Compare values by converting symbols to strings or by using
+        # regexes to match if the ignore_value is one.
+        # @param ignore_value [String,Regex,Symbol] Value to compare
+        # @param incident_value [String, Symbol] Value to compare against.
+        # @return [Boolean] true or false depending on the equality-ish-ness.
+        def compare_values(ignore_value, incident_value)
+          if ignore_value.is_a?(Regexp)
+            !ignore_value.match(incident_value.to_s).nil?
+          else
+            incident_value = incident_value.is_a?(Symbol) ? incident_value.to_s : incident_value
+            ignore_value = ignore_value.is_a?(Symbol) ? ignore_value.to_s : ignore_value
+            incident_value == ignore_value
+          end
+        end
+
+        # Swats hash keys and turns them into symbols. See example for what swatting is.
+        #
+        # @example Swatting a hash.
+        #   swat_hash({
+        #     'foo' => {
+        #       'bar' => 'rab',
+        #       'foo' => {
+        #         'super' => 'nested'
+        #       },
+        #     },
+        #     'extra' => 'value'
+        #   }, '_') #=>
+        #   {
+        #     :foo_bar => 'rab',
+        #     :foo_foo_super => 'nested',
+        #     :extra => 'value'
+        #   }
+        #
+        # @param hash [Hash] hash to swat.
+        # @param prefix [String] prefix to add to the keys. This is normally only filled in by recursive calls.
+        # @param glue [String] String to use to join the keys.
+        # @return [Hash<Symbol, Any>] Hash without nesting.
+        def swat_hash(hash, glue = '.', prefix = nil)
+          prefix = prefix.nil? ? '' : "#{prefix}#{glue}"
+          intermediate = {}
+          hash.each do |k, v|
+            if v.is_a?(Hash)
+              intermediate.merge!(swat_hash(v, glue, "#{prefix}#{k}"))
+            else
+              intermediate["#{prefix}#{k}".to_sym] = v
+            end
+          end
+          intermediate
+        end
+      end
+    end
+  end
+end

data/lib/puppet_rake_tasks/depchecker/ignores.rb

@@ -0,0 +1,107 @@
+require_relative 'helpers'
+
+module PuppetRakeTasks
+  module DepChecker
+    class Resolver
+      # Deal with management of the ignore rules you can set.
+      # You can either set all rules in one go using {#ignores=} or add one by one
+      # using the {#ignore} method.
+      #
+      # ## Reference:
+      # When referring to the 'simple name' of a puppet module, use the name without `author/` in front.
+      # You can not have a module with the same name installed in your tree anyhow.
+      #
+      # @example Adding a rule for a single module.
+      #   # Ignores the stdlib version mismatch on `your_module`.
+      #   @depchecker.ignore 'your_module', { name: 'puppetlabs/stdlib', reason: :version_mismatch }
+      #
+      # @example Adding a rule for a single module with regexp values.
+      #   # Ignores all modules from author `custom` that are missing.
+      #   @depchecker.ignore 'your_module', { name: %r{^custom/.*}, reason: :missing }
+      #
+      # @example Adding a rule for all modules using a regexp.
+      #   # ignores a missing module for all modules that might declare it as a dependency.
+      #   @depchecker.ignore %r{.*}, { name: 'foobar/module', reason: :missing }
+      #
+      # @example Loading ignores from a (yaml) file
+      #   @depchecker.ignores = YAML.load_file('.ignores.yaml')
+      #   # .ignores.yaml
+      #   # ---
+      #   # !ruby/regexp /.*/:
+      #   #   - :name: always/missing
+      #   #     :reason: :missing
+      #   # foobar:
+      #   #   - :name: !ruby/regexp /.*/
+      #   #     :reason: :version_mismatch
+      #
+      module Ignores
+        extend Helpers
+
+        # Configure all ignore rules at once by setting a single hash.
+        # This clears the cached ignore rules for modules.
+        # @param ignores [Hash] Hash with ignore rules.
+        def ignores=(ignores)
+          @ignores = ignores
+          @ignores_for_module = {}
+        end
+
+        # @param for_module [String,Regexp] module name or regex this rule applies to.
+        # @param expr [Hash] ignore expression.
+        def ignore(for_module, expr)
+          # reset cached ignores matching modules
+          (@ignores_for_module ||= {})[for_module] = nil
+
+          # initialize if not exists
+          (@ignores ||= {})[for_module] ||= []
+          @ignores[for_module] << expr
+        end
+
+        # Returns all configured ignore rules.
+        # @return [Hash] ignore rules.
+        def ignores
+          @ignores ||= {}
+        end
+
+        # Returns ignore rules that might apply to the modulename and caches the result.
+        # @param modulename [String] module name to get ignore rules for in its simple form.
+        def ignores_for_module(modulename)
+          if (@ignores_for_module ||= {})[modulename].nil?
+            @ignores_for_module[modulename] ||= collect_ignores_for_module(modulename)
+          end
+          @ignores_for_module[modulename]
+        end
+
+        # Loop over ignores for a modulename and check if it matches the incident.
+        # @param modulename [String] puppet module name.
+        # @param incident [Hash] The module incident to check.
+        def ignores_matches_incident(modulename, incident)
+          loop_ignores = ignores_for_module(modulename)
+          # Look for a match, return true immediately, otherwise, false
+          loop_ignores.each do |ign|
+            this_ignore = true
+            ign.keys.each do |k|
+              compare = Helpers.compare_values(ign[k], incident[k])
+              this_ignore = false unless compare
+            end
+            return true if this_ignore
+          end
+          false
+        end
+
+        private
+
+        # @param modulename [String] puppet module name. Must be in the 'simple' form.
+        # @return [Array] array with all ignores that apply to a certain puppet module.
+        def collect_ignores_for_module(modulename)
+          tmp_ignores = []
+          ignores.each do |k, i|
+            if (k.is_a?(String) && k == modulename) || (k.is_a?(Regexp) && modulename =~ k)
+              tmp_ignores += i
+            end
+          end
+          tmp_ignores
+        end
+      end
+    end
+  end
+end

data/lib/puppet_rake_tasks/depchecker/incidents.rb

@@ -0,0 +1,27 @@
+module PuppetRakeTasks
+  module DepChecker
+    class Resolver
+      # Collect all incidents
+      module Incidents
+        # Returns all (cached) detected incidents in modules.
+        # @return [Hash] all incidents.
+        def incidents
+          @incidents ||= initialize_incidents
+        end
+
+        # Detect all incidents for the current env.
+        # @return [Hash] incidents.
+        def initialize_incidents
+          tmp_incidents = {}
+          modules.by_name.each do |name, mod|
+            mod.unmet_dependencies.each do |incident|
+              tmp_incidents[name] ||= []
+              tmp_incidents[name] << incident
+            end
+          end
+          tmp_incidents
+        end
+      end
+    end
+  end
+end

data/lib/puppet_rake_tasks/depchecker/report.rb

@@ -0,0 +1,79 @@
+require 'pp'
+
+module PuppetRakeTasks
+  module DepChecker
+    class Resolver
+      # Prints stuff to `stderr` and optionally raises an error
+      module Report
+        extend Helpers
+
+        # Make sure we don't throw a too generic error.
+        class DependencyError < StandardError
+          attr_reader :filtered
+          def initialize(message, filtered)
+            @filtered = filtered
+            super(message)
+          end
+        end
+
+        attr_writer :fail_on_error
+        attr_writer :format
+        attr_writer :output
+
+        def output
+          @output ||= $stderr
+        end
+
+        # Returns the format configured (or the default format)
+        # @return [String] string fed into sprintf.
+        def format
+          @format ||= 'ERROR: module %<module_name>s: %<reason>s dependency %<name>s. '\
+            "Wants: '%<version_constraint>s', got: '%<mod_details.installed_version>s'\n"
+        end
+
+        # Boolean indicating wether or not we will fail (raise error) when there are incidents.
+        # @return [Boolean]
+        def fail_on_error
+          @fail_on_error ||= false
+        end
+
+        # Gets all filtered incidents for all modules and reports them module by module.
+        # @raise [DependencyError] if there are any issues detected and `fail_on_error` is enabled (`true`)
+        def report
+          filtered.each do |module_name, module_incidents|
+            format_module_incidents(module_name, module_incidents)
+          end
+          raise DependencyError.new('Module errors found', filtered) unless filtered.empty? || !fail_on_error
+        end
+
+        # Adds extra information to the incident hash for reporting purposes.
+        # @param incident [Hash] Incident to enrich.
+        # @return [Hash] copy of the incident with extra data and a default_proc assigned.
+        def enrich_incident(incident)
+          incident = Helpers.swat_hash(incident)
+          # For recent enough ruby versions, this default proc will just show missing
+          # keys in stead of failing on them (when using sprintf).
+          incident.default_proc = proc { |hash, key| hash[key] = "%<#{key}>s" }
+          incident
+        end
+
+        # Format all incidents for a certain module.
+        # @param module_name [String] name of the module the incidents are detected for.
+        # @param module_incidents [Array<Hash>] All incidents.
+        def format_module_incidents(module_name, module_incidents)
+          module_incidents.each do |incident|
+            # Add the module_name to the incident
+            info_hash = incident.merge(module_name: module_name)
+            format_incident(info_hash)
+          end
+        end
+
+        # Format a single incident.
+        # @param info_hash [Hash] hash with all information for the incident.
+        def format_incident(info_hash)
+          output.puts(Kernel.format(format, enrich_incident(info_hash)))
+        end
+      end
+    end
+  end
+end

data/lib/puppet_rake_tasks/depchecker/resolver.rb

@@ -0,0 +1,69 @@
+require 'puppet'
+require 'puppet/module_tool'
+
+require_relative 'helpers'
+require_relative 'ignores'
+require_relative 'incidents'
+require_relative 'filter'
+require_relative 'report'
+
+module PuppetRakeTasks
+  module DepChecker
+    # Class to detect all puppet module dependency issues.
+    # It uses puppet module tool internals to detect all issues.
+    class Resolver
+      include Helpers
+      include Ignores
+      include Incidents
+      include Filter
+      include Report
+
+      def initialize(module_path = '.')
+        @modulepath = Helpers.normalize_path(module_path)
+      end
+
+      # Returns the puppet module tool environment.
+      # @see http://www.rubydoc.info/gems/puppet/Puppet/ModuleTool#environment_from_options-class_method
+      def env
+        @env ||= Puppet::ModuleTool.environment_from_options(modulepath: modulepath_s)
+      end
+
+      # Collect the installed modules using Puppet::ModuleTool.
+      # @see http://www.rubydoc.info/gems/puppet/Puppet/ModuleTool/InstalledModules
+      def modules
+        @modules ||= Puppet::ModuleTool::InstalledModules.new(env)
+      end
+
+      # Clear all cached data (env, modules, incidents)
+      def reset_caches
+        @env = nil
+        @modules = nil
+        @incidents = nil
+      end
+
+      # Returns the configured module paths.
+      # @return [Array<String>] configured module paths as an array.
+      def modulepath
+        @modulepath ||= ['.']
+      end
+
+      # Return modulepath as a string
+      # @return [String] module paths joined with `File::PATH_SEPARATOR`
+      def modulepath_s
+        @modulepath.flatten.join(File::PATH_SEPARATOR)
+      end
+
+      # Set the modulepath and normalize using {Helpers#normalize_path}
+      # When the module path changes, cached values are {#reset_caches cleared}
+      # @param [Array<String>,String] path Module paths
+      # @return [Array<String>] configured and normalized module paths.
+      def modulepath=(path)
+        unless path == @modulepath
+          # reset the env and loaded modules when changing the modulepath
+          reset_caches
+        end
+        @modulepath = Helpers.normalize_path(path)
+      end
+    end
+  end
+end