puppet-retrospec 0.11.0 → 0.12.0

data/lib/retrospec/plugins/v1/plugin/puppet_module.rb

@@ -1,5 +1,7 @@
 require 'singleton'
 require 'puppet/face'
+require_relative 'exceptions'
+
 module Utilities
   class PuppetModule
     attr_writer :module_path
@@ -33,17 +35,13 @@ module Utilities
 
     # create the temporary module create, validate the
     def self.create_tmp_module_path
-      Utilities::PuppetModule::instance.create_tmp_module_path(module_path)
+      Utilities::PuppetModule.instance.create_tmp_module_path(module_path)
     end
 
     def self.clean_tmp_modules_dir
-      FileUtils.remove_entry_secure instance.tmp_modules_dir  # ensure we remove the temporary directory
-    end
-
-    def module_path
-      @module_path
+      FileUtils.remove_entry_secure instance.tmp_modules_dir # ensure we remove the temporary directory
     end
-
+    attr_reader :module_path
     # validate and set the module path
     def module_path=(path)
       @module_path = validate_module_dir(path)
@@ -62,14 +60,14 @@ module Utilities
       if dir.nil?
         dir = '.'
       elsif dir.instance_of?(Array)
-        puts "Retrospec - an array of module paths is not supported at this time".fatal
-        exit 1
+        puts 'Retrospec - an array of module paths is not supported at this time'.fatal
+        raise Retrospec::Puppet::InvalidModulePathError
       end
       dir = File.expand_path(dir)
-      manifest_dir = File.join(dir,'manifests')
-      if ! File.exist?(manifest_dir)
+      manifest_dir = File.join(dir, 'manifests')
+      if !File.exist?(manifest_dir)
         puts "No manifest directory in #{manifest_dir}, cannot validate this is a module".fatal
-        exit 1
+        raise Retrospec::Puppet::NoManifestDirError
       else
         files = Dir.glob("#{manifest_dir}/**/*.pp")
         warn "No puppet manifest files found at #{manifest_dir}".warning if files.length < 1
@@ -80,7 +78,7 @@ module Utilities
             Puppet::Face[:parser, :current].validate(file)
           rescue SystemExit => e
             puts "Manifest file: #{file} has parser errors, please fix and re-check using\n puppet parser validate #{file}".fatal
-            exit 1
+            raise Retrospec::Puppet::ParserError
           end
         end
         # switch back to current parser, since we rely on the AST parser
@@ -93,9 +91,9 @@ module Utilities
 
     # puts a symlink in that module directory that points back to the user supplied module path
     def create_tmp_module_path(module_path)
-      raise "ModulePathNotFound" unless module_path
+      fail 'ModulePathNotFound' unless module_path
       path = File.join(tmp_modules_dir, module_dir_name)
-      unless File.exists?(path) # only create if it doesn't already exist
+      unless File.exist?(path) # only create if it doesn't already exist
         # create a link where source is the current repo and dest is /tmp/modules/module_name
         FileUtils.ln_s(module_path, path)
       end
@@ -109,26 +107,32 @@ module Utilities
     # the directory name of the module
     # usually this is the same as the module name but it can be namespaced sometimes
     def module_dir_name
-      raise "ModulePathNotFound" unless module_path
+      fail 'ModulePathNotFound' unless module_path
       @module_dir_name ||= File.basename(module_path)
     end
 
+    def module_dir_name=(name)
+      @module_dir_name = name
+    end
+
     def module_type_names
-      types.map {|x| x.name}
+      types.map(&:name)
+    end
+
+    def module_name=(name)
+      @module_name = name
     end
 
     # returns the name of the module  ie. mysql::config  => mysql
     def module_name
-      begin
-        @module_name ||= types.first.name.split('::').first
-      rescue
-        @module_name = module_dir_name
-      end
+      @module_name ||= types.first.name.split('::').first
+    rescue
+      @module_name ||= module_dir_name
     end
 
     # creates a tmp module directory so puppet can work correctly
     def tmp_modules_dir
