rvm 0.1.41 → 0.1.42

data/lib/rvm/environment/info.rb

@@ -0,0 +1,13 @@
+require 'yaml'
+
+module RVM
+  class Environment
+
+    def info(*ruby_strings)
+      ruby_string = normalize_ruby_string(ruby_strings)
+      res = rvm(:info, ruby_string)
+      res.successful? ? YAML.load(res.stdout) : {}
+    end
+
+  end
+end

data/lib/rvm/environment/list.rb

@@ -0,0 +1,124 @@
+module RVM
+  class Environment
+
+    # Returns a raw array list of ruby + gemset combinations.
+    def list_gemsets
+      normalize_listing_output rvm(:list, :gemsets, :strings).stdout
+    end
+
+    # Returns a raw array list of installed ruby strings, including aliases.
+    def list_strings
+      normalize_listing_output rvm(:list, :strings).stdout.tr(' ', "\n")
+    end
+
+    # Lists the default ruby (minus gemset)
+    def list_default
+      normalize rvm(:list, :default, :string).stdout
+    end
+
+    # Lists all known ruby strings (raw, filtered output)
+    def list_known
+      normalize_listing_output rvm(:list, :known).stdout
+    end
+
+    # Lists all known ruby strings
+    def list_known_strings
+      normalize_listing_output rvm(:list, :known_strings).stdout
+    end
+
+    # Lists all known svn tags.
+    def list_ruby_svn_tags
+      normalize_listing_output rvm(:list, :ruby_svn_tags).stdout
+    end
+
+    # Returns an interface to a more Ruby-like interface for list.
+    def list
+      @list_helper ||= ListWrapper.new(self)
+    end
+
+    # Provides a ruby-like interface to make listing rubies easier.
+    class ListWrapper
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Returns an array of ruby + gemset combinations.
+      def gemsets
+        @parent.list_gemsets
+      end
+
+      # Returns an array of installed rubies.
+      def rubies
+        @parent.list_strings
+      end
+      alias installed rubies
+      alias strings rubies
+
+      # Shows the current default. If :gemset is passed in and is
+      # true, it will include the gemset in the output.
+      def default(options = {})
+        options[:gemset] ? @parent.show_alias(:default) : @parent.list_default
+      end
+
+      # A raw list of known rubies.
+      def raw_known
+        @parent.list_known
+      end
+
+      def known_strings
+        @parent.list_known_strings
+      end
+
+      # A list of known ruby strings, minus svn tags.
+      def expanded_known
+        raw_known.map do |raw|
+          expand_variants(raw)
+        end.flatten.uniq.sort
+      end
+
+      # Raw list of svn tagged version
+      def raw_ruby_svn_tags
+        @parent.list_ruby_svn_tags
+      end
+
+      # Normalized list of ruby svn tags.
+      def ruby_svn_tags
+        raw_ruby_svn_tags.map { |t| expand_variants(t) }.flatten.uniq.sort
+      end
+      alias from_svn ruby_svn_tags
+
+      # Most installable ruby strings.
+      def installable
+        (expanded_known + ruby_svn_tags).uniq.sort
+      end
+
+      protected
+
+      # Expands strings to include optional parts (surrounded in brackets),
+      # given a useable string.
+      def expand_variants(s)
+        if s =~ /(\([^\)]+\))/
+          part = $1
+          expand_variants(s.sub(part, "")) + expand_variants(s.sub(part, part[1..-2]))
+        else
+          [s]
+        end
+      end
+
+    end
+
+    protected
+
+    # Takes a list of rubies / items, 1 per line and strips comments and blank lines.
+    def normalize_listing_output(results)
+      lines = []
+      results.each_line do |line|
+        line = line.gsub(/#.*/, '').strip
+        lines << line unless line.empty?
+      end
+      lines.sort
+    end
+
+  end
+end

data/lib/rvm/environment/rubies.rb

@@ -0,0 +1,50 @@
+module RVM
+  class Environment
+
+    # Installs the given ruby
+    def install(rubies, opts = {})
+      rvm(:install, normalize_ruby_string(rubies), opts).successful?
+    end
+
+    # Uninstalls a ruby (remove but keeps src etc)
+    def uninstall(rubies, opts = {})
+      rvm(:uninstall, normalize_ruby_string(rubies), opts).successful?
+    end
+
+    # Removes a given ruby from being managed by rvm.
+    def remove(rubies, opts = {})
+      rvm(:remove, normalize_ruby_string(rubies), opts).successful?
+    end
+
+    # Changes the ruby string for the current environment.
+    def use(ruby_string, opts = {})
+      ruby_string = ruby_string.to_s
+      result = rvm(:use, ruby_string)
+      if result.successful?
+        @environment_name = ruby_string
+        @expanded_name    = nil
+        use_env_from_result! result if opts[:replace_env]
+      end
+    end
+
+    # Like use but with :replace_env defaulting to true.
+    def use!(ruby_string, opts = {})
+      use ruby_string, opts.merge(:replace_env => true)
+    end
+
+    # Will get the ruby from the given path. If there
+    # is a compatible ruby found, it will then attempt
+    # to use the associated gemset.
+    # e.g. RVM::Environment.current.use_from_path! Dir.pwd
+    def use_from_path!(path)
+     use! tools.path_identifier(path)
+    end
+
+    protected
+
+    def normalize_ruby_string(rubies)
+      Array(rubies).join(",")
+    end
+
+  end
+end

data/lib/rvm/environment/sets.rb

@@ -0,0 +1,123 @@
+module RVM
+  class Environment
+
+    # Passed either something containing ruby code or
+    # a path to a ruby file, will attempt to exectute
+    # it in the current environment.
+    def ruby(runnable, options = {})
+      if runnable.respond_to?(:path)
+        # Call the path
+        ruby_run runnable.path, options
+      elsif runnable.respond_to?(:to_str)
+        runnable = runnable.to_str
+        File.exist?(runnable) ? ruby_run(runnable, options) : ruby_eval(runnable, options)
+      elsif runnable.respond_to?(:read)
+        ruby_run runnable.read
+      end
+    end
+
+    # Eval the given code within ruby.
+    def ruby_eval(code, options = {})
+      perform_set_operation :ruby, "-e", code.to_s, options
+    end
+
+    # Run the given path as a ruby script.
+    def ruby_run(path, options = {})
+      perform_set_operation :ruby, path.to_s, options
+    end
+
+    # Execute rake (optionally taking the path to a rake file),
+    # then change back.
+    def rake(file = nil, options = {})
+      if file.nil?
+        perform_set_operation :rake, options
+      else
+        file = File.expand_path(file)
+        chdir(File.dirname(file)) do
+          perform_set_operation(:rake, options.merge(:rakefile => file))
+        end
+      end
+    end
+
+    # Use the rvm test runner for unit tests.
+    def tests(options = {})
+      perform_set_operation :tests, options
+    end
+
+    # Use the rvm spec runner for specs.
+    def specs(options = {})
+      perform_set_operation :specs, options
+    end
+
+    # Like Kernel.system, but evaluates it within the environment.
+    # Also note that it doesn't support redirection etc.
+    def system(command, *args)
+      identifier = extract_identifier!(args)
+      args = [identifier, :exec, command, *args].compact
+      rvm(*args).successful?
+    end
+
+    # Executes a command, replacing the current shell.
+    # exec is a bit of an odd ball compared to the others, since
+    # it has to use the Kernel.exec builtin.
+    def exec(command, *args)
+      command = @shell_wrapper.build_cli_call(:exec, [command] + args)
+      Kernel.exec "bash", "-c", "source '#{env_path}'; #{command}"
+    end
+
+    protected
+
+    # Converts the given identifier to a rvm-friendly form.
+    # Unlike using sets directly, a nil identifier is set
+    # to mean the current ruby (not all). :all or "all" will
+    # instead return the a blank identifier / run it against
+    # all rubies.
+    def normalize_set_identifier(identifier)
+      case identifier
+      when nil, ""
+        @environment_name
+      when :all, "all"
+        nil
+      when Array
+        identifier.map { |i| normalize_set_identifier(i) }.uniq.join(",")
+      else
+        identifier.to_s
+      end
+    end
+
+    # From an options hash, extract the environment identifier.
+    def extract_environment!(options)
+      values = []
+      [:environment, :env, :rubies, :ruby].each do |k|
+        values << options.delete(k)
+      end
+      values.compact.first
+    end
+
+    # Shorthand to extra an identifier from args.
+    # Since we
+    def extract_identifier!(args)
+      options = extract_options!(args)
+      identifier = normalize_set_identifier(extract_environment!(options))
+      args << options
+      identifier
+    end
+
+    # Performs a set operation. If the :env or :environment option is given,
+    # it will return a yaml summary (instead of the stdout / stderr etc via
+    # a Result object.
+    def perform_set_operation(*args)
+      options     = extract_options!(args)
+      environment = extract_environment!(options)
+      identifier  = normalize_set_identifier(environment)
+      # Uses yaml when we have multiple identifiers.
+      uses_yaml   = !environment.nil?
+      options.merge!(:yaml => true) if uses_yaml
+      args.unshift(identifier) unless identifier.nil?
+      args << options
+      result = rvm(*args)
+      uses_yaml ? YAML.load(result.stdout) : result
+    end
+
+  end
+end

data/lib/rvm/environment/tools.rb

@@ -0,0 +1,41 @@
+module RVM
+  class Environment
+
+    # Gets the full name for the current env.
+    def tools_identifier
+      normalize rvm(:tools, :identifier).stdout
+    end
+
+    # Gets the identifier after cd'ing to a path, no destructive.
+    def tools_path_identifier(path)
+      normalize rvm(:tools, "path-identifier", path.to_s).stdout
+    end
+
+    # Return the tools wrapper.
+    def tools
+      @tools_wrapper ||= ToolsWrapper.new(self)
+    end
+
+    # Ruby like wrapper for tools
+    class ToolsWrapper
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Returns the current envs expanded identifier
+      def identifier
+        @parent.tools_identifier
+      end
+
+      # Returns the identifier for a path, taking into account
+      # things like an rvmrc
+      def path_identifier(path)
+        @parent.tools_path_identifier(File.expand_path(path))
+      end
+      alias identifier_for_path path_identifier
+
+    end
+
+  end
+end

data/lib/rvm/environment/utility.rb

@@ -0,0 +1,167 @@
+module RVM
+  class Environment
+
+    PREFIX_OPTIONS = [:trace, :json, :yaml]
+
+    # Returns the environment identifier for the current environment,
+    # as determined from the GEM_HOME.
+    def self.current_environment_id
+      @current_environment_id ||= begin
+        gem_home = ENV['GEM_HOME'].to_s.strip
+        if !gem_home.empty? && gem_home =~ /rvm\/gems\//
+          File.basename(gem_home)
+        else
+          matching_path = $:.select { |item| item =~ /rvm\/rubies/ }.first
+          matching_path.to_s.gsub(/^.*rvm\/rubies\//, '').split('/')[0] || "system"
+        end
+      end
+    end
+
+    # Returns the ruby string that represents the current environment.
+    def self.current_ruby_string
+      identifier_to_ruby_string current_environment_id
+    end
+
+    # Converts a ruby identifier (string + gemset) to just the ruby string.
+    def self.identifier_to_ruby_string(identifier)
+      identifier.gsub(/@.*$/, '')
+    end
+
+    # Returns the currentl environment.
+    # Note that when the ruby is changed, this is reset - Also,
+    # if the gemset is changed it will also be reset.
+    def self.current
+      @current_environment ||= Environment.new(current_environment_id)
+    end
+
+    # Sets the current environment back to the currently running ruby
+    # or the system env (if it can't be determined from GEM_HOME).
+    def self.reset_current!
+      @current_environment = nil
+    end
+
+    # Lets you build a command up, without needing to see the output.
+    # As an example,
+    #
+    #  rvm :use, "ree@rails3", :install => true
+    #
+    # Will call the following:
+    #
+    #  rvm use ree@rails3 --install
+    #
+    def rvm(*args)
+      options = extract_options!(args)
+      silent = options.delete(:silent)
+      rearrange_options!(args, options)
+      args += hash_to_options(options)
+      args.map! { |a| a.to_s }
+      if silent
+        run_silently 'rvm', *args
+      else
+        run 'rvm', *args
+      end
+    end
+
+    # Run commands inside the given directory.
+    def chdir(dir)
+      run_silently :pushd, dir.to_s
+      result = Dir.chdir(dir) { yield }
+      run_silently :popd
+      result
+    end
+
+    protected
+
+    # Moves certain options (e.g. yaml, json etc) to the front
+    # of the arguments list, making stuff like sets work.
+    def rearrange_options!(args, options)
+      prefix_options = {}
+      (PREFIX_OPTIONS + PREFIX_OPTIONS.map { |o| o.to_s }).each do |k|
+        if options.has_key?(k)
+          value = options.delete(k)
+          prefix_options[k.to_sym] = value
+        end
+      end
+      hash_to_options(prefix_options).reverse.each { |o| args.unshift(o) }
+    end
+
+    def ruby_string(result)
+      if result && result[:rvm_ruby_string]
+        result[:rvm_ruby_string]
+      else
+        self.class.identifier_to_ruby_string expanded_name
+      end
+    end
+
+    # Checks whether the given environment is compatible with the current
+    # ruby interpeter.
+    def compatible_with_current?(result)
+      ruby_string(result) == self.class.current_ruby_string
+    end
+
+    # Given an environment identifier, it will add the the given
+    # gemset to the end to form a qualified identifier name.
+    def self.environment_with_gemset(environment, gemset)
+      environment_name, gemset_name = environment.split("@", 2)
+      environment_name = "default"     if environment_name.to_s.empty?
+      environment_name << "@#{gemset}" unless gemset.to_s.empty?
+      environment_name
+    end
+
+    # Returns a value, or nil if it is blank.
+    def normalize(value)
+      value = value.to_s.strip
+      value.empty? ? nil : value
+    end
+
+    # Normalizes an array, removing blank lines.
+    def normalize_array(value)
+      value.split("\n").map { |l| l.strip }.reject { |l| l.empty? }
+    end
+
+    # Extract options from a hash.
+    def extract_options!(args)
+      args.last.is_a?(Hash) ? args.pop : {}
+    end
+
+    # Converts a hash of options to an array of command line argumets.
+    # If the value is false, it wont be added but if it is true only the
+    # key will be added. Lastly, when the value is neither true or false,
+    # to_s will becalled on it and it shall be added to the array.
+    def hash_to_options(options)
+      result = []
+      options.each_pair do |key, value|
+        real_key = "--#{key.to_s.gsub("_", "-")}"
+        if value == true
+          result << real_key
+        elsif value != false
+          result << real_key
+          result << value.to_s
+        end
+      end
+      result
+    end
+
+    # Recursively normalize options.
+    def normalize_option_value(value)
+      case value
+      when Array
+        value.map { |v| normalize_option_value(v) }.join(",")
+      else
+        value.to_s
+      end
+    end
+
+    def use_env_from_result!(result)
+      if compatible_with_current?(result)
+        ENV['GEM_HOME']    = result[:GEM_HOME]
+        ENV['GEM_PATH']    = result[:GEM_PATH]
+        ENV['BUNDLE_PATH'] = result[:BUNDLE_PATH]
+        Gem.clear_paths if defined?(Gem)
+      else
+        raise IncompatibleRubyError.new(result, "The given ruby environment requires #{ruby_string(result)} (versus #{self.class.current_ruby_string})")
+      end
+    end
+
+  end
+end