chef 12.6.0 → 12.7.2

data/lib/chef/resource/csh.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,14 +16,14 @@
 # limitations under the License.
 #
 
-require 'chef/resource/script'
-require 'chef/provider/script'
+require "chef/resource/script"
+require "chef/provider/script"
 
 class Chef
   class Resource
     class Csh < Chef::Resource::Script
 
-      def initialize(name, run_context=nil)
+      def initialize(name, run_context = nil)
         super
         @interpreter = "csh"
       end

data/lib/chef/resource/deploy.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Author:: Tyler Cloke (<tyler@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Tyler Cloke (<tyler@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -59,17 +59,17 @@ class Chef
       default_action :deploy
       allowed_actions :force_deploy, :deploy, :rollback
 
-      def initialize(name, run_context=nil)
+      def initialize(name, run_context = nil)
         super
         @deploy_to = name
         @environment = nil
-        @repository_cache = 'cached-copy'
+        @repository_cache = "cached-copy"
         @copy_exclude = []
         @purge_before_symlink = %w{log tmp/pids public/system}
         @create_dirs_before_symlink = %w{tmp public config}
-        @symlink_before_migrate = {"config/database.yml" => "config/database.yml"}
-        @symlinks = {"system" => "public/system", "pids" => "tmp/pids", "log" => "log"}
-        @revision = 'HEAD'
+        @symlink_before_migrate = { "config/database.yml" => "config/database.yml" }
+        @symlinks = { "system" => "public/system", "pids" => "tmp/pids", "log" => "log" }
+        @revision = "HEAD"
         @migrate = false
         @rollback_on_error = false
         @remote = "origin"
@@ -99,180 +99,180 @@ class Chef
         @current_path ||= @deploy_to + "/current"
       end
 
-      def depth(arg=@shallow_clone ? 5 : nil)
+      def depth(arg = @shallow_clone ? 5 : nil)
         set_or_return(
           :depth,
           arg,
-          :kind_of => [ Integer ]
+          :kind_of => [ Integer ],
         )
       end
 
       # note: deploy_to is your application "meta-root."
-      def deploy_to(arg=nil)
+      def deploy_to(arg = nil)
         set_or_return(
           :deploy_to,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def repo(arg=nil)
+      def repo(arg = nil)
         set_or_return(
           :repo,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
       alias :repository :repo
 
-      def remote(arg=nil)
+      def remote(arg = nil)
         set_or_return(
           :remote,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def role(arg=nil)
+      def role(arg = nil)
         set_or_return(
           :role,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def restart_command(arg=nil, &block)
+      def restart_command(arg = nil, &block)
         arg ||= block
         set_or_return(
           :restart_command,
           arg,
-          :kind_of => [ String, Proc ]
+          :kind_of => [ String, Proc ],
         )
       end
       alias :restart :restart_command
 
-      def migrate(arg=nil)
+      def migrate(arg = nil)
         set_or_return(
           :migrate,
           arg,
-          :kind_of => [ TrueClass, FalseClass ]
+          :kind_of => [ TrueClass, FalseClass ],
         )
       end
 
-      def migration_command(arg=nil)
+      def migration_command(arg = nil)
         set_or_return(
           :migration_command,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def rollback_on_error(arg=nil)
+      def rollback_on_error(arg = nil)
         set_or_return(
           :rollback_on_error,
           arg,
-          :kind_of => [ TrueClass, FalseClass ]
+          :kind_of => [ TrueClass, FalseClass ],
         )
       end
 
-      def user(arg=nil)
+      def user(arg = nil)
         set_or_return(
           :user,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def group(arg=nil)
+      def group(arg = nil)
         set_or_return(
           :group,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def enable_submodules(arg=nil)
+      def enable_submodules(arg = nil)
         set_or_return(
           :enable_submodules,
           arg,
-          :kind_of => [ TrueClass, FalseClass ]
+          :kind_of => [ TrueClass, FalseClass ],
         )
       end
 
-      def shallow_clone(arg=nil)
+      def shallow_clone(arg = nil)
         set_or_return(
           :shallow_clone,
           arg,
-          :kind_of => [ TrueClass, FalseClass ]
+          :kind_of => [ TrueClass, FalseClass ],
         )
       end
 
-      def repository_cache(arg=nil)
+      def repository_cache(arg = nil)
         set_or_return(
           :repository_cache,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def copy_exclude(arg=nil)
+      def copy_exclude(arg = nil)
         set_or_return(
           :copy_exclude,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def revision(arg=nil)
+      def revision(arg = nil)
         set_or_return(
           :revision,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
       alias :branch :revision
 
-      def git_ssh_wrapper(arg=nil)
+      def git_ssh_wrapper(arg = nil)
         set_or_return(
           :git_ssh_wrapper,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
       alias :ssh_wrapper :git_ssh_wrapper
 
-      def svn_username(arg=nil)
+      def svn_username(arg = nil)
         set_or_return(
           :svn_username,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def svn_password(arg=nil)
+      def svn_password(arg = nil)
         set_or_return(
           :svn_password,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def svn_arguments(arg=nil)
+      def svn_arguments(arg = nil)
         set_or_return(
           :svn_arguments,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String ],
         )
       end
 
-      def svn_info_args(arg=nil)
+      def svn_info_args(arg = nil)
         set_or_return(
           :svn_arguments,
           arg,
           :kind_of => [ String ])
       end
 
-      def scm_provider(arg=nil)
+      def scm_provider(arg = nil)
         klass = if arg.kind_of?(String) || arg.kind_of?(Symbol)
                   lookup_provider_constant(arg)
                 else
@@ -281,7 +281,7 @@ class Chef
         set_or_return(
           :scm_provider,
           klass,
-          :kind_of => [ Class ]
+          :kind_of => [ Class ],
         )
       end
 
@@ -291,29 +291,29 @@ class Chef
         Chef::Provider::Deploy
       end
 
-      def svn_force_export(arg=nil)
+      def svn_force_export(arg = nil)
         set_or_return(
           :svn_force_export,
           arg,
-          :kind_of => [ TrueClass, FalseClass ]
+          :kind_of => [ TrueClass, FalseClass ],
         )
       end
 
-      def environment(arg=nil)
+      def environment(arg = nil)
         if arg.is_a?(String)
           Chef::Log.debug "Setting RAILS_ENV, RACK_ENV, and MERB_ENV to `#{arg}'"
           Chef::Log.warn "[DEPRECATED] please modify your deploy recipe or attributes to set the environment using a hash"
-          arg = {"RAILS_ENV"=>arg,"MERB_ENV"=>arg,"RACK_ENV"=>arg}
+          arg = { "RAILS_ENV" => arg, "MERB_ENV" => arg, "RACK_ENV" => arg }
         end
         set_or_return(
           :environment,
           arg,
-          :kind_of => [ Hash ]
+          :kind_of => [ Hash ],
         )
       end
 
        # The number of old release directories to keep around after cleanup
-      def keep_releases(arg=nil)
+      def keep_releases(arg = nil)
         [set_or_return(
           :keep_releases,
           arg,
@@ -324,11 +324,11 @@ class Chef
       # SCM clone/checkout before symlinking. Use this to get rid of files and
       # directories you want to be shared between releases.
       # Default: ["log", "tmp/pids", "public/system"]
-      def purge_before_symlink(arg=nil)
+      def purge_before_symlink(arg = nil)
         set_or_return(
           :purge_before_symlink,
           arg,
-          :kind_of => Array
+          :kind_of => Array,
         )
       end
 
@@ -340,11 +340,11 @@ class Chef
       # then specify tmp here so that the tmp directory will exist when you
       # symlink the pids directory in to the current release.
       # Default: ["tmp", "public", "config"]
-      def create_dirs_before_symlink(arg=nil)
+      def create_dirs_before_symlink(arg = nil)
         set_or_return(
           :create_dirs_before_symlink,
           arg,
-          :kind_of => Array
+          :kind_of => Array,
         )
       end
 
@@ -354,11 +354,11 @@ class Chef
       # $shared/pids that you would like to symlink as $current_release/tmp/pids
       # you specify it as "pids" => "tmp/pids"
       # Default {"system" => "public/system", "pids" => "tmp/pids", "log" => "log"}
-      def symlinks(arg=nil)
+      def symlinks(arg = nil)
         set_or_return(
           :symlinks,
           arg,
-          :kind_of => Hash
+          :kind_of => Hash,
         )
       end
 
@@ -369,59 +369,59 @@ class Chef
       # For a rails/merb app, this is used to link in a known good database.yml
       # (with the production db password) before running migrate.
       # Default {"config/database.yml" => "config/database.yml"}
-      def symlink_before_migrate(arg=nil)
+      def symlink_before_migrate(arg = nil)
         set_or_return(
           :symlink_before_migrate,
           arg,
-          :kind_of => Hash
+          :kind_of => Hash,
         )
       end
 
       # Callback fires before migration is run.
-      def before_migrate(arg=nil, &block)
+      def before_migrate(arg = nil, &block)
         arg ||= block
         set_or_return(:before_migrate, arg, :kind_of => [Proc, String])
       end
 
       # Callback fires before symlinking
-      def before_symlink(arg=nil, &block)
+      def before_symlink(arg = nil, &block)
         arg ||= block
         set_or_return(:before_symlink, arg, :kind_of => [Proc, String])
       end
 
       # Callback fires before restart
-      def before_restart(arg=nil, &block)
+      def before_restart(arg = nil, &block)
         arg ||= block
         set_or_return(:before_restart, arg, :kind_of => [Proc, String])
       end
 
       # Callback fires after restart
-      def after_restart(arg=nil, &block)
+      def after_restart(arg = nil, &block)
         arg ||= block
         set_or_return(:after_restart, arg, :kind_of => [Proc, String])
       end
 
-      def additional_remotes(arg=nil)
+      def additional_remotes(arg = nil)
         set_or_return(
           :additional_remotes,
           arg,
-          :kind_of => Hash
+          :kind_of => Hash,
         )
       end
 
-      def enable_checkout(arg=nil)
+      def enable_checkout(arg = nil)
         set_or_return(
           :enable_checkout,
           arg,
-          :kind_of => [TrueClass, FalseClass]
+          :kind_of => [TrueClass, FalseClass],
         )
       end
 
-      def checkout_branch(arg=nil)
+      def checkout_branch(arg = nil)
         set_or_return(
           :checkout_branch,
           arg,
-          :kind_of => String
+          :kind_of => String,
         )
       end
 
@@ -430,11 +430,11 @@ class Chef
       # timeout for SCM operations. The deploy resource must therefore support
       # a timeout method, but the timeout it describes is for SCM operations,
       # not the overall deployment. This is potentially confusing.
-      def timeout(arg=nil)
+      def timeout(arg = nil)
         set_or_return(
           :timeout,
           arg,
-          :kind_of => Integer
+          :kind_of => Integer,
         )
       end
 

data/lib/chef/resource/deploy_revision.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# Copyright:: Copyright 2009-2016, Daniel DeLeo
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");