-      if @tmp_modules_dir.nil? or not File.exists?(@tmp_modules_dir)
+      if @tmp_modules_dir.nil? || !File.exist?(@tmp_modules_dir)
         dir = Dir.mktmpdir
         tmp_path = File.expand_path(File.join(dir, 'modules'))
         FileUtils.mkdir_p(tmp_path)
@@ -137,7 +141,6 @@ module Utilities
       @tmp_modules_dir
     end
 
-
     # creates a puppet environment given a module path and environment name
     def puppet_environment
       @puppet_environment ||= Puppet::Node::Environment.create('production', [tmp_modules_dir])
@@ -164,12 +167,12 @@ module Utilities
     end
 
     # returns the resource types found in the module
-    def search_module(pattern='*')
+    def search_module(pattern = '*')
       request = request(pattern, 'search')
       resource_type_parser.search(request)
     end
 
-    # TODO we need to parse the types and find all the types that inherit other types and then order them so we can load the files first
+    # TODO: we need to parse the types and find all the types that inherit other types and then order them so we can load the files first
     def types
       @types ||= search_module || []
     end

data/lib/retrospec/plugins/v1/plugin/resource.rb

@@ -1,14 +1,13 @@
 require_relative 'variable_store'
 
 class Resource
-
   attr_reader :type, :title, :parameters, :scope_name
 
-  def initialize(type_name,instance)
+  def initialize(type_name, instance)
     # we don't store the resource parameters in the variablestore because they are never referenced
-    @parameters = Hash[instance.parameters.map { |k| [k.param, VariableStore.resolve(k.value).gsub("\"", '')]}]
+    @parameters = Hash[instance.parameters.map { |k| [k.param, VariableStore.resolve(k.value).delete("\"")] }]
     @type = type_name
-    @title = VariableStore.resolve(instance.title).gsub("\"", '')
+    @title = VariableStore.resolve(instance.title).delete("\"")
   end
 
   # Gets all resources in the type that are not in a code block
@@ -20,7 +19,7 @@ class Resource
     a = []
     # sometimes the code is empty
     if statements.respond_to?(:find_all)
-      res = statements.find_all { |s| s.instance_of?(Puppet::Parser::AST::Resource)}
+      res = statements.find_all { |s| s.instance_of?(Puppet::Parser::AST::Resource) }
       res.each do |r|
         r.instances.each do |i|
           a << Resource.new(r.type, i)
@@ -31,6 +30,6 @@ class Resource
   end
 
   def self.all_resources
-    ObjectSpace.each_object(Puppet::Parser::AST::Resource).map {|x| x}
+    ObjectSpace.each_object(Puppet::Parser::AST::Resource).map { |x| x }
   end
-end
+end

data/lib/retrospec/plugins/v1/plugin/spec_object.rb

@@ -4,11 +4,9 @@ module Retrospec
     # this object is passed to the templates for erb template rendering
     # you can use data contained in this object in your templates
     class SpecObject < Retrospec::Plugins::V1::ContextObject
-
       attr_reader :instance, :module_path, :module_name, :all_hiera_data, :config
       attr_accessor :enable_beaker_tests, :parameters, :types, :resources, :type
 
-
       def initialize(mod_path, instance_data, config_data)
         @instance = instance_data
         @config = config_data
@@ -27,9 +25,9 @@ module Retrospec
       def class_hiera_data(classname)
         data = {}
         types.each do |t|
-          next unless t.type == :hostclass   #defines don't have hiera lookup values
+          next unless t.type == :hostclass # defines don't have hiera lookup values
           next unless t.name == classname
-          t.arguments.each do |k, v|
+          t.arguments.each do |k, _v|
             key = "#{t.name}::#{k}"
             data[key] = nil
           end
@@ -42,8 +40,8 @@ module Retrospec
         if @all_hiera_data.nil?
           @all_hiera_data = {}
           types.each do |t|
-            next unless t.type == :hostclass   #defines don't have hiera lookup values
-            t.arguments.each do |k, v|
+            next unless t.type == :hostclass # defines don't have hiera lookup values
+            t.arguments.each do |k, _v|
               key = "#{t.name}::#{k}"
               @all_hiera_data[key] = nil
             end
