(CONT-237) Rubocop - updates for puppetlabs_spec

Author: chelnak

lib/puppetlabs_spec_helper/puppetlabs_spec/files.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Style/GlobalVars # TODO: investigate the use of instance variables
+
 require 'fileutils'
 require 'tempfile'
 require 'pathname'
@@ -20,7 +22,7 @@ def self.in_tmp(path)
 
   def self.cleanup
     $global_tempfiles ||= []
-    while path = $global_tempfiles.pop
+    while (path = $global_tempfiles.pop)
       raise "Not deleting tmpfile #{path} outside regular tmpdir" unless in_tmp(path)
 
       begin

lib/puppetlabs_spec_helper/puppetlabs_spec/fixtures.rb

@@ -14,8 +14,8 @@ def fixtures(*rest)
   # <project>/spec/fixture/unit/facter/foo
   def my_fixture_dir
     callers = caller
-    while line = callers.shift
-      next unless found = line.match(%r{/spec/(.*)_spec\.rb:})
+    while (line = callers.shift)
+      next unless (found = line.match(%r{/spec/(.*)_spec\.rb:}))
 
       return fixtures(found[1])
     end
@@ -47,7 +47,7 @@ def my_fixtures(glob = '*', flags = 0, &block)
       raise "fixture '#{glob}' for #{my_fixture_dir} had no files!"
     end
 
-    block_given? && files.each(&block)
+    block && files.each(&block)
     files
   end
 end

lib/puppetlabs_spec_helper/puppetlabs_spec/matchers.rb

@@ -5,20 +5,15 @@
 
 ########################################################################
 # Backward compatibility for Jenkins outdated environment.
-module RSpec
-  module Matchers
-    module BlockAliases
-      if method_defined?(:should) && !method_defined?(:to)
-        alias to should
-      end
-      if method_defined? :should_not
-        alias to_not should_not unless method_defined? :to_not
-        alias not_to should_not unless method_defined? :not_to
-      end
-    end
+module RSpec::Matchers::BlockAliases
+  if method_defined?(:should) && !method_defined?(:to)
+    alias to should
+  end
+  if method_defined? :should_not
+    alias to_not should_not unless method_defined? :to_not
+    alias not_to should_not unless method_defined? :not_to
   end
 end
-
 ########################################################################
 # Custom matchers...
 RSpec::Matchers.define :have_matching_element do |expected|

lib/puppetlabs_spec_helper/puppetlabs_spec/puppet_internals.rb

@@ -4,74 +4,73 @@
 # 'puppetlabs_spec_helper/puppet_spec_helper' library
 require 'puppetlabs_spec_helper/puppet_spec_helper'
 
-module PuppetlabsSpec
-  module PuppetInternals
-    # parser_scope is intended to return a Puppet::Parser::Scope
-    # instance suitable for placing in a test harness with the intent of
-    # testing parser functions from modules.
-    def scope(parts = {})
-      RSpec.deprecate('scope', replacement: 'rspec-puppet 2.2.0 provides a scope property')
+# PuppetInternals provides a set of methods that interface
+# with internal puppet implementations.
+module PuppetlabsSpec::PuppetInternals
+  # parser_scope is intended to return a Puppet::Parser::Scope
+  # instance suitable for placing in a test harness with the intent of
+  # testing parser functions from modules.
+  def scope(parts = {})
+    RSpec.deprecate('scope', replacement: 'rspec-puppet 2.2.0 provides a scope property')
 
-      if %r{^2\.[67]}.match?(Puppet.version)
-        # loadall should only be necessary prior to 3.x
-        # Please note, loadall needs to happen first when creating a scope, otherwise
-        # you might receive undefined method `function_*' errors
-        Puppet::Parser::Functions.autoloader.loadall
-      end
+    if %r{^2\.[67]}.match?(Puppet.version)
+      # loadall should only be necessary prior to 3.x
+      # Please note, loadall needs to happen first when creating a scope, otherwise
+      # you might receive undefined method `function_*' errors
+      Puppet::Parser::Functions.autoloader.loadall
+    end
 
