origen 0.38.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9aa332ea30ff6e2185ef86ef42fb8ed6444b525555bd8509fed4f28a721596f0
-  data.tar.gz: 9aa1c645c4a77f2b9ce18b0b406d7c18fef099f9dca71bfd45dd97361a18116c
+  metadata.gz: e95972bfda37704ac8411834e3428a6e68b01056b90ed2accae530ce7b97900d
+  data.tar.gz: e6e626d864f73a3b07014d8b43bbcae416d97884cb4c09bfff3c1b1fb05bef42
 SHA512:
-  metadata.gz: c9aaf744fbb84e2e6fee05f7f53c148a36a789d7ff6c83ded3129f0762acb5afdd98c6ce872608105c35b129a5283b6027e501b571d8512279629ad026854bd9
-  data.tar.gz: 3d0f7817ed9bf9c5098ac89effbc4cfbab473f6fb6572ee9bf3e39756f1fdf22925ca0a01104272ca6138964ba807804137c60cf31115a9ce915f161b3caee1c
+  metadata.gz: '090322751c0e38385385dcb0f8dbf6cfcf9f424aea3b49a423f3e3585c8a514cd4921811687197de7ca8a6954184ada52d148dc3648c7c451b51df2d27fb8ce1'
+  data.tar.gz: ab8292bb949e3dcd392f04b25ce2ca86ca6e48a0a80dfc7bb9d93599a937c253b506a23b11199cdb22a8eeae324ce26f6e42d59477e93ae752fd3c048b7d1cc5

data/bin/origen

@@ -1,237 +1,2 @@
 #!/usr/bin/env ruby