@@ -64,7 +62,6 @@ module Retrospec
       def fact_name
         instance[:name]
       end
-
     end
   end
-end
+end

data/lib/retrospec/plugins/v1/plugin/template_helpers.rb

@@ -4,12 +4,12 @@ module Retrospec
     module TemplateHelpers
       # creates the user supplied or default template directory
       # returns: user_template_dir
-      def create_user_template_dir(user_template_directory=nil)
+      def create_user_template_dir(user_template_directory = nil)
         if user_template_directory.nil?
           user_template_directory = default_user_template_dir
         end
         # create default user template path or supplied user template path
-        if not File.exists?(user_template_directory)
+        unless File.exist?(user_template_directory)
           FileUtils.mkdir_p(File.expand_path(user_template_directory))
         end
         user_template_directory
@@ -27,7 +27,7 @@ module Retrospec
 
       # creates and syncs the specifed user template diretory
       # returns: user_template_dir
-      def setup_user_template_dir(user_template_directory=nil, git_url=nil, branch=nil)
+      def setup_user_template_dir(user_template_directory = nil, git_url = nil, branch = nil)
         if user_template_directory.nil?
           user_template_directory = default_user_template_dir
         end
@@ -37,7 +37,7 @@ module Retrospec
       end
 
       def default_user_template_dir
-        File.expand_path(File.join(ENV['HOME'], '.retrospec','repos', 'retrospec-puppet-templates' ))
+        File.expand_path(File.join(ENV['HOME'], '.retrospec', 'repos', 'retrospec-puppet-templates'))
       end
 
       def gem_template_dir
@@ -49,15 +49,15 @@ module Retrospec
       # from an external repo. Because templates are updated frequently
       # and users will sometimes have client specific templates I wanted to
       # externalize them for easier management.
-      def run_clone_hook(template_dir, git_url=nil, branch=nil)
-        if File.exists?(File.join(template_dir,'clone-hook'))
-          hook_file = File.join(template_dir,'clone-hook')
+      def run_clone_hook(template_dir, git_url = nil, branch = nil)
+        if File.exist?(File.join(template_dir, 'clone-hook'))
+          hook_file = File.join(template_dir, 'clone-hook')
         else
           hook_file = File.join(gem_template_dir, 'clone-hook')
         end
-        if File.exists?(hook_file)
+        if File.exist?(hook_file)
           output = `#{hook_file} #{template_dir} #{git_url} #{branch}`
-          if $?.success?
+          if $CHILD_STATUS.success?
             puts "Successfully ran hook: #{hook_file}".info
             puts output.info
           else
@@ -69,4 +69,3 @@ module Retrospec
     end
   end
 end
-

data/lib/retrospec/plugins/v1/plugin/templates/clone-hook

@@ -2,7 +2,12 @@
 require 'fileutils'
 require 'open-uri'
 
-@template_dir    = ARGV[0] || File.join(ENV['HOME'], '.retrospec','repos','retrospec-puppet-templates')
+# this hook is only called once until the template directory is clone
+# once the template directory is cloned the, the clone hook from the template directory
+# will be run instead of this file.  This is on purpose in order to allow the user
+# to easily to customize the hook.
+
+@template_dir    = ARGV[0] || File.join(ENV['HOME'], '.retrospec', 'repos', 'retrospec-puppet-templates')
 @template_repo   = ARGV[1] || 'https://github.com/nwops/retrospec-templates'
 @template_branch = ARGV[2] || 'master'
 
@@ -14,26 +19,28 @@ def create_repo(template_dir, git_url, branch)
 end
 
 def git_exists?(template_dir)
-  File.exists? File.join(template_dir,'.git','config')
+  File.exist? File.join(template_dir, '.git', 'config')
 end
 
 def origin_exists?(template_dir)
   `git -C #{template_dir} remote show origin`
-  $?.success?
+  $CHILD_STATUS.success?
 end
 