-      scope_compiler = parts[:compiler] || compiler
-      scope_parent = parts[:parent] || scope_compiler.topscope
-      scope_resource = parts[:resource] || resource(type: :node, title: scope_compiler.node.name)
+    scope_compiler = parts[:compiler] || compiler
+    scope_parent = parts[:parent] || scope_compiler.topscope
 
-      scope = if %r{^2\.[67]}.match?(Puppet.version)
-                Puppet::Parser::Scope.new(compiler: scope_compiler)
-              else
-                Puppet::Parser::Scope.new(scope_compiler)
-              end
+    scope = if %r{^2\.[67]}.match?(Puppet.version)
+              Puppet::Parser::Scope.new(compiler: scope_compiler)
+            else
+              Puppet::Parser::Scope.new(scope_compiler)
+            end
 
-      scope.source = Puppet::Resource::Type.new(:node, 'foo')
-      scope.parent = scope_parent
-      scope
-    end
-    module_function :scope
+    scope.source = Puppet::Resource::Type.new(:node, 'foo')
+    scope.parent = scope_parent
+    scope
+  end
+  module_function :scope
 
-    def resource(parts = {})
-      resource_type = parts[:type] || :hostclass
-      resource_name = parts[:name] || 'testing'
-      Puppet::Resource::Type.new(resource_type, resource_name)
-    end
-    module_function :resource
+  def resource(parts = {})
+    resource_type = parts[:type] || :hostclass
+    resource_name = parts[:name] || 'testing'
+    Puppet::Resource::Type.new(resource_type, resource_name)
+  end
+  module_function :resource
 
-    def compiler(parts = {})
-      compiler_node = parts[:node] || node
-      Puppet::Parser::Compiler.new(compiler_node)
-    end
-    module_function :compiler
+  def compiler(parts = {})
+    compiler_node = parts[:node] || node
+    Puppet::Parser::Compiler.new(compiler_node)
+  end
+  module_function :compiler
 
-    def node(parts = {})
-      node_name = parts[:name] || 'testinghost'
-      options = parts[:options] || {}
-      node_environment = if Puppet.version.to_f >= 4.0
-                           Puppet::Node::Environment.create(parts[:environment] || 'test', [])
-                         else
-                           Puppet::Node::Environment.new(parts[:environment] || 'test')
-                         end
-      options[:environment] = node_environment
-      Puppet::Node.new(node_name, options)
-    end
-    module_function :node
+  def node(parts = {})
+    node_name = parts[:name] || 'testinghost'
+    options = parts[:options] || {}
+    node_environment = if Puppet.version.to_f >= 4.0
+                         Puppet::Node::Environment.create(parts[:environment] || 'test', [])
+                       else
+                         Puppet::Node::Environment.new(parts[:environment] || 'test')
+                       end
+    options[:environment] = node_environment
+    Puppet::Node.new(node_name, options)
+  end
+  module_function :node
 
-    # Return a method instance for a given function.  This is primarily useful
-    # for rspec-puppet
-    def function_method(name, parts = {})
-      scope = parts[:scope] || scope()
-      # Ensure the method instance is defined by side-effect of checking if it
-      # exists.  This is a hack, but at least it's a hidden hack and not an
-      # exposed hack.
-      return nil unless Puppet::Parser::Functions.function(name)
+  # Return a method instance for a given function.  This is primarily useful
+  # for rspec-puppet
+  def function_method(name, parts = {})
+    scope = parts[:scope] || scope()
+    # Ensure the method instance is defined by side-effect of checking if it
+    # exists.  This is a hack, but at least it's a hidden hack and not an
+    # exposed hack.
+    return nil unless Puppet::Parser::Functions.function(name)
 
-      scope.method("function_#{name}".intern)
-    end
-    module_function :function_method
+    scope.method("function_#{name}".to_sym)
   end
+  module_function :function_method
 end