-$VERBOSE = nil  # Don't care about world writable dir warnings and the like
-
-require 'pathname'
-require 'fileutils'
-#require 'byebug' # Un-comment to debug this file
-
-class OrigenBootError < StandardError
-end
-
-# Keep a note of the pwd at the time when Origen was first loaded, this is initially used
-# by the site_config lookup.
-$_origen_invocation_pwd ||= Pathname.pwd
-
-load File.expand_path('../../lib/origen/operating_systems.rb', __FILE__)
-load File.expand_path('../../lib/origen/site_config.rb', __FILE__)
-
-# This will be referenced later in ruby_version_check, the origen used to launch
-# the process is different than the one that actually runs under bundler
-$origen_launch_root = Pathname.new(File.dirname(__FILE__)).parent
-
-# Override any influence from $LANG in the users environment
-Encoding.default_external = Encoding::UTF_8
-Encoding.default_internal = Encoding::UTF_8
-ENV['LC_ALL'] = nil
-ENV['LANG'] = nil
-ENV['LANG'] = 'en_US.UTF-8'
-
-# Work out what Origen.root is if we are running inside an Origen application, this will be
-# later used to execute from that app's bundle even if the origen executable lives somewhere
-# else (e.g. in the tools repository)
-app_config = File.join('config', 'application.rb')
-if File.exist?(app_config)
-  origen_root = Dir.pwd
-else
-  path = Pathname.new(Dir.pwd)
-  until path.root? || origen_root
-    if File.exist?(File.join(path, app_config))
-      origen_root = path.to_s
-    else
-      path = path.parent
-    end
-  end
-end
-
-# If running inside an application workspace
-if origen_root
-  # Force everyone to have a consistent way of installing gems with bundler
-  ENV['BUNDLE_GEMFILE'] = File.join(origen_root, 'Gemfile')
-  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
-  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')
-
-  # If it looks like a bundled binstub of origen exists, and we have not been invoked through that,
-  # then run that instead.
-  if Origen.site_config.gem_manage_bundler && File.exist?("#{origen_root}/lbin/origen") && !ENV['BUNDLE_BIN_PATH'] &&
-     File.exist?(File.expand_path(Origen.site_config.gem_install_dir))
-    exec Gem.ruby, "#{origen_root}/lbin/origen", *ARGV
-    exit 0
-  end
-  
-  boot_app = true
-
-# If running outside an application and a user or central tool Origen bundle is to be used
-elsif Origen.site_config.gem_manage_bundler && (Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
-  # Force everyone to have a consistent way of installing gems with bundler.
-  # In this case, we aren't running from an Origen application, so build everything at Origen.home instead
-  # Have two options here: if user_install_enable is true, use user_install_dir. Otherwise, use the tool_repo_install_dir
-  Origen.site_config.user_install_enable ? origen_root = File.expand_path(Origen.site_config.user_install_dir) : origen_root = File.expand_path(Origen.site_config.tool_repo_install_dir)
-  unless Dir.exists?(origen_root)
-    load File.expand_path('../../lib/origen/utility/input_capture.rb', __FILE__)
-    include Origen::Utility::InputCapture
-    
-    puts "Root directory '#{origen_root}' does not exist. Would you like to create it?"
-    if get_text(confirm: :return_boolean)
-      FileUtils.mkdir(origen_root)
-    else
-      puts "Exiting with creating Origen install"
-      exit!
-    end
-  end
-  
-  gemfile = File.join(origen_root, 'Gemfile')
-  unless File.exists?(gemfile)
-    # Create a default Gemfile that can be further customized by the user.
-    # Initial Gemfile only requires Origen. Nothing else. Essentially a blank installation.
-    Dir.chdir(origen_root) do
-      `bundle init`
-    end
-    # The above will give a general Gemfile from Bundler. We'll just append "gem 'origen' to the end.
-    File.open(gemfile, 'a') do |f|
-     f << "gem 'origen'\n"
-    end
-  end
-  ENV['BUNDLE_GEMFILE'] = gemfile
-  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
-  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')
-
-  origen_exec = File.join(ENV['BUNDLE_BIN'], 'origen')
-
-  # If the user/tool bundle already exists but we have not been invoked through that, abort this thread
-  # and re-launch under the required bundler environment
-  if File.exist?(origen_exec) && !ENV['BUNDLE_BIN_PATH'] && File.exist?(ENV['BUNDLE_PATH'])
-    exec Gem.ruby, origen_exec, *ARGV
-    exit 0
-  else
-    boot_app = false
-  end
-end
-
-if origen_root && File.exist?(ENV['BUNDLE_GEMFILE']) && Origen.site_config.gem_manage_bundler && (boot_app || Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
-  # Overriding bundler here so that bundle install can be automated as required
-  require 'bundler/shared_helpers'
-  if Bundler::SharedHelpers.in_bundle?
-    require 'bundler'
-    if STDOUT.tty?
-      begin
-        fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
-        Bundler.setup
-        fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
-      rescue Gem::LoadError, Bundler::BundlerError, OrigenBootError => e
-        cmd = "bundle install --gemfile #{ENV['BUNDLE_GEMFILE']} --binstubs #{ENV['BUNDLE_BIN']} --path #{ENV['BUNDLE_PATH']}"
-        # puts cmd
-        puts 'Installing required gems...'
-        puts
-        `chmod o-w #{origen_root}` # Stops some annoying world writable warnings during install
-        `chmod o-w #{origen_root}/bin` if File.exist?("#{origen_root}/bin")
-        `chmod o-w #{origen_root}/.bin` if File.exist?("#{origen_root}/.bin")
-        result = false
-
-        Bundler.with_clean_env do
-          if Origen.os.unix?
-            if Origen.site_config.gem_build_switches
-              Origen.site_config.gem_build_switches.each do |switches|
-                `bundle config build.#{switches}`
-              end
-            end
-          end
-          result = system(cmd)
-        end
-        `chmod o-w #{ENV['BUNDLE_BIN']}`
-        # Make .bat versions of all executables, Bundler should really be doing this when running
-        # on windows
-        if Origen.os.windows?
-          bat_present = File.exist? "#{origen_root}/lbin/origen.bat"
-          Dir.glob("#{origen_root}/lbin/*").each do |bin|
-            unless bin =~ /.bat$/
-              bat = "#{bin}.bat"
-              unless File.exist?(bat)
-                File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
-              end
-            end
-          end
-          if !bat_present && !result
-            puts 'Some Windows specific updates to your workspace were required, please re-run the last command'
-            exit 0
-          end
-        end
-        if result
-          exec "origen #{ARGV.join(' ')}"
-          exit 0
-        else
-          puts
-          puts "If you have just updated a gem version and are now getting an error that Bundler cannot find compatible versions for it then first try running 'bundle update <gemname>'."
-          puts "For example if you have just changed the version of origen_core run 'bundle update origen_core'."
-          exit 1
-        end
-      end
-    else
-      Bundler.setup
-    end
-  end
-  require 'bundler/setup'
-  _exec_remote = ARGV.include?('--exec_remote') ? true : false  
-  if Origen.site_config.use_bootsnap && !Origen.os.windows? && !_exec_remote
-    ENV["BOOTSNAP_CACHE_DIR"] ||= "#{origen_root}/tmp/cache"
-    require 'bootsnap/setup'
-  end
-  require 'origen'
-else
-  $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
-  require 'origen'
-end
-
-begin
-  # If this script has been invoked from within an Origen application then open
-  # up all commands, if not then only allow the command to create a new Origen
-  # application.
-  if origen_root && boot_app
-    require 'origen/commands'
-  else
-    require 'origen/commands_global'
-  end
-rescue Exception => e
-  # A formatted stack dump will not be printed if the application ends via 'exit 0' or 'exit 1'. In that
-  # case the application code is responsible for printing a helpful error message.
-  # This will intercept all other exits, e.g. via 'fail "Something has done wrong"', and split the stack
-  # dump to separate all in-application references from Origen core/plugin references.
-  if e.is_a?(SystemExit)
-    exit e.status
-  else
-    puts
-    if Origen.app_loaded?
-      puts 'COMPLETE CALL STACK'
-      puts '-------------------'
-      puts e.message unless e.is_a?(SystemExit)
-      puts e.backtrace
-
-      puts
-      puts 'APPLICATION CALL STACK'
-      puts '----------------------'
-      puts e.message unless e.is_a?(SystemExit)
-      # Only print out the application stack trace by default, if verbose logging is
-      # enabled then output the full thing
-      e.backtrace.each do |line|
-        path = Pathname.new(line)
-        if path.absolute?
-          if line =~ /^#{Origen.root}/ && line !~ /^#{Origen.root}\/lbin/
-            puts line
-          end
-        else
-          puts line unless line =~ /^.\/lbin/
-        end
-      end
-    else
-      puts 'COMPLETE CALL STACK'
-      puts '-------------------'
-      puts e.message unless e.is_a?(SystemExit)
-      puts e.backtrace
-    end
-    exit 1
-  end
-ensure
-  if Origen.app_loaded?
-    Origen.app.listeners_for(:on_origen_shutdown).each(&:on_origen_shutdown)
-    Origen.app.runner.shutdown
-  end
-end
+load File.expand_path('../../lib/origen/boot.rb', __FILE__)

data/config/application.rb

@@ -38,7 +38,8 @@ class OrigenCoreApplication < Origen::Application
 
   #config.lsf.project = "origen core"
   
-  config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/origen"
+  #config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/origen"
+  config.web_directory = "https://github.com/Origen-SDK/Origen-SDK.github.io.git/origen"
   config.web_domain = "http://origen-sdk.org/origen"
   
   config.pattern_prefix = "nvm"
@@ -119,6 +120,14 @@ class OrigenCoreApplication < Origen::Application
     end
   end
 
+  def before_release_gem
+    Dir.chdir Origen.root do
+      FileUtils.rm_rf('origen_app_generators') if File.exist?('origen_app_generators')
+      FileUtils.cp_r(Origen.app(:origen_app_generators).root, 'origen_app_generators')
+      FileUtils.rm_rf(File.join('origen_app_generators', '.git'))
+    end
+  end
+
   # Ensure that all tests pass before allowing a release to continue
   def validate_release
     if !system("origen specs") || !system("origen examples")

data/config/version.rb

@@ -1,6 +1,6 @@
 module Origen
   MAJOR = 0
-  MINOR = 38
+  MINOR = 40
   BUGFIX = 0
   DEV = nil
 

data/lib/origen/{boot_api.rb → boot/api.rb}

@@ -1,10 +1,10 @@
 # Helper methods here and in the required files can be used by Origen during the bootup process.
 # (e.g., in site config ERB files)
 # This can be expanded as needed to provide more helpers.
-
 module Origen
+  # NOTE: Gems are not allowed to be required here, only Ruby stlibs
   require 'socket'
-  require_relative './operating_systems'
+  require_relative '../operating_systems'
 
   # Platform independent means of retrieving the hostname
   def self.hostname

data/lib/origen/boot/app.rb

@@ -0,0 +1,324 @@
+require 'fileutils'
+module Origen
+  # Provides methods for setting up, booting and
+  # archiving an Origen application
+  module Boot
+    # Gem executables that Origen depends on [bin name, gem name]
+    BIN_DEPS = [%w(rspec rspec-core), %w(nanoc nanoc), %w(yard yard),
+                %w(rubocop rubocop), %w(rake rake)]
+
+    BUNDLER_WARNING = '
+From Origen 0.40.0 onwards, a new way of launching Origen is supported and
+you are seeing this message because your application is still setup to run
+the old way.
+
+The main difference is that Origen is now launched via an Origen-owned binstub
+(./lbin/origen) rather than a Bundler-owned binstub. This means that Origen can
+no longer be prevented from running due to a Bundler configuration issue within
+your workspace and it should mean that Origen invocation becomes more reliable.
+
+It is recommended that you follow these instructions to upgrade your application
+to the new system.
+
+If have already done this and you are seeing this message again, then Bundler has
+overwritten the binstub at ./lbin/origen and you should perform the upgrade again.
+
+To upgrade, run the following command:
+
+ origen setup
+
+If you ever run the `bundle` or `bundle install` commands manually, never use
+the --binstubs option or it will roll you back to the old system.
+
+Under the new system, you should check the `./lbin` directory into your source
+control system, so remove it from your `.gitignore` (or equivalent) and check
+it in.
+
+When you install a new gem whose executable you want to use in your app,
+generate a binstub for it via the following command:
+
+  origen new binstub some-gem-name
+
+______________________________________________________________________________________
+
+'
+
+    BUNDLER_SETUP = %q(
+  if Origen.site_config.gem_manage_bundler
+    FileUtils.mkdir_p(File.join(origen_root, '.bundle'))
+    File.open(File.join(origen_root, '.bundle', 'config'), 'w') do |f|
+      f.puts '# Origen is managing this file, any local edits will be overwritten'
+      f.puts '# IT SHOULD NOT BE CHECKED INTO REVISION CONTROL!'
+      f.puts '---'
+      f.puts 'BUNDLE_BIN: false'
+      # If gems have been installed to the app, always use them
+      bundle_path = File.join(origen_root, 'vendor', 'gems')
+      if File.exist?(bundle_path)
+        # Only keep the gems we actually need when installing to the application, but
+        # don't do this when installing outside since other apps might use them
+        f.puts 'BUNDLE_CLEAN: true'
+      else
+        bundle_path = File.expand_path(Origen.site_config.gem_install_dir)
+      end
+      f.puts "BUNDLE_PATH: \"#{bundle_path}\""
+      Array(Origen.site_config.gem_build_switches).each do |build_switches|
+        switches = build_switches.strip.split(' ')
+        gem = switches.shift
+        f.puts "BUNDLE_BUILD__#{gem.upcase}: \"#{switches.join(' ')}\""
+      end
+    end
+  end
+)
+
+    UPDATER_WARNING = '
+The bin/fix_my_workspace script is not compatible with the new way that Origen is
+launched and you should remove it from your application.
+
+Do this by deleting bin/fix_my_workspace and also remove the origen_updater gem from
+your application.
+
+The command `origen setup` can be used in place of fix_my_workspace under the
+new system, however the new system should be more robust and such workspace repairs
+should no longer be required.
+
+______________________________________________________________________________________
+
+'
+
+    if Origen.os.windows?
+      PATH_WARNING = %q(
+Warning, your PATH does not contain ./lbin which is expected by Origen.
+You can correct this by editing your system's PATH environment variable via:
+
+(right-click) My Computer -> Properties -> Advanced system settings -> Environment Variables
+
+Path is under System variables and add the following value to it:
+
+  .\lbin
+
+______________________________________________________________________________________
+
+)
+
+    else
+      PATH_WARNING = %q(
+Warning, your PATH does not contain ./lbin which is expected by Origen.
+You can correct this by adding one of the following lines to the end of your
+environment setup file:
+
+  In ~/.bashrc or ~/.bashrc.user:  export PATH="./lbin:$PATH"'
+  In ~/.tcshrc or ~/.tcshrc.user:  setenv PATH "./lbin:$PATH"'
+
+______________________________________________________________________________________
+
+)
+    end
+
+    BINSTUB =
+"#!/usr/bin/env ruby
+#
+# This file was generated by Origen.
+#
+
+require 'rubygems'
+
+origen_lib = File.expand_path('../../lib/origen', Gem.bin_path('origen', 'origen'))
+boot = File.join(origen_lib, 'boot.rb')
+ORIGEN_ROOT = File.expand_path('..', __dir__)
+origen_root = ORIGEN_ROOT
+
+# If the Origen version supports the new boot system then use it
+if File.exist?(boot)
+  load boot
+
+# Otherwise fall back to an (improved) old-style invocation via Bundler
+else
+  require 'pathname'
+  require 'fileutils'
+  $_origen_invocation_pwd = Pathname.pwd
+  require File.join(origen_lib, 'site_config')
+" + BUNDLER_SETUP + %q(
+  bundle_binstub = File.expand_path('../bundle', __FILE__)
+
+  if File.file?(bundle_binstub)
+    if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+      load(bundle_binstub)
+    else
+      abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+  Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+    end
+  end
+  require 'bundler/setup'
+
+  load Gem.bin_path('origen', 'origen')
+end
+)
+    class << self
+      # Boot the application at the given root
+      def app!(origen_root)
+        # This will be used to collect warnings about the user's application environment, however showing them
+        # will be deferred until it has been determined that the application is using Origen >= 0.40.0 - i.e. we
+        # don't want to start complaining to the user about existing apps until they have intentionally upgraded
+        # their Origen version.
+        warnings = []
+
+        exec_remote = ARGV.include?('--exec_remote') ? true : false
+        lbin_dir = File.join(origen_root, 'lbin')
+        origen_binstub = File.join(lbin_dir, 'origen')
+
+        unless exec_remote
+          if Origen.os.windows?
+            warnings << PATH_WARNING unless ENV['PATH'] =~ /\.\\lbin(;|$)/
+          else
+            warnings << PATH_WARNING unless ENV['PATH'] =~ /(^|:)\.\/lbin(:|$)/
+          end
+
+          if !File.exist?(origen_binstub) ||
+             (File.exist?(origen_binstub) && File.read(origen_binstub) !~ /This file was generated by Origen/)
+            warnings << BUNDLER_WARNING
+          elsif File.exist?(File.join(origen_root, 'bin', 'fix_my_workspace'))
+            warnings << UPDATER_WARNING
+          end
+
+          setup_bundler(origen_root)
+        end
+
+        boot_app = true
+
+        Dir.chdir origen_root do
+          # Overriding bundler here so that bundle install can be automated as required, otherwise if just call
+          # require 'bundler/setup' then it will exit in the event of errors
+          require 'bundler'
+          begin
+            Bundler.setup
+          rescue Gem::LoadError, Bundler::BundlerError => e
+            puts e
+            puts
+            if exec_remote
+              puts 'App failed to boot, run it locally so that this can be resolved before re-submitting to the LSF'
+              exit 1
+            end
+            puts 'Attempting to resolve this...'
+            puts
+
+            passed = false
+
+            Bundler.with_clean_env do
+              cmd = 'bundle install'
+              cmd += ' --local' if File.exist?('.origen_archive')
+              passed = system(cmd)
+            end
+
+            if passed
+              Bundler.with_clean_env do
+                exec "origen #{ARGV.join(' ')}"
+              end
+              exit 0
+            else
+              puts
+              puts "If you have just updated a gem version and are now getting an error that Bundler cannot find compatible versions for it then first try running 'bundle update <gemname>'."
+              puts "For example if you have just changed the version of origen run 'bundle update origen'."
+              exit 1
+            end
+          end
+        end
+        unless exec_remote
+          # The application's bundle is safely loaded, do a final check to make sure that Origen's
+          # required bin dependencies have binstubs
+          if BIN_DEPS.any? { |bin, gem| !File.exist?(File.join(lbin_dir, bin)) }
+            system "bundle binstubs #{BIN_DEPS.map { |bin, gem| gem }.join(' ')} --path #{lbin_dir} --force"
+          end
+          if Origen.site_config.use_bootsnap && !Origen.os.windows?
+            ENV['BOOTSNAP_CACHE_DIR'] ||= "#{origen_root}/tmp/cache"
+            require 'bootsnap/setup'
+          end
+        end
+        require 'origen'
+        warnings
+      end
+
+      def setup(origen_root)
+        create_origen_binstub(origen_root)
+        bundle_path = setup_bundler(origen_root)
+        unless File.exist?(File.join(origen_root, '.origen_archive'))
+          copy_system_gems(origen_root, bundle_path)
+        end
+      end
+
+      def create_origen_binstub(origen_root)
+        lbin_dir = File.join(origen_root, 'lbin')
+
+        FileUtils.mkdir_p(lbin_dir)
+        File.open(File.join(lbin_dir, 'origen'), 'w') do |f|
+          f.puts BINSTUB
+        end
+        FileUtils.chmod('+x', File.join(lbin_dir, 'origen'))
+
+        if Origen.os.windows?
+          Dir.glob("#{origen_root}/lbin/*").each do |bin|
+            unless bin =~ /.bat$/
+              bat = "#{bin}.bat"
+              unless File.exist?(bat)
+                File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
+              end
+            end
+          end
+        end
+      end
+
+      def setup_bundler(origen_root)
+        bundle_path = nil
+        eval BUNDLER_SETUP  # Will update bundle_path
+        bundle_path
+      end
+
+      def copy_system_gems(origen_root, bundle_path)
+        require 'byebug'
+        if Origen.site_config.gem_use_from_system
+          local_gem_dir = "#{bundle_path}/ruby/#{Pathname.new(Gem.dir).basename}"
+          gem_dir = Pathname.new(Gem.dir)
+
+          Origen.site_config.gem_use_from_system.each do |gem, version|
+            begin
+              # This will raise an error if the system doesn't have this gem installed, that
+              # will be rescued below
+              spec = Gem::Specification.find_by_name(gem, version)
+
+              # If the spec has returned a handle to a system installed gem. If this script has been invoked through
+              # Bundler then it could point to some other gem dir. The only time this should occur is when switching
+              # from the old system to the new system, but can't work out how to fix it so just disabling in that case.
+              if spec.gem_dir =~ /#{gem_dir}/
+
+                local_dir = File.join(local_gem_dir, Pathname.new(spec.gem_dir).relative_path_from(gem_dir))
+                FileUtils.mkdir_p local_dir
+                FileUtils.cp_r("#{spec.gem_dir}/.", local_dir)
+
+                local_file = Pathname.new(File.join(local_gem_dir, Pathname.new(spec.cache_file).relative_path_from(gem_dir)))
+                FileUtils.mkdir_p local_file.dirname
+                FileUtils.cp(spec.cache_file, local_file)
+
+                if spec.extension_dir && File.exist?(spec.extension_dir)
+                  local_dir = File.join(local_gem_dir, Pathname.new(spec.extension_dir).relative_path_from(gem_dir))
+                  FileUtils.mkdir_p local_dir
+                  FileUtils.cp_r("#{spec.extension_dir}/.", local_dir)
+                end
+
+                local_file = Pathname.new(File.join(local_gem_dir, Pathname.new(spec.spec_file).relative_path_from(gem_dir)))
+                FileUtils.mkdir_p local_file.dirname
+                FileUtils.cp(spec.spec_file, local_file)
+
+                puts "Copied #{gem} #{version} from the system into #{bundle_path}"
+
+              end
+
+            rescue Exception # Gem::LoadError  # Rescue everything here, this is a try-our-best operation, better to
+              # continue and try and install the gem if this fails rather than crash
+              # This just means that one of the gems that should be copied from the system
+              # was not actually installed in the system, so nothing we can do about that here
+            end
+          end
+        end
+      end
+    end
+  end
+end