right_develop 1.2.2 → 2.0.1

data/lib/right_develop/s3/rake_task.rb

@@ -0,0 +1,168 @@
+#
+# Copyright (c) 2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Once this file is required, the Rake DSL is loaded - don't do this except inside Rake!!
+require 'rake/tasklib'
+
+# Make sure the rest of RightDevelop & S3 is required, since this file can be
+# required directly.
+require 'right_develop'
+require 'right_develop/s3'
+
+# localized
+require 'tmpdir'
+
+module RightDevelop::S3
+
+  class RakeTask < ::Rake::TaskLib
+    DEFAULT_OPTIONS = {
+      :s3_namespace     => :s3
+    }
+
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    attr_accessor :s3_namespace
+
+    def initialize(options = {})
+      # Let client provide options object-style, in our initializer
+      options = DEFAULT_OPTIONS.merge(options)
+      self.s3_namespace = options[:s3_namespace]
+
+      # Let client provide options DSL-style by calling our writers
+      yield(self) if block_given?
+
+      namespace self.s3_namespace do
+
+        desc 'List files in S3 bucket'
+        task :list_files, [:bucket, :subdirectory, :recursive, :filters] do |task, args|
+          raise ::ArgumentError.new(":bucket is required") unless bucket = args[:bucket]
+          list = storage.list_files(
+            bucket,
+            :subdirectory => args[:subdirectory],
+            :recursive    => args[:recursive] != 'false',
+            :filters      => args[:filters])
+          puts "Files in S3 bucket \"#{bucket}/#{args[:subdirectory]}\":"
+          list.sort.each { |path| puts "  #{path}" }
+        end
+
+        desc 'Download files from S3 bucket'
+        task :download_files, [:bucket, :to_dir_path, :subdirectory, :recursive, :filters] do |task, args|
+          raise ::ArgumentError.new(":bucket is required") unless bucket = args[:bucket]
+          raise ::ArgumentError.new(":to_dir_path is required") unless to_dir_path = args[:to_dir_path]
+          count = storage.download_files(
+            bucket,
+            to_dir_path,
+            :subdirectory => args[:subdirectory],
+            :recursive    => args[:recursive] != 'false',
+            :filters      => args[:filters])
+          puts "Downloaded #{count} file(s)."
+        end
+
+        desc 'Upload files to S3 bucket'
+        task :upload_files, [:bucket, :from_dir_path, :subdirectory, :recursive, :access, :filters] do |task, args|
+          raise ::ArgumentError.new(":bucket is required") unless bucket = args[:bucket]
+          raise ::ArgumentError.new(":from_dir_path is required") unless from_dir_path = args[:from_dir_path]
+          count = storage.upload_files(
+            bucket,
+            from_dir_path,
+            :subdirectory => args[:subdirectory],
+            :recursive => args[:recursive] != 'false',
+            :access => args[:access],
+            :filters => args[:filters])
+          puts "Uploaded #{count} file(s)."
+        end
+
+        desc 'Copy files between S3 buckets'
+        task :copy_files, [:from_bucket, :from_subdirectory, :to_bucket, :to_subdirectory, :recursive, :access, :filters] do |task, args|
+          raise ::ArgumentError.new(":from_bucket is required") unless from_bucket = args[:from_bucket]
+          raise ::ArgumentError.new(":to_bucket is required") unless to_bucket = args[:to_bucket]
+          verbose = ::Rake.application.options.trace
+          recursive = args[:recursive] != 'false'
+
+          # establish from/to credentials before copying.
+          from_storage = Interface.new(
+            :aws_access_key_id     => ENV['FROM_AWS_ACCESS_KEY_ID'],
+            :aws_secret_access_key => ENV['FROM_AWS_SECRET_ACCESS_KEY'],
+            :logger                => logger)
+          to_storage = Interface.new(
+            :aws_access_key_id     => ENV['TO_AWS_ACCESS_KEY_ID'],
+            :aws_secret_access_key => ENV['TO_AWS_SECRET_ACCESS_KEY'],
+            :logger                => logger)
+
+          # download
+          ::Dir.mktmpdir do |temp_dir|
+            ::Dir.chdir(temp_dir) do
+              download_count = from_storage.download_files(
+                from_bucket,
+                temp_dir,
+                :subdirectory => args[:from_subdirectory],
+                :recursive    => recursive,
+                :filters      => args[:filters])
+
+              upload_count = to_storage.upload_files(
+                to_bucket,
+                temp_dir,
+                :subdirectory => args[:to_subdirectory],
+                :recursive    => recursive,
+                :access       => args[:access],
+                :filters      => nil)  # already filtered during download
+
+              if upload_count == download_count
+                puts "Copied #{upload_count} file(s)."
+              else
+                fail "Failed to upload all downloaded files (#{upload_count} uploaded != #{download_count} downloaded)."
+              end
+            end
+          end
+        end
+
+        desc 'Delete files from S3 bucket'
+        task :delete_files, [:bucket, :subdirectory, :recursive, :filters] do |task, args|
+          raise ::ArgumentError.new(":bucket is required") unless bucket = args[:bucket]
+          count = storage.delete_files(
+            bucket,
+            :subdirectory => args[:subdirectory],
+            :recursive    => args[:recursive] != 'false',
+            :filters      => args[:filters])
+          puts "Deleted #{count} file(s)."
+        end
+
+      end # namespace
+    end # initialize
+
+    def logger
+      unless @logger
+        verbose = Rake.application.options.trace
+        @logger = verbose ? Logger.new(STDOUT) : RightDevelop::Utility::Shell.null_logger
+      end
+      @logger
+    end
+
+    def storage
+      @storage ||= Interface.new(
+        :aws_access_key_id     => ENV['AWS_ACCESS_KEY_ID'],
+        :aws_secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'],
+        :logger                => logger)
+    end
+
+  end # RakeTask
+end # RightDevelop::Buckets