-def update_templates(git_url, dest, branch='master')
+def update_templates(git_url, dest, branch = 'master')
   create_repo(dest, git_url, branch)
   puts `git -C #{dest} pull`
   dest
 end
 
 def connected?
-  open("http://www.google.com/") rescue false
+  unless ENV['CLONE_RETROSPEC_TEMPLATES'].nil?
+    # if the user wants internet but doesn't want cloning, allow them to set this variable
+    return false
+  end
+  open('http://www.google.com/') rescue false
 end
 
 # sometimes I work on an airplane and don't care to clone everything all the time
 # so lets check for connectivity first
-if connected?
-  update_templates(@template_repo, @template_dir, @template_branch)
-end
+update_templates(@template_repo, @template_dir, @template_branch) if connected?

data/lib/retrospec/plugins/v1/plugin/type_code.rb

@@ -5,9 +5,9 @@ require 'retrospec/exceptions'
 class TypeCode
   attr_reader :type, :variables, :scope_name, :parent, :name
 
-  #TODO figure out how to store vardef statements that are contained inside conditional blocks
+  # TODO: figure out how to store vardef statements that are contained inside conditional blocks
   def initialize(type)
-    raise TypeNotFoundException unless type
+    fail TypeNotFoundException unless type
     @scope_name = type.namespace
     @name = type.name
     @type = type
@@ -21,10 +21,10 @@ class TypeCode
   # returns a list of variables found in the main code block
   def variables
     if @type.code.respond_to?(:find_all)
-      @variables ||= @type.code.find_all {|i| i.instance_of?(Puppet::Parser::AST::VarDef) }
+      @variables ||= @type.code.find_all { |i| i.instance_of?(Puppet::Parser::AST::VarDef) }
     else
       @variables = []
     end
     @variables
   end
-end
+end

data/lib/retrospec/plugins/v1/plugin/variable_store.rb

@@ -20,16 +20,14 @@ class VariableStore
 
   # key should be a variable starting with $
   # enable_value_conversion converts the value to a string
-  def self.add(key, value, enable_value_conversion=true)
-    if key.respond_to?(:value)
-      key = key.value
-    end
+  def self.add(key, value, enable_value_conversion = true)
+    key = key.value if key.respond_to?(:value)
     # the key name must always be the same and look like $key_name or $key_name::other::name
     key = "#{'$' + key.to_s}" unless key.to_s.start_with?('$')
-    key = key.to_s.gsub('$::', '$') if key.to_s.start_with?('$::')    # sometimes variables start with $::
-    #return if instance.store[key] == value
-    if value.instance_of?(String) or value.instance_of?(Puppet::Parser::AST::String)
-      value = value.to_s.gsub("\"",'')
+    key = key.to_s.gsub('$::', '$') if key.to_s.start_with?('$::') # sometimes variables start with $::
+    # return if instance.store[key] == value
+    if value.instance_of?(String) || value.instance_of?(Puppet::Parser::AST::String)
+      value = value.to_s.delete("\"")
     end
     if enable_value_conversion
       instance.store[key.to_s] = value.to_s
@@ -40,22 +38,20 @@ class VariableStore
 
   # lookup the key in the hash, if we dont' find it lets just return the string representation
   def self.lookup(key)
-    if key.respond_to?(:value)
-      key = key.value
-    end
-    key = "$#{key.to_s}" unless key.to_s.start_with?('$')
-    key = key.gsub('$::', '$') if key.to_s.start_with?('$::')    # sometimes variables start with $::
-    #puts "Looking up: #{key}"
+    key = key.value if key.respond_to?(:value)
+    key = "$#{key}" unless key.to_s.start_with?('$')
+    key = key.gsub('$::', '$') if key.to_s.start_with?('$::') # sometimes variables start with $::
+    # puts "Looking up: #{key}"
     begin
       value = VariableStore.instance.store.fetch(key.to_s)
       # try and resolve if necessary
