puppet 8.5.1-universal-darwin → 8.7.0-universal-darwin

data/lib/puppet/ssl/openssl_loader.rb

@@ -7,10 +7,7 @@ require_relative '../../puppet/util/platform'
 # core Puppet code to load correctly in JRuby environments that do not
 # have a functioning openssl (eg a FIPS enabled one).
 
-unless Puppet::Util::Platform.jruby_fips?
-  require 'openssl'
-  require 'net/https'
-else
+if Puppet::Util::Platform.jruby_fips?
   # Even in JRuby we need to define the constants that are wrapped in
   # Indirections: Puppet::SSL::{Key, Certificate, CertificateRequest}
   module OpenSSL
@@ -23,4 +20,7 @@ else
       class Certificate; end
     end
   end
+else
+  require 'openssl'
+  require 'net/https'
 end

data/lib/puppet/syntax_checkers/base64.rb

@@ -16,9 +16,9 @@ class Puppet::SyntaxCheckers::Base64 < Puppet::Plugins::SyntaxCheckers::SyntaxCh
   # @api public
   #
   def check(text, syntax, acceptor, source_pos)
-    raise ArgumentError.new(_("Base64 syntax checker: the text to check must be a String.")) unless text.is_a?(String)
-    raise ArgumentError.new(_("Base64 syntax checker: the syntax identifier must be a String, e.g. json, data+json")) unless syntax.is_a?(String)
-    raise ArgumentError.new(_("Base64 syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name }) unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    raise ArgumentError, _("Base64 syntax checker: the text to check must be a String.") unless text.is_a?(String)
+    raise ArgumentError, _("Base64 syntax checker: the syntax identifier must be a String, e.g. json, data+json") unless syntax.is_a?(String)
+    raise ArgumentError, _("Base64 syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name } unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
 
     cleaned_text = text.gsub(/[\r?\n[:blank:]]/, '')
     begin

data/lib/puppet/syntax_checkers/epp.rb

@@ -15,9 +15,9 @@ class Puppet::SyntaxCheckers::EPP < Puppet::Plugins::SyntaxCheckers::SyntaxCheck
   # @api public
   #
   def check(text, syntax, acceptor, source_pos)
-    raise ArgumentError.new(_("EPP syntax checker: the text to check must be a String.")) unless text.is_a?(String)
-    raise ArgumentError.new(_("EPP syntax checker: the syntax identifier must be a String, e.g. pp")) unless syntax == 'epp'
-    raise ArgumentError.new(_("EPP syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name }) unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    raise ArgumentError, _("EPP syntax checker: the text to check must be a String.") unless text.is_a?(String)
+    raise ArgumentError, _("EPP syntax checker: the syntax identifier must be a String, e.g. pp") unless syntax == 'epp'
+    raise ArgumentError, _("EPP syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name } unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
 
     begin
       Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.singleton.parse_string(text)

data/lib/puppet/syntax_checkers/json.rb

@@ -15,9 +15,9 @@ class Puppet::SyntaxCheckers::Json < Puppet::Plugins::SyntaxCheckers::SyntaxChec
   # @api public
   #
   def check(text, syntax, acceptor, source_pos)
-    raise ArgumentError.new(_("Json syntax checker: the text to check must be a String.")) unless text.is_a?(String)
-    raise ArgumentError.new(_("Json syntax checker: the syntax identifier must be a String, e.g. json, data+json")) unless syntax.is_a?(String)
-    raise ArgumentError.new(_("Json syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name }) unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    raise ArgumentError, _("Json syntax checker: the text to check must be a String.") unless text.is_a?(String)
+    raise ArgumentError, _("Json syntax checker: the syntax identifier must be a String, e.g. json, data+json") unless syntax.is_a?(String)
+    raise ArgumentError, _("Json syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name } unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
 
     begin
       Puppet::Util::Json.load(text)

data/lib/puppet/syntax_checkers/pp.rb

@@ -15,9 +15,9 @@ class Puppet::SyntaxCheckers::PP < Puppet::Plugins::SyntaxCheckers::SyntaxChecke
   # @api public
   #
   def check(text, syntax, acceptor, source_pos)
-    raise ArgumentError.new(_("PP syntax checker: the text to check must be a String.")) unless text.is_a?(String)
-    raise ArgumentError.new(_("PP syntax checker: the syntax identifier must be a String, e.g. pp")) unless syntax == 'pp'
-    raise ArgumentError.new(_("PP syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name }) unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    raise ArgumentError, _("PP syntax checker: the text to check must be a String.") unless text.is_a?(String)
+    raise ArgumentError, _("PP syntax checker: the syntax identifier must be a String, e.g. pp") unless syntax == 'pp'
+    raise ArgumentError, _("PP syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name } unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
 
     begin
       Puppet::Pops::Parser::EvaluatingParser.singleton.parse_string(text)

data/lib/puppet/transaction/additional_resource_generator.rb

@@ -191,7 +191,7 @@ class Puppet::Transaction::AdditionalResourceGenerator
       parent_contains || child_contains
     }
 
-    if not edge_exists
+    unless edge_exists
       # We *cannot* use target.to_resource here!
       #
       # For reasons that are beyond my (and, perhaps, human)

data/lib/puppet/transaction/event.rb

@@ -16,10 +16,10 @@ class Puppet::Transaction::Event
   attr_accessor :time
   attr_reader :default_log_level
 
-  EVENT_STATUSES = %w{noop success failure audit}
+  EVENT_STATUSES = %w[noop success failure audit]
 
   def self.from_data_hash(data)
-    obj = self.allocate
+    obj = allocate
     obj.initialize_from_hash(data)
     obj
   end

data/lib/puppet/transaction/event_manager.rb

@@ -79,7 +79,7 @@ class Puppet::Transaction::EventManager
       queue_events_for_resource(resource, resource, :refresh, [event]) if resource.self_refresh? and !resource.deleting?
     end
 
-    dequeue_events_for_resource(resource, :refresh) if events.detect { |e| e.invalidate_refreshes }
+    dequeue_events_for_resource(resource, :refresh) if events.detect(&:invalidate_refreshes)
   end
 
   def dequeue_all_events_for_resource(target)
@@ -142,27 +142,27 @@ class Puppet::Transaction::EventManager
   #   associated with this callback and resource.
   # @return [true, false] Whether the callback was successfully run.
   def process_callback(resource, callback, events)
-    if !process_callback?(resource, events)
+    unless process_callback?(resource, events)
       process_noop_events(resource, callback, events)
       return false
     end
 
     resource.send(callback)
 
-    if not resource.is_a?(Puppet::Type.type(:whit))
+    unless resource.is_a?(Puppet::Type.type(:whit))
       message = n_("Triggered '%{callback}' from %{count} event", "Triggered '%{callback}' from %{count} events", events.length) % { count: events.length, callback: callback }
       resource.notice message
       add_callback_status_event(resource, callback, message, "success")
     end
 
-    return true
+    true
   rescue => detail
     resource_error_message = _("Failed to call %{callback}: %{detail}") % { callback: callback, detail: detail }
     resource.err(resource_error_message)
     transaction.resource_status(resource).failed_to_restart = true
     transaction.resource_status(resource).fail_with_event(resource_error_message)
     resource.log_exception(detail)
-    return false
+    false
   end
 
   def add_callback_status_event(resource, callback, message, status)

data/lib/puppet/transaction/persistence.rb

@@ -21,7 +21,7 @@ class Puppet::Transaction::Persistence
       Puppet::Pops::Time::Timestamp,
       Puppet::Pops::Time::TimeData,
       Puppet::Pops::Time::Timespan,
-      Puppet::Pops::Types::PBinaryType::Binary,
+      Puppet::Pops::Types::PBinaryType::Binary
       # Puppet::Pops::Types::PSensitiveType::Sensitive values are excluded from
       # the persistence store, ignore it.
     ].freeze
@@ -64,7 +64,7 @@ class Puppet::Transaction::Persistence
   def copy_skipped(resource_name)
     @old_data["resources"] ||= {}
     old_value = @old_data["resources"][resource_name]
-    if !old_value.nil?
+    unless old_value.nil?
       @new_data["resources"][resource_name] = old_value
     end
   end
@@ -83,20 +83,18 @@ class Puppet::Transaction::Persistence
 
     result = nil
     Puppet::Util.benchmark(:debug, _("Loaded transaction store file in %{seconds} seconds")) do
+      result = Puppet::Util::Yaml.safe_load_file(filename, self.class.allowed_classes)
+    rescue Puppet::Util::Yaml::YamlLoadError => detail
+      Puppet.log_exception(detail, _("Transaction store file %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail })
+
       begin
-        result = Puppet::Util::Yaml.safe_load_file(filename, self.class.allowed_classes)
-      rescue Puppet::Util::Yaml::YamlLoadError => detail
-        Puppet.log_exception(detail, _("Transaction store file %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail })
-
-        begin
-          File.rename(filename, filename + ".bad")
-        rescue => detail
-          Puppet.log_exception(detail, _("Unable to rename corrupt transaction store file: %{detail}") % { detail: detail })
-          raise Puppet::Error, _("Could not rename corrupt transaction store file %{filename}; remove manually") % { filename: filename }, detail.backtrace
-        end
-
-        result = {}
+        File.rename(filename, filename + ".bad")
+      rescue => detail
+        Puppet.log_exception(detail, _("Unable to rename corrupt transaction store file: %{detail}") % { detail: detail })
+        raise Puppet::Error, _("Could not rename corrupt transaction store file %{filename}; remove manually") % { filename: filename }, detail.backtrace
       end
+
+      result = {}
     end
 
     unless result.is_a?(Hash)

data/lib/puppet/transaction/report.rb

@@ -144,7 +144,7 @@ class Puppet::Transaction::Report
   TOTAL = "total"
 
   def self.from_data_hash(data)
-    obj = self.allocate
+    obj = allocate
     obj.initialize_from_hash(data)
     obj
   end
@@ -344,8 +344,8 @@ class Puppet::Transaction::Report
       'noop' => @noop,
       'noop_pending' => @noop_pending,
       'environment' => @environment,
-      'logs' => @logs.map { |log| log.to_data_hash },
-      'metrics' => @metrics.transform_values { |metric| metric.to_data_hash },
+      'logs' => @logs.map(&:to_data_hash),
+      'metrics' => @metrics.transform_values(&:to_data_hash),
       'resource_statuses' => calculate_resource_statuses,
       'corrective_change' => @corrective_change,
     }
@@ -466,7 +466,7 @@ class Puppet::Transaction::Report
 
   def calculate_event_metrics
     metrics = Hash.new(0)
-    %w{total failure success}.each { |m| metrics[m] = 0 }
+    %w[total failure success].each { |m| metrics[m] = 0 }
     resource_statuses.each do |_name, status|
       metrics[TOTAL] += status.events.length
       status.events.each do |event|

data/lib/puppet/transaction/resource_harness.rb

@@ -217,7 +217,7 @@ class Puppet::Transaction::ResourceHarness
 
     # The event we've been provided might have been redacted so we need to use the state stored within
     # the resource application context to see if an event was actually generated.
-    if !are_audited_values_equal(context.historical_values[property.name], context.current_values[property.name])
+    unless are_audited_values_equal(context.historical_values[property.name], context.current_values[property.name])
       event.message = property.format(_("audit change: previously recorded value %s has been changed to %s"),
                                       property.is_to_s(event.historical_value),
                                       property.is_to_s(event.previous_value))
@@ -310,7 +310,7 @@ class Puppet::Transaction::ResourceHarness
       ResourceApplicationContext.new(resource,
                                      resource.retrieve_resource.to_hash,
                                      Puppet::Util::Storage.cache(resource).dup,
-                                     (resource[:audit] || []).map { |p| p.to_sym },
+                                     (resource[:audit] || []).map(&:to_sym),
                                      [],
                                      status,
                                      resource.parameters.select { |_n, p| p.is_a?(Puppet::Property) && !p.sensitive })

data/lib/puppet/transaction.rb

@@ -78,11 +78,9 @@ class Puppet::Transaction
     prerun_errors = {}
 
     @catalog.vertices.each do |res|
-      begin
-        res.pre_run_check
-      rescue Puppet::Error => detail
-        prerun_errors[res] = detail
-      end
+      res.pre_run_check
+    rescue Puppet::Error => detail
+      prerun_errors[res] = detail
     end
 
     unless prerun_errors.empty?
@@ -149,11 +147,9 @@ class Puppet::Transaction
       end
 
       post_evalable_providers.each do |provider|
-        begin
-          provider.post_resource_eval
-        rescue => detail
-          Puppet.log_exception(detail, _("post_resource_eval failed for provider %{provider}") % { provider: provider })
-        end
+        provider.post_resource_eval
+      rescue => detail
+        Puppet.log_exception(detail, _("post_resource_eval failed for provider %{provider}") % { provider: provider })
       end
 
       persistence.save if persistence.enabled?(catalog)
@@ -222,7 +218,7 @@ class Puppet::Transaction
 
   # Find all of the changed resources.
   def changed?
-    report.resource_statuses.values.find_all { |status| status.changed }.collect { |status| catalog.resource(status.resource) }
+    report.resource_statuses.values.find_all(&:changed).collect { |status| catalog.resource(status.resource) }
   end
 
   def relationship_graph
@@ -270,7 +266,7 @@ class Puppet::Transaction
     status = resource_harness.evaluate(resource)
     add_resource_status(status)
     ancestor ||= resource
-    if !(status.failed? || status.failed_to_restart?)
+    unless status.failed? || status.failed_to_restart?
       event_manager.queue_events(ancestor, status.events)
     end
   rescue => detail
@@ -316,7 +312,7 @@ class Puppet::Transaction
         @failed_class_dependencies_already_notified.merge(class_dependencies_to_be_notified)
       else
         unless @merge_dependency_warnings || is_puppet_class
-          s.failed_dependencies.find_all { |d| !(@failed_dependencies_already_notified.include?(d.ref)) }.each do |dep|
+          s.failed_dependencies.find_all { |d| !@failed_dependencies_already_notified.include?(d.ref) }.each do |dep|
             resource.notice _("Dependency %{dep} has failures: %{status}") % { dep: dep, status: resource_status(dep).failed }
             @failed_dependencies_already_notified.add(dep.ref)
           end
@@ -398,15 +394,15 @@ class Puppet::Transaction
 
   # Is the resource currently scheduled?
   def scheduled?(resource)
-    self.ignoreschedules || resource_harness.scheduled?(resource)
+    ignoreschedules || resource_harness.scheduled?(resource)
   end
 
   # Should this resource be skipped?
   def skip?(resource)
     if skip_tags?(resource)
-      resource.debug "Skipping with skip tags #{skip_tags.join(", ")}"
+      resource.debug "Skipping with skip tags #{skip_tags.join(', ')}"
     elsif missing_tags?(resource)
-      resource.debug "Not tagged with #{tags.join(", ")}"
+      resource.debug "Not tagged with #{tags.join(', ')}"
     elsif !scheduled?(resource)
       resource.debug "Not scheduled"
     elsif failed_dependencies?(resource)
@@ -418,7 +414,7 @@ class Puppet::Transaction
       unless resource.instance_of?(Puppet::Type.type(:whit))
         if @merge_dependency_warnings && resource.parent && failed_dependencies?(resource.parent)
           ps = resource_status(resource.parent)
-          ps.failed_dependencies.find_all { |d| !(@failed_class_dependencies_already_warned.include?(d.ref)) }.each do |dep|
+          ps.failed_dependencies.find_all { |d| !@failed_class_dependencies_already_warned.include?(d.ref) }.each do |dep|
             resource.parent.warning _("Skipping resources in class because of failed class dependencies")
             @failed_class_dependencies_already_warned.add(dep.ref)
           end
@@ -450,7 +446,7 @@ class Puppet::Transaction
     return false if ignore_tags?
     return false if tags.empty?
 
-    not resource.tagged?(*tags)
+    !resource.tagged?(*tags)
   end
 
   def skip_tags?(resource)

data/lib/puppet/type/component.rb

@@ -45,11 +45,11 @@ Puppet::Type.newtype(:component) do
     else
       myname = reference.to_s
     end
-    p = self.parent
+    p = parent
     if p
-      return [p.pathbuilder, myname]
+      [p.pathbuilder, myname]
     else
-      return [myname]
+      [myname]
     end
   end
 

data/lib/puppet/type/exec.rb

@@ -85,9 +85,7 @@ module Puppet
 
     newproperty(:returns, :array_matching => :all, :event => :executed_command) do |_property|
       include Puppet::Util::Execution
-      munge do |value|
-        value.to_s
-      end
+      munge(&:to_s)
 
       def event_name
         :executed_command
@@ -131,32 +129,32 @@ module Puppet
         # value, which causes us to be treated as in_sync?, which means we
         # don't actually execute anything.  I think. --daniel 2011-03-10
         if @resource.check_all_attributes
-          return :notrun
+          :notrun
         else
-          return self.should
+          should
         end
       end
 
       # Actually execute the command.
       def sync
         event = :executed_command
-        tries = self.resource[:tries]
-        try_sleep = self.resource[:try_sleep]
+        tries = resource[:tries]
+        try_sleep = resource[:try_sleep]
 
         begin
           tries.times do |try|
             # Only add debug messages for tries > 1 to reduce log spam.
             debug("Exec try #{try + 1}/#{tries}") if tries > 1
-            @output, @status = provider.run(self.resource[:command])
-            break if self.should.include?(@status.exitstatus.to_s)
+            @output, @status = provider.run(resource[:command])
+            break if should.include?(@status.exitstatus.to_s)
 
             if try_sleep > 0 and tries > 1
               debug("Sleeping for #{try_sleep} seconds between tries")
               sleep try_sleep
             end
           end
-        rescue Timeout::Error
-          self.fail Puppet::Error, _("Command exceeded timeout"), $!
+        rescue Timeout::Error => e
+          self.fail Puppet::Error, _("Command exceeded timeout"), e
         end
 
         log = @resource[:logoutput]
@@ -165,29 +163,29 @@ module Puppet
           when :true
             log = @resource[:loglevel]
           when :on_failure
-            unless self.should.include?(@status.exitstatus.to_s)
-              log = @resource[:loglevel]
-            else
+            if should.include?(@status.exitstatus.to_s)
               log = :false
+            else
+              log = @resource[:loglevel]
             end
           end
           unless log == :false
             if @resource.parameter(:command).sensitive
-              self.send(log, "[output redacted]")
+              send(log, "[output redacted]")
             else
               @output.split(/\n/).each { |line|
-                self.send(log, line)
+                send(log, line)
               }
             end
           end
         end
 
-        unless self.should.include?(@status.exitstatus.to_s)
+        unless should.include?(@status.exitstatus.to_s)
           if @resource.parameter(:command).sensitive
             # Don't print sensitive commands in the clear
-            self.fail(_("[command redacted] returned %{status} instead of one of [%{expected}]") % { status: @status.exitstatus, expected: self.should.join(",") })
+            self.fail(_("[command redacted] returned %{status} instead of one of [%{expected}]") % { status: @status.exitstatus, expected: should.join(",") })
           else
-            self.fail(_("'%{cmd}' returned %{status} instead of one of [%{expected}]") % { cmd: self.resource[:command], status: @status.exitstatus, expected: self.should.join(",") })
+            self.fail(_("'%{cmd}' returned %{status} instead of one of [%{expected}]") % { cmd: resource[:command], status: @status.exitstatus, expected: should.join(",") })
           end
         end
 
@@ -336,8 +334,8 @@ module Puppet
         value = value.shift if value.is_a?(Array)
         begin
           value = Float(value)
-        rescue ArgumentError
-          raise ArgumentError, _("The timeout must be a number."), $!.backtrace
+        rescue ArgumentError => e
+          raise ArgumentError, _("The timeout must be a number."), e.backtrace
         end
         [value, 0.0].max
       end
@@ -353,7 +351,7 @@ module Puppet
 
       munge do |value|
         if value.is_a?(String)
-          unless value =~ /^[\d]+$/
+          unless value =~ /^\d+$/
             raise ArgumentError, _("Tries must be an integer")
           end
 
@@ -438,6 +436,14 @@ module Puppet
         back by re-extracting the tarball. If `important.tar` does **not**
         actually contain `myfile`, the exec will keep running every time
         Puppet runs.
+
+        This parameter can also take an array of files and the command will
+        not run if **any** of these files exist. For example:
+
+            creates => ['/tmp/file1', '/tmp/file2'],
+
+        will only run the command if both files don't exist.
+
       EOT
 
       accept_arrays
@@ -503,10 +509,10 @@ module Puppet
         end
 
         if sensitive
-          self.debug("[output redacted]")
+          debug("[output redacted]")
         else
           output.split(/\n/).each { |line|
-            self.debug(line)
+            debug(line)
           }
         end
 
@@ -566,10 +572,10 @@ module Puppet
         end
 
         if sensitive
-          self.debug("[output redacted]")
+          debug("[output redacted]")
         else
           output.split(/\n/).each { |line|
-            self.debug(line)
+            debug(line)
           }
         end
 
@@ -596,7 +602,7 @@ module Puppet
       cmd = cmd[0] if cmd.is_a? Array
 
       if cmd.is_a?(Puppet::Pops::Evaluator::DeferredValue)
-        self.debug("The 'command' parameter is deferred and cannot be autorequired")
+        debug("The 'command' parameter is deferred and cannot be autorequired")
       else
         cmd.scan(file_regex) { |str|
           reqs << str
@@ -621,7 +627,7 @@ module Puppet
           # to do.
           line = line[0] if line.is_a? Array
           if line.is_a?(Puppet::Pops::Evaluator::DeferredValue)
-            self.debug("The '#{param}' parameter is deferred and cannot be autorequired")
+            debug("The '#{param}' parameter is deferred and cannot be autorequired")
           else
             reqs += line.scan(file_regex)
           end
@@ -653,20 +659,20 @@ module Puppet
       self.class.checks.each { |check|
         next if refreshing and check == :refreshonly
 
-        if @parameters.include?(check)
-          val = @parameters[check].value
-          val = [val] unless val.is_a? Array
-          val.each do |value|
-            if !@parameters[check].check(value)
-              # Give a debug message so users can figure out what command would have been
-              # but don't print sensitive commands or parameters in the clear
-              cmdstring = @parameters[:command].sensitive ? "[command redacted]" : @parameters[:command].value
+        next unless @parameters.include?(check)
 
-              debug(_("'%{cmd}' won't be executed because of failed check '%{check}'") % { cmd: cmdstring, check: check })
+        val = @parameters[check].value
+        val = [val] unless val.is_a? Array
+        val.each do |value|
+          next if @parameters[check].check(value)
 
-              return false
-            end
-          end
+          # Give a debug message so users can figure out what command would have been
+          # but don't print sensitive commands or parameters in the clear
+          cmdstring = @parameters[:command].sensitive ? "[command redacted]" : @parameters[:command].value
+
+          debug(_("'%{cmd}' won't be executed because of failed check '%{check}'") % { cmd: cmdstring, check: check })
+
+          return false
         end
       }
 
@@ -674,21 +680,21 @@ module Puppet
     end
 
     def output
-      if self.property(:returns).nil?
-        return nil
+      if property(:returns).nil?
+        nil
       else
-        return self.property(:returns).output
+        property(:returns).output
       end
     end
 
     # Run the command, or optionally run a separately-specified command.
     def refresh
-      if self.check_all_attributes(true)
+      if check_all_attributes(true)
         cmd = self[:refresh]
         if cmd
           provider.run(cmd)
         else
-          self.property(:returns).sync
+          property(:returns).sync
         end
       end
     end

data/lib/puppet/type/file/checksum_value.rb

@@ -26,7 +26,7 @@ module Puppet
     def property_matches?(current, desired)
       return true if super(current, desired)
 
-      return date_matches?(resource.parameter(:checksum).value, current, desired)
+      date_matches?(resource.parameter(:checksum).value, current, desired)
     end
 
     def retrieve

data/lib/puppet/type/file/content.rb

@@ -5,7 +5,7 @@ require 'uri'
 require 'tempfile'
 
 require_relative '../../../puppet/util/checksums'
-require_relative '../../../puppet/type/file/data_sync.rb'
+require_relative '../../../puppet/type/file/data_sync'
 
 module Puppet
   Puppet::Type.type(:file).newproperty(:content) do
@@ -79,11 +79,11 @@ module Puppet
         newvalue = tmp
       end
       if currentvalue == :absent
-        return "defined content as '#{newvalue}'"
+        "defined content as '#{newvalue}'"
       elsif newvalue == :absent
-        return "undefined content from '#{currentvalue}'"
+        "undefined content from '#{currentvalue}'"
       else
-        return "content changed '#{currentvalue}' to '#{newvalue}'"
+        "content changed '#{currentvalue}' to '#{newvalue}'"
       end
     end
 
@@ -92,7 +92,7 @@ module Puppet
     end
 
     def content
-      self.should
+      should
     end
 
     # Override this method to provide diffs if asked for.
@@ -119,7 +119,7 @@ module Puppet
       # The inherited equality is always accepted, so use it if valid.
       return true if super(current, desired)
 
-      return date_matches?(checksum_type, current, desired)
+      date_matches?(checksum_type, current, desired)
     end
 
     def retrieve

data/lib/puppet/type/file/ctime.rb

@@ -2,9 +2,9 @@
 
 module Puppet
   Puppet::Type.type(:file).newproperty(:ctime) do
-    desc %q{A read-only state to check the file ctime. On most modern \*nix-like
+    desc %q(A read-only state to check the file ctime. On most modern \*nix-like
       systems, this is the time of the most recent change to the owner, group,
-      permissions, or content of the file.}
+      permissions, or content of the file.)
 
     def retrieve
       current_value = :absent