data/lib/right_develop/s3.rb

@@ -0,0 +1,31 @@
+#
+# Copyright (c) 2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightDevelop
+  module S3
+    # Defer loading the Rake task; it mixes the Rake DSL into everything!
+    # Only the Rakefiles themselves should refer to this constant.
+    autoload :RakeTask, 'right_develop/s3/rake_task'
+  end
+end
+
+require 'right_develop/s3/interface'

data/lib/right_develop/utility/git.rb

@@ -0,0 +1,364 @@
+#
+# Copyright (c) 2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# ancestor
+require 'right_develop/utility'
+require 'right_git'
+
+module RightDevelop::Utility::Git
+
+  DEFAULT_REPO_OPTIONS = {
+    :logger => ::RightDevelop::Utility::Shell.default_logger,
+    :shell  => ::RightDevelop::Utility::Shell
+  }.freeze
+
+  class VerifyError < StandardError; end
+
+  module_function
+
+  # Factory method for a default repository object from the current working
+  # directory. The working directory can change but the repo directory is
+  # preserved by the object.
+  #
+  # @return [RightGit::Git::Repository] new repository
+  def default_repository
+    ::RightGit::Git::Repository.new('.', DEFAULT_REPO_OPTIONS)
+  end
+
+  # Performs setup of the working directory repository for automation or
+  # development. Currently this only involves initializing/updating submodules.
+  #
+  # @return [TrueClass] always true
+  def setup
+    default_repository.update_submodules(:recursive => true)
+    true
+  end
+
+  # @return [TrueClass|FalseClass] true if the given revision is a commit SHA
+  def is_sha?(revision)
+    ::RightGit::Git::Commit.sha?(revision)
+  end
+
+  # Determine if the branch given by name exists.
+  #
+  # @param [String] branch_name to query
+  # @param [Hash] options for query
+  # @option options [TrueClass|FalseClass] :remote to find remote branches
+  # @option options [TrueClass|FalseClass] :local to find local branches
+  # @option options [RightGit::Git::Repository] :repo to use or nil
+  #
+  # @return [TrueClass|FalseClass] true if branch exists
+  def branch_exists?(branch_name, options = {})
+    options = {
+      :remote => true,
+      :local  => true,
+      :repo   => nil
+    }.merge(options)
+    remote = options[:remote]
+    local = options[:local]
+    repo = options[:repo] || default_repository
+    unless local || remote
+      raise ::ArgumentError, 'Either remote or local must be true'
+    end
+    both = local && remote
+    repo.branches(:all => remote).any? do |branch|
+      branch.name == branch_name && (both || remote == branch.remote?)
+    end
+  end
+
+  # Determine if the tag given by name exists.
+  #
+  # @param [String] tag_name to query
+  # @param [Hash] options for query
+  # @option options [RightGit::Git::Repository] :repo to use or nil
+  #
+  # @return [TrueClass|FalseClass] true if tag exists
+  def tag_exists?(tag_name, options = {})
+    options = {
+      :repo => nil
+    }.merge(options)
+    repo = options[:repo] || default_repository
+
+    # note that remote tags cannot be queried directly; use git fetch --tags to
+    # import them first.
+    repo.tags.any? { |tag| tag.name == tag_name }
+  end
+
+  # Clones the repo given by URL to the given destination (if any).
+  #
+  # @param [String] repo URL to clone
+  # @param [String] destination path where repo is cloned
+  #
+  # @return [TrueClass] always true
+  def clone_to(repo, destination)
+    ::RightGit::Git::Repository.clone_to(repo, destination, DEFAULT_REPO_OPTIONS)
+    true
+  end
+
+  # Generates a difference from the current workspace to the given commit on the
+  # same branch as a sorted list of relative file paths. This is useful for
+  # creating a list of files to patch, etc.
+  #
+  # @param [String] commit to diff from (e.g. 'master')
+  # @return [String] list of relative file paths from diff or empty
+  def diff_files_from(commit)
+    git_args = ['diff', '--stat', '--name-only', commit]
+    result = default_repository.git_output(git_args).lines.map { |line| line.strip }.sort
+    # not sure if git would ever mention directories in a diff, but ignore them.
+    result.delete_if { |item| ::File.directory?(item) }
+    return result
+  end
+
+  # Checks out the given revision (tag, branch or SHA) and optionally creates a
+  # new branch from it.
+  #
+  # @param [String] revision to checkout
+  # @param [Hash] options for checkout
+  # @option options [TrueClass|FalseClass] :force to perform hard reset and force checkout
+  # @option options [String] :new_branch_name to create after checkout or nil
+  # @option options [TrueClass|FalseClass] :recursive to perform a recursive checkout to same branch or tag (but not for SHA)
+  #
+  # @return [TrueClass] always true
+  def checkout_revision(revision, options = {})
+    options = {
+      :new_branch_name => nil,
+      :force           => true,
+      :recursive       => true
+    }.merge(options)
+
+    # check parameters.
+    new_branch_name = options[:new_branch_name]
+    if new_branch_name && new_branch_name == revision
+      raise ::ArgumentError, "revision cannot be same as new_branch_name: #{revision}"
+    end
+    unless [TrueClass, FalseClass, NilClass].include?(options[:force].class)
+      raise ::ArgumentError, "force must be a boolean"
+    end
+    force = !!options[:force]
+
+    # hard reset any local changes before attempting checkout, if forced.
+    repo = default_repository
+    logger = repo.logger
+    logger.info("Performing checkout in #{repo.repo_dir.inspect}")
+    repo.hard_reset_to(nil) if force
+
+    # fetch to ensure revision is known and most up-to-date.
+    repo.fetch_all
+
+    # do full checkout of revision with submodule update before any attempt to
+    # create a new branch. this handles some wierd git failures where submodules
+    # are changing between major/minor versions of the code.
+    repo.checkout_to(revision, :force => true)
+
+    # note that the checkout-to-a-branch will simply switch to a local copy of
+    # the branch which may or may not by synchronized with its remote origin. to
+    # ensure the branch is synchronized, perform a pull.
+    is_sha = is_sha?(revision)
+    needs_pull = (
+      !is_sha &&
+      branch_exists?(revision, :remote => true, :local => false, :repo => repo)
+    )
+    if needs_pull
+      # hard reset to remote origin to overcome any local branch divergence.
+      repo.hard_reset_to("origin/#{revision}") if force
+
+      # a pull is not needed at this point if we forced hard reset but it is
+      # always nice to see it succeed in the output.
+      repo.spit_output('pull', 'origin', revision)
+    end
+
+    # perform a localized hard reset to revision just to prove that revision is
+    # now known to the local git database.
+    repo.hard_reset_to(revision)
+
+    # note that the submodule update is non-recursive for tags and branches in
+    # case the submodule needs to checkout to a specific branch before updating
+    # its own submodules. it would be strange to recursively update submodules
+    # from the parent and then have the recursively checked-out child revision
+    # (branch or tag) introduce a different set of submodules.
+    repo.update_submodules(:recursive => is_sha && options[:recursive])
+
+    # recursively checkout submodules, if requested and unless we determine the
+    # revision is a SHA (in which case recursive+SHA is ignored).
+    if !is_sha && options[:recursive]
+      repo.submodule_paths(:recursive => false).each do |submodule_path|
+        # note that recursion will use the current directory and create a new
+        # repo by calling default_repository.
+        ::Dir.chdir(submodule_path) do
+          checkout_revision(revision, options)
+        end
+      end
+    end
+
+    # create a new branch from fully resolved directory, if requested.
+    repo.spit_output('checkout', '-b', new_branch_name) if new_branch_name
+    true
+  end
+
+  # Verifies that the local repository and all submodules match the expected
+  # revision (branch, tag or SHA).
+  #
+  # @param [String] revision to check or nil to use base directory revision
+  #
+  # @return [TrueClass] always true
+  #
+  # @raise [VerifyError] on failure
+  def verify_revision(revision = nil)
+    repo = default_repository
+    logger = repo.logger
+    if revision
+      # check current directory against revision.
+      actual_revision = current_revision(revision, :repo => repo)
+      if revision != actual_revision
+        message =
+          'Base directory is in an inconsistent state' +
+          " (#{revision} != #{actual_revision}): #{repo.repo_dir.inspect}"
+        raise VerifyError, message
+      end
+    else
+      # determine revision to check from local HEAD state if not given. at best
+      # this will be a branch or tag, at worst a SHA.
+      logger.info("Resolving the default branch, tag or SHA to use for verification in #{repo.repo_dir.inspect}")
+      revision = current_revision(nil, :repo => repo)
+    end
+
+    # start verify.
+    logger.info("Verifying consistency of revision=#{revision} in #{repo.repo_dir.inspect}")
+    if is_sha?(revision)
+      revision_type = :sha
+    elsif branch_exists?(revision, :remote => false, :local => true, :repo => repo)
+      revision_type = :branch
+    else
+      revision_type = :tag
+    end
+
+    # for SHAs and tags, verify that expected submodule commits are checked-out
+    # by looking for +,- in the submodule status. any that are out of sync will
+    # not have a blank space on the left-hand side.
+    if revision_type != :branch
+      repo.git_output('submodule status --recursive').lines.each do |line|
+        data = line.chomp
+        if matched = ::RightGit::Git::Repository::SUBMODULE_STATUS_REGEX.match(data)
+          if matched[1] != ' '
+            message =
+              'At least one submodule is in an inconsistent state:' +
+              " #{::File.expand_path(matched[3])}"
+            raise VerifyError, message
+          end
+        else
+          raise VerifyError,
+                "Unexpected output from submodule status: #{data.inspect}"
+        end
+      end
+    end
+
+    # branches are not required to have up-to-date submodule commits for ad-hoc
+    # building purposes but all submodules should be checked-out to the same
+    # branch (and that branch must exist for all submodules).
+    #
+    # for the tag case (i.e. release candidate), we peform a double-check
+    # inside each submodule to verify that what the submodule thinks is tagged
+    # is the same as the submodule SHA from the parent. the same tag must exist
+    # and must be consistent for all submodules.
+    if revision_type != :sha
+      repo.submodule_paths(:recursive => true).each do |submodule_path|
+        sub_repo = ::RightGit::Git::Repository.new(submodule_path, DEFAULT_REPO_OPTIONS)
+        logger.info("Inspecting #{sub_repo.repo_dir.inspect}")
+        actual_revision = current_revision(revision, :repo => sub_repo)
+        if revision != actual_revision
+          message =
+            'At least one submodule is in an inconsistent state' +
+            " (#{revision} != #{actual_revision}): #{sub_repo.repo_dir.inspect}"
+          raise VerifyError, message
+        end
+      end
+    end
+    true
+  end
+
+  # Attempts to determine which branch, tag or SHA to which the current
+  # directory is pointing. A directory can be pointing at both a branch and
+  # multiple tags at the same time it so uses the hint to pick one or the other,
+  # if given. if all else fails, the current SHA is returned.
+  #
+  # note that current revision is localized and so not directly related to the
+  # current state of remote branches or tags. do a fetch to ensure those.
+  #
+  # @param [String] hint for branch vs. tag or nil
+  # @param [Hash] options for query
+  # @option options [RightGit::Git::Repository] :repo to use or nil
+  #
+  # @return [String] current revision
+  def current_revision(hint = nil, options = {})
+    options = {
+      :repo => nil
+    }.merge(options)
+    repo = options[:repo] || default_repository
+
+    # SHA logic
+    actual_sha = repo.sha_for(nil)
+    return actual_sha if is_sha?(hint)
+
+    # branch logic
+    branch_hint = (
+      hint.nil? ||
+      branch_exists?(hint, :remote => true, :local => true, :repo => repo)
+    )
+    if branch_hint
+      branch = repo.git_output('rev-parse --abbrev-ref HEAD').strip
+      return branch if branch != 'HEAD'
+    end
+
+    # tag logic
+    if hint && tag_exists?(hint, :repo => repo)
+      hint_sha = repo.sha_for(hint)
+      return hint if hint_sha == actual_sha
+    end
+
+    # lookup tags for actual SHA, if any.
+    if first_tag = tags_for_sha(actual_sha, :repo => repo).first
+      return first_tag
+    end
+
+    # detached HEAD state, no matching branches or tags.
+    actual_sha
+  end
+
+  # Generates a list of tags pointing to the given SHA, if any.
+  # When the revision is a tag, only one tag is returned regardless of
+  # whether other tags reference the same SHA.
+  #
+  # @param [String] sha for tags
+  # @param [Hash] options for query
+  # @option options [RightGit::Git::Repository] :repo to use or nil
+  #
+  # @return [Array] tags for the revision or empty
+  def tags_for_sha(sha, options = {})
+    options = {
+      :repo => nil
+    }.merge(options)
+    repo = options[:repo] || default_repository
+    git_args = ['tag', '--contains', sha]
+    repo.git_output(git_args).lines.map { |line| line.strip }
+  end
+
+end # RightDevelop::Utility::Git

