rvm 0.1.41 → 0.1.42

data/lib/rvm/capistrano.rb

@@ -0,0 +1,45 @@
+# Recipes for using RVM on a server with capistrano.
+
+unless Capistrano::Configuration.respond_to?(:instance)
+  abort "rvm/capistrano requires Capistrano >= 2."
+end
+
+Capistrano::Configuration.instance(true).load do
+
+  # Taken from the capistrano code.
+  def _cset(name, *args, &block)
+    unless exists?(name)
+      set(name, *args, &block)
+    end
+  end
+
+  set :default_shell do
+    shell = File.join(rvm_bin_path, "rvm-shell")
+    ruby = rvm_ruby_string.to_s.strip
+    shell = "#{shell} '#{ruby}'" unless ruby.empty?
+    shell
+  end
+
+  # Let users set the type of their rvm install.
+  _cset(:rvm_type, :system)
+
+  # Let users override the rvm_bin_path
+  _cset(:rvm_bin_path) do
+    case rvm_type
+    when :system_wide, :root, :system
+      "/usr/local/bin"
+    when :local, :user, :default
+      "$HOME/.rvm/bin"
+    end
+  end
+
+  # Use the default ruby.
+  _cset(:rvm_ruby_string, "default")
+
+end
+
+# E.g, to use ree and rails 3:
+#
+#   require 'rvm/capistrano'
+#   set :rvm_ruby_string, "ree@rails3"
+#

data/lib/rvm/environment.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module RVM
+  # Implements the actual wrapper around the api. For more information
+  # about this design, see the RVM module.
+  class Environment
+    extend Forwardable
+
+    %w(configuration utility alias list gemset rubies cleanup sets env tools info).each do |key|
+      require File.join("rvm", "environment", key)
+    end
+
+    # The default config has rvm_silence_logging so that log doesn't print anything to stdout.
+    merge_config! :rvm_silence_logging => 1
+
+    attr_reader :environment_name, :shell_wrapper
+
+    # Creates a new environment with the given name and optionally
+    # a set of extra environment variables to be set on load.
+    def initialize(environment_name = "default", options = {})
+      merge_config! options
+      @environment_name = environment_name
+      @shell_wrapper = Shell.default_wrapper.new
+      @shell_wrapper.setup do |s|
+        source_rvm_environment
+        use_rvm_environment
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} environment_name=#{@environment_name.inspect}>"
+    end
+
+    # Returns the expanded name, using the same method as used by the rvm command line.
+    def expanded_name
+      @expanded_name ||= tools_identifier.to_s
+    end
+
+    # Actually define methods to interact with the shell wrapper.
+    def_delegators :@shell_wrapper, :run, :run_silently, :run_command_without_output,
+                   :run_command, :[], :escape_argument
+
+    protected
+
+    # Automatically load rvm config from the multiple sources.
+    def source_rvm_environment
+      rvm_path = config_value_for(:rvm_path, File.expand_path("~/.rvm"), false)
+      actual_config = defined_config.merge('rvm_path' => rvm_path)
+      config = []
+      actual_config.each_pair do |k, v|
+        config << "#{k}=#{escape_argument(v.to_s)}"
+      end
+      run_silently :export, config.join(" ")
+      run_silently :source, File.join(rvm_path, "scripts", "rvm")
+    end
+
+    def use_rvm_environment
+      rvm :use, @environment_name, :silent => true
+    end
+
+  end
+end

data/lib/rvm/environment/alias.rb