-      if [Puppet::Parser::AST::Variable,Puppet::Parser::AST::VarDef].include?(value.class)
+      if [Puppet::Parser::AST::Variable, Puppet::Parser::AST::VarDef].include?(value.class)
         value = resolve(value)
       else
         if captures = value.scan(/(\$[::]?[\w+::]*\w+)/).flatten
           # produces an array of variables that have not been resolved yet
           #  ["$concat1", "$concat"] = "$concat1/test3183/$concat"
-          captures.each { |c| value.gsub(c, resolve(c))}
+          captures.each { |c| value.gsub(c, resolve(c)) }
         end
       end
     rescue
@@ -69,12 +65,12 @@ class VariableStore
     res = nil
     if variable.instance_of? Puppet::Parser::AST::VarDef
       res = lookup(variable.name.value)
-      #add(variable.name, variable.value,false) unless res.nil?
+      # add(variable.name, variable.value,false) unless res.nil?
     elsif variable.instance_of?(Puppet::Parser::AST::Variable)
       res = lookup(variable.value)
     elsif variable.instance_of?(Puppet::Parser::AST::Concat)
       begin
-        res = variable.value.map { |i| variable_resolution(i)}.join.gsub("\"",'')
+        res = variable.value.map { |i| variable_resolution(i) }.join.delete("\"")
       rescue
         res = variable.value
       end
@@ -85,7 +81,7 @@ class VariableStore
     unless res.nil?
       if variable.instance_of?(Puppet::Parser::AST::Variable)
         unless res = lookup(variable.to_s)
-          #add(variable.to_s, res)
+          # add(variable.to_s, res)
         end
       end
     end
@@ -99,8 +95,8 @@ class VariableStore
 
   # gets all the variables and parameters and passes them through the resolve function to populate the variable store
   # we use recursion to evaluate inherited manifests
-  # TODO use the same recursion method to evaluate included manifests
-  def self.populate(type, is_parent=false)
+  # TODO: use the same recursion method to evaluate included manifests
+  def self.populate(type, is_parent = false)
     if type.parent
       p = type.parent.gsub(/\A::/, '')
       parent = type.resource_type_collection.hostclasses[p]
@@ -110,14 +106,14 @@ class VariableStore
     if parent
       # type has a parent and we want to add the parent variables first so we call populate first
       # then we load the type's variable
-      populate(parent,true)
+      populate(parent, true)
       # we load the local scope and top scope variables because we need access to both
       # there is a chance some of the local scope variables will be overwritten but by the time that happens
       # we won't need them anymore.
-      type.arguments.each do |k,v|
+      type.arguments.each do |k, v|
         # store the class params
-        add(k.to_s,resolve(v),true)
-        add(("$#{type.namespace}::" << k.to_s),resolve(v),true)
+        add(k.to_s, resolve(v), true)
+        add(("$#{type.namespace}::" << k.to_s), resolve(v), true)
       end
       TypeCode.new(type).variables.each do |v|
         add(v.name.to_s, resolve(v.value))
@@ -125,14 +121,14 @@ class VariableStore
       end
     elsif is_parent
       # if this is the parent we load the variables
-      type.arguments.each {|k,v| add(("$#{type.namespace}::" << k.to_s),resolve(v),true)}
-      TypeCode.new(type).variables.each {|v| add(("$#{type.namespace}::" << v.name.to_s), resolve(v.value))}
+      type.arguments.each { |k, v| add(("$#{type.namespace}::" << k.to_s), resolve(v), true) }
+      TypeCode.new(type).variables.each { |v| add(("$#{type.namespace}::" << v.name.to_s), resolve(v.value)) }
     else
       # if the type does not have a parent we load the variables
-      type.arguments.each do |k,v|
+      type.arguments.each do |k, v|
         # store the class params
-        add(k.to_s,resolve(v),true)
-        add(("$#{type.namespace}::" << k.to_s),resolve(v),true)
+        add(k.to_s, resolve(v), true)
+        add(("$#{type.namespace}::" << k.to_s), resolve(v), true)
       end
       TypeCode.new(type).variables.each do |v|
         add(v.name.to_s, resolve(v.value))