data/lib/right_develop/utility/shell.rb

@@ -0,0 +1,131 @@
+#
+# Copyright (c) 2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# ancestor
+require 'right_develop/utility'
+
+require 'right_git'
+require 'right_support'
+
+module RightDevelop
+  module Utility
+
+    # extends default shell easy-singleton from right_git gem.
+    class Shell < ::RightGit::Shell::Default
+
+      class NullLoggerSingleton
+        @@logger = nil
+
+        def self.instance
+          @@logger ||= ::RightSupport::Log::NullLogger.new
+        end
+      end
+
+      # bundle exec sets GEM_HOME and GEM_PATH (in Windows?) and these need to
+      # be wacked in order to have a pristing rubygems environment since bundler
+      # won't clean them. also, if you 'bundle exec rake ...' and then put
+      # arguments to the right of the task name, then these args won't appear in
+      # Bundler::ORIGINAL_ENV.
+      # example: "bundle exec rake build:all DEBUG=true ..."
+      def setup_clean_env
+        # a little revisionist history music...
+        ::ENV.each do |key, value|
+          if key.start_with?('GEM_') || key.start_with?('BUNDLER_')
+            ::Bundler::ORIGINAL_ENV[key] = nil
+          elsif Bundler::ORIGINAL_ENV[key].nil?
+            ::Bundler::ORIGINAL_ENV[key] = value
+          end
+        end
+        ::Bundler.with_clean_env do
+          # now the ENV is clean and not missing any right-hand args so replace
+          # the ORIGINAL_ENV.
+          ::Bundler::ORIGINAL_ENV.replace(ENV)
+        end
+        true
+      end
+
+      # @return [TrueClass|FalseClass] true if running on Windows platform
+      def is_windows?
+        return !!(RUBY_PLATFORM =~ /mswin|win32|dos|mingw|cygwin/)
+      end
+
+      # Creates a null logger.
+      #
+      # @return [Logger] the null logger
+      def null_logger
+        NullLoggerSingleton.instance
+      end
+
+      # @return [Logger] default logger for STDOUT
+      def default_logger
+        @default_logger ||= ::Logger.new(STDOUT)
+      end
+
+      # Overrides ::RightGit::Shell::Default#execute
+      #
+      # @param [String] cmd the shell command to run
+      # @param [Hash] options for execution
+      # @option options :directory [String] to use as working directory during command execution or nil
+      # @option options :logger [Logger] logger for shell execution (default = STDOUT)
+      # @option options :outstream [IO] output stream to receive STDOUT and STDERR from command (default = none)
+      # @option options :raise_on_failure [TrueClass|FalseClass] if true, wil raise a RuntimeError if the command does not end successfully (default), false to ignore errors
+      # @option options :set_env_vars [Hash] environment variables to set during execution (default = none set)
+      # @option options :clear_env_vars [Hash] environment variables to clear during execution (default = none cleared but see :clean_bundler_env)
+      # @option options :clean_bundler_env [TrueClass|FalseClass] true to clear all bundler environment variables during execution (default), false to inherit bundler env from parent
+      # @option options :sudo [TrueClass|FalseClass] if true, will wrap command in sudo if needed, false to run as current user (default)
+      #
+      # @return [Integer] exitstatus of the command
+      #
+      # @raise [ShellError] on failure only if :raise_on_failure is true
+      def execute(cmd, options = {})
+        options = {
+          :clean_bundler_env => true,
+          :sudo              => false
+        }.merge(options)
+
+        if options[:sudo]
+          fail "Not available in Windows" if is_windows?
+          cmd = "sudo #{cmd}" unless ::Process.euid == 0
+        end
+
+        # super execute.
+        super(cmd, options)
+      end
+
+      # Overrides ::RightGit::Shell::Default#configure_executioner
+      def configure_executioner(executioner, options)
+        # super configure early to ensure that any custom env vars are set after
+        # restoring the pre-bundler env.
+        executioner = super(executioner, options)
+
+        # clean all bundler env vars, if requested.
+        if options[:clean_bundler_env]
+          executioner = lambda do |e|
+            lambda { ::Bundler.with_clean_env { e.call } }
+          end.call(executioner)
+        end
+        executioner
+      end
+
+    end # Shell
+  end # Utility
+end # RightDevelop