@@ -0,0 +1,69 @@
+module RVM
+  class Environment
+
+    # Returns a hash of aliases.
+    def alias_list
+      lines = normalize_array(rvm(:alias, :list).stdout)
+      lines.inject({}) do |acc, current|
+        alias_name, ruby_string = current.to_s.split(" => ")
+        unless alias_name.empty? || ruby_string.empty?
+          acc[alias_name] = ruby_string
+        end
+        acc
+      end
+    end
+
+    # Shows the full ruby string that a given alias points to.
+    def alias_show(name)
+      normalize rvm(:alias, :show, name.to_s).stdout
+    end
+
+    # Deletes an alias and returns the exit status.
+    def alias_delete(name)
+      rvm(:alias, :delete, name.to_s).successful?
+    end
+
+    # Creates an alias with the given name.
+    def alias_create(name, ruby_string)
+      rvm(:alias, :create, name.to_s, ruby_string.to_s).successful?
+    end
+
+    # Returns an aliases proxy which can be used in a more Ruby-like manner.
+    def aliases
+      @aliases ||= AliasWrapper.new(self)
+    end
+
+    # Provides a Ruby-like wrapper to the alias functionality.
+    class AliasWrapper
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Shows the value of a given alias.
+      def show(name)
+        @parent.alias_show name
+      end
+      alias [] show
+
+      # Deletes the given alias.
+      def delete(name)
+        @parent.alias_delete name
+      end
+
+      # Creates an alias with a given name and ruby string.
+      def create(name, ruby_string)
+        @parent.alias_create name, ruby_string
+      end
+      alias []= create
+
+      # Returns a hash of all aliases.
+      def list
+        @parent.alias_list
+      end
+      alias all list
+
+    end
+
+  end
+end

data/lib/rvm/environment/cleanup.rb

@@ -0,0 +1,54 @@
+module RVM
+  class Environment
+
+    # Batch define common operations.
+    %w(all archives repos sources logs).each do |cleanup_type|
+      define_method(:"cleanup_#{cleanup_type}") do
+        rvm(:cleanup, cleanup_type).successful?
+      end
+    end
+
+    # Returns the ruby-like interface defined by CleanupWrapper
+    def cleanup
+      @cleanup_wrapper ||= CleanupWrapper.new(self)
+    end
+
+    # Implements a Ruby-like interface to cleanup, making it nicer to deal with.
+    class CleanupWrapper
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Cleans up archives, repos, sources and logs
+      def all
+        @parent.cleanup_all
+      end
+      alias everything all
+
+      # Cleans up everything in the archives folder
+      def archives
+        @parent.cleanup_archives
+      end
+
+      # Cleans up everything in the repos path
+      def repos
+        @parent.cleanup_repos
+      end
+      alias repositories repos
+
+      # Cleans up everything in the source folder
+      def sources
+        @parent.cleanup_sources
+      end
+      alias src sources
+
+      # Cleans up all of the logs
+      def logs
+        @parent.cleanup_logs
+      end
+
+    end
+
+  end
+end

data/lib/rvm/environment/configuration.rb

@@ -0,0 +1,60 @@
+module RVM
+  class Environment
+
+    # Define the config accessor, which basically uses config_value_for and
+    # the linke to set the env variable.
+    def self.define_config_accessor(*args)
+      singleton = (class << self; self; end)
+      args.each do |arg|
+        singleton.send(:define_method, arg)        { RVM::Environment.config_value_for(arg) }
+        singleton.send(:define_method, :"#{arg}=") { |v| RVM::Environment.merge_config! arg => v }
+      end
+    end
+
+    define_config_accessor :rvm_path, :rvm_config_path, :rvm_bin_path
+
+    # Mixin for a set of configs.
+    module ConfigMixin
+
+      # Returns the current config for this scope
+      def config
+        @config ||= {}
+      end
+
+      # Merge a set of items into the config.
+      def merge_config!(r)
+        r.each_pair { |k, v| config[k.to_s] = v }
+      end
+
+      # Reset this local config to be empty.
+      def clear_config!
+        @config = {}
+      end
+    end
+
+    include ConfigMixin
+    extend  ConfigMixin
+
+    # Gets the default option or the current
+    # environment variable for a given env var.
+    def self.config_value_for(value)
+      value = value.to_s
+      config[value] || ENV[value]
+    end
+
+    # Returns the value for a configuration option (mapping to an
+    # environment variable). If check_live is true (which it is
+    # by default), it will also check the environment for a value.
+    def config_value_for(key, default = nil, check_live = true)
+      key = key.to_s
+      value = check_live ? self[key.to_s] : nil
+      value || config[key] || self.class.config_value_for(key) || default
+    end
+
+    # Returns a hash of all of the user defined configuration.
+    def defined_config
+      self.class.config.merge(self.config)
+    end
+
+  end
+end

data/lib/rvm/environment/env.rb

@@ -0,0 +1,52 @@
+module RVM
+  class Environment
+
+    # Returns the contents of the env file.
+    def env_contents
+      rvm(:env).stdout
+    end
+
+    # Returns the path to the env file
+    def env_path
+      rvm(:env, :path => true).stdout.strip
+    end
+
+    # Returns a ruby-like wrapper for the env functions
+    def env
+      @env_wrapper ||= EnvWrapper.new(self)
+    end
+
+    # Returns the path for the given command
+    def path_for(command)
+      run(:command, "-v", command).stdout.strip
+    end
+    alias which path_for
+
+    # Simple ruby like wrapper for envs.
+    class EnvWrapper
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Contents of the env file.
+      def contents
+        @parent.env_contents
+      end
+      alias read contents
+      alias to_s contents
+
+      # The path of the env file.
+      def path
+        @parent.env_path
+      end
+
+      # Opens a file on the env file.
+      def to_file
+        File.open(path)
+      end
+
+    end
+
+  end
+end

data/lib/rvm/environment/gemset.rb

@@ -0,0 +1,222 @@
+module RVM
+  class Environment
+
+    # Loads a gemset into the current environment.
+    # If an argument is given, it will load it from
+    # file_prefix.gems
+    def gemset_import(file_prefix = nil)
+      args = [file_prefix].compact
+      rvm(:gemset, :import, *args).successful?
+    end
+    alias gemset_load gemset_import
+
+    # Exports a gemset.
+    def gemset_export(gemset_or_file = nil)
+      args = [gemset_or_file].compact
+      rvm(:gemset, :export, *args).successful?
+    end
+    alias gemset_dump gemset_export
+
+    def gemset_list
+      normalize_array rvm(:gemset, :list).stdout
+    end
+
+    # Creates a new gemset with the given name.
+    def gemset_create(*names)
+      names = names.flatten
+      rvm(:gemset, :create, *names).successful?
+    end
+
+    # Copies the gems between two different gemsets.
+    def gemset_copy(from, to)
+      rvm(:gemset, :copy, from, to).successful?
+    end
+
+    # Deletes the gemset with a given name.
+    def gemset_delete(name)
+      run("echo 'yes' | rvm", :gemset, :delete, name.to_s).successful?
+    end
+
+    # Removes all gem-related stuff from the current gemset.
+    def gemset_empty
+      run("echo 'yes' | rvm", :gemset, :empty).successful?
+    end
+
+    # Resets the current gemset to a pristine state.
+    def gemset_pristine
+      rvm(:gemset, :pristine).successful?
+    end
+
+    # Updates all gems in the current gemset.
+    def gemset_update
+      rvm(@environment_name, :gemset, :update).successful?
+    end
+
+    # Prunes the gem cache for the current ruby.
+    def gemset_prune
+      rvm(:gemset, :prune).successful?
+    end
+
+    # Initializes gemsets for a given ruby.
+    def gemset_intial
+      rvm(:gemset, :initial).successful?
+    end
+
+    # Enable or disable the rvm gem global cache.
+    def gemset_globalcache(enable = true)
+      case enable
+        when "enabled", :enabled
+          run(:__rvm_using_gemset_globalcache).successful?
+        when true, "enable", :enable
+          rvm(:gemset, :globalcache, :enable).successful?
+        when false, "disable", :disable
+          rvm(:gemset, :globalcache, :disable).successful?
+        else
+          false
+      end
+    end
+
+    # Changes the current environments gemset. If :replace_env is passed
+    # and the ruby is compatible, it will attempt to replace the current
+    # processes gem home and path with the one requested.
+    def gemset_use(gemset, options = {})
+      replace_env = options.delete(:replace_env)
+      result = rvm(:gemset, :use, gemset, options)
+      if result.successful?
+        gemset_name = result[:rvm_gemset_name]
+        @environment_name = self.class.environment_with_gemset(@environment_name, gemset_name)
+        @expanded_name    = nil
+        self.class.reset_current!
+        use_env_from_result! result if replace_env
+        true
+      end
+    end
+
+    # Like gemset_use, but replaces the env by default.
+    def gemset_use!(name, options = {})
+      gemset_use name, {:replace_env => true}.merge(options)
+    end
+
+    %w(gemdir gempath gemhome home path version name string dir).each do |action|
+      define_method(:"gemset_#{action}") do
+        normalize rvm(:gemset, action).stdout
+      end
+    end
+
+    # Returns the Ruby-like wrapper for gemset operations.
+    def gemset
+      @gemset_wrapper ||= GemsetWrapper.new(self)
+    end
+
+    # Wraps the gemset functionality.
+    class GemsetWrapper
+      extend Forwardable
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Import a gemset file.
+      def import(prefix)
+        @parent.gemset_export prefix.to_s.gsub(/\.gems$/, '')
+      end
+      alias load import
+
+      # Export a given gemset or, if the name ends with .gems, the current gemset.
+      def export(path_or_name)
+        @parent.gemset_export path_or_name.to_s
+      end
+      alias dump export
+      alias save export
+
+      # Returns a list of all gemsets belonging to the current ruby.
+      def list
+        @parent.gemset_list
+      end
+      alias all list
+
+      # Creates gemsets with the given names.
+      def create(*names)
+        @parent.gemset_create(*names.flatten)
+      end
+
+      # Delete a given gemset.
+      def delete(name)
+        @parent.gemset_delete(name)
+      end
+
+      # Empty the current gemset.
+      def empty
+        @parent.gemset_empty
+      end
+
+      # Restores the current gemset to a pristine state.
+      def pristine
+        @parent.gemset_pristine
+      end
+
+      # Updates all gems in the current gemset.
+      def update
+        @parent.gemset_update
+      end
+
+      # Prune the current gemset.
+      def prune
+        @parent.gemset_prune
+      end
+
+      # Use a given gemset in this environment
+      def use(name)
+        @parent.gemset_use(name)
+      end
+
+      # Use the given gemset, replacing the current
+      # gem environment if possible.
+      def use!(name)
+        @parent.gemset_use(name, :replace_env => true)
+      end
+
+      # Shortcut to deal with the gemset global cache.
+      def globalcache
+        @globalcache ||= GlobalCacheHelper.new(@parent)
+      end
+
+      # Copy gems from one gemset to another.
+      def copy(from, to)
+        @parent.gemset_copy(from, to)
+      end
+
+      %w(gemdir gempath gemhome home path version name string dir).each do |action|
+        define_method(action) do
+          @parent.send(:"gemset_#{action}")
+        end
+      end
+
+      # A Ruby-like wrapper to manipulate the rvm gem global cache.
+      class GlobalCacheHelper
+
+        def initialize(parent)
+          @parent = parent
+        end
+
+        # Enable the globalcache
+        def enable!
+          @parent.gemset_globalcache :enable
+        end
+
+        # Disable the globalcache
+        def disable!
+          @parent.gemset_globalcache :disable
+        end
+
+        # Returns whether or not the globalcache is enabled.
+        def enabled?
+          @parent.gemset_globalcache :enabled
+        end
+
+      end
+
+    end
+
+  end
+end