gemrage 0.1.1 → 0.1.2

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/shell/calculate_rvm_path.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Calculates a default rvm path
+
+# Check first.
+if [[ -n "$rvm_path" ]]; then
+  echo "$rvm_path"
+  exit
+fi
+
+# Load extra files.
+
+[[ -s ~/.rvmrc ]] && source ~/.rvmrc >/dev/null 2>&1
+[[ -s /etc/.rvmrc ]] && source /etc/rvmrc >/dev/null 2>&1
+
+if [[ -n "$rvm_path" ]]; then
+  echo "$rvm_path"
+elif [[ -d ~/.rvm ]]; then
+  echo "~/.rvm"
+elif [[ -d /usr/local/rvm ]]; then
+  echo "/usr/local/rvm"
+else
+  exit 1
+fi
+
+exit 0

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/shell/result.rb

@@ -0,0 +1,42 @@
+module RVM
+  module Shell
+    # Represents the output of a shell command.
+    # This includes the exit status (and the helpful #successful? method)
+    # as well accessors for the command and stdout / stderr.
+    class Result
+
+      attr_reader :command, :stdout, :stderr, :raw_status
+
+      # Creates a new result object with the given details.
+      def initialize(command, status, stdout, stderr)
+        @command     = command.dup.freeze
+        @raw_status  = status
+        @environment = @raw_status["environment"] || {}
+        @successful  = (exit_status == 0)
+        @stdout      = stdout.freeze
+        @stderr      = stderr.freeze
+      end
+
+      # Returns the hash of the environment.
+      def env
+        @environment
+      end
+
+      # Whether or not the command had a successful exit status.
+      def successful?
+        @successful
+      end
+
+      # Returns a value from the outputs environment.
+      def [](key)
+        env[key.to_s]
+      end
+
+      # Returns the exit status for the program
+      def exit_status
+        @exit_status ||= (Integer(@raw_status["exit_status"]) rescue 1)
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/shell/shell_wrapper.sh

@@ -0,0 +1,10 @@
+# Prints an epilog to a shell command.
+__rvm_show_command_epilog() {
+  local last_command_result="$?"
+  echo "---------------RVM-RESULTS-START---------------"
+  echo "---"
+  echo " exit_status: \"$last_command_result\""
+  echo " environment:"
+  env | sed "s#'#\\'#g" | sed -e 's#"#\\"#g' -e "s#\\([^=]*\\)=\\(.*\\)#   '\1': \"\2\"#"
+  echo "----------------RVM-RESULTS-END----------------"
+}

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/shell/single_shot_wrapper.rb

@@ -0,0 +1,56 @@
+require 'open3'
+
+module RVM
+  module Shell
+    # Implementation of the abstract wrapper class that opens a new
+    # instance of bash when a command is run, only keeping it around
+    # for the lifetime of the command. Possibly inefficient but for
+    # the moment simplest and hence default implementation.
+    class SingleShotWrapper < AbstractWrapper
+
+      attr_accessor :current
+
+      # Runs a given command in the current shell.
+      # Defaults the command to true if empty.
+      def run_command(command)
+        command = "true" if command.to_s.strip.empty?
+        with_shell_instance do
+          stdin.puts wrapped_command(command)
+          stdin.close
+          out, err = stdout.read, stderr.read
+          out, status, _ = raw_stdout_to_parts(out)
+          return status, out, err
+        end
+      end
+
+      # Runs a command, ensuring no output is collected.
+      def run_command_silently(command)
+        with_shell_instance do
+          stdin.puts silent_command(command)
+        end
+      end
+
+      protected
+
+      # yields stdio, stderr and stdin for a shell instance.
+      # If there isn't a current shell instance, it will create a new one.
+      # In said scenario, it will also cleanup once it is done.
+      def with_shell_instance(&blk)
+        no_current = @current.nil?
+        if no_current
+          @current = Open3.popen3(self.shell_executable)
+          invoke_setup!
+        end
+        yield
+      ensure
+        @current = nil if no_current
+      end
+
+      # Direct access to each of the named descriptors
+      def stdin;  @current[0]; end
+      def stdout; @current[1]; end
+      def stderr; @current[2]; end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/shell/utility.rb

@@ -0,0 +1,37 @@
+module RVM
+  module Shell
+    module Utility
+
+      public
+
+      # Takes an array / number of arguments and converts
+      # them to a string useable for passing into a shell call.
+      def escape_arguments(*args)
+        return '' if args.nil?
+        args.flatten.map { |a| escape_argument(a.to_s) }.join(" ")
+      end
+
+      # Given a string, converts to the escaped format. This ensures
+      # that things such as variables aren't evaluated into strings
+      # and everything else is setup as expected.
+      def escape_argument(s)
+        return "''" if s.empty?
+        s.scan(/('+|[^']+)/).map do |section|
+          section = section.first
+          if section[0] == ?'
+            "\\'" * section.length
+          else
+            "'#{section}'"
+          end
+        end.join
+      end
+
+      # From a command, will build up a runnable command. If args isn't provided,
+      # it will escape arguments.
+      def build_cli_call(command, args = nil)
+        "#{command} #{escape_arguments(args)}".strip
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/shell.rb

@@ -0,0 +1,25 @@
+module RVM
+  # Provides Generic access to a more ruby-like shell interface.
+  # For more details, see AbstractWrapper.
+  module Shell
+
+    autoload :AbstractWrapper,   'rvm/shell/abstract_wrapper'
+    autoload :SingleShotWrapper, 'rvm/shell/single_shot_wrapper'
+    # Current unimplemented
+    #autoload :PersistingWrapper, 'rvm/shell/persisting_wrapper'
+    autoload :TestWrapper,       'rvm/shell/test_wrapper'
+    autoload :Utility,           'rvm/shell/utility'
+    autoload :Result,            'rvm/shell/result'
+
+    # Returns the default shell wrapper class to use
+    def self.default_wrapper
+      @@default_wrapper ||= SingleShotWrapper
+    end
+
+    # Sets the default shell wrapper class to use.
+    def self.default_wrapper=(wrapper)
+      @@default_wrapper = wrapper
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/version.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+
+module RVM
+  module Version
+
+    # YAML of raw version info
+    VERSION_YAML = YAML.load_file(File.expand_path("../VERSION.yml", File.dirname(__FILE__)))
+
+    # Current major version of rvm
+    MAJOR  = VERSION_YAML[:major]
+    # Current minor version of rvm
+    MINOR  = VERSION_YAML[:minor]
+    # Current patch level of rvm
+    PATCH  = VERSION_YAML[:patch]
+    # A String with the current rvm version
+    STRING = [MAJOR, MINOR, PATCH].join(".").freeze
+
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm.rb

@@ -0,0 +1,156 @@
+# == Ruby Version Manager - Ruby API
+#
+# Provides a wrapper around the command line api implemented as part of the api.
+# If you're not familiar with rvm, please read http://rvm.beginrescueend.com/
+# first.
+#
+# == Usage
+#
+# When using the rvm ruby api, you gain access to most of the commands, including the set
+# functionality. As a side node, the RVM module provides access to most of the api
+# both via direct api wrappers (of the form <tt><tool>_<action></tt> - e.g. +alias_create+,
+# +gemset_use+ and +wrapper+).
+#
+# == The Environment Model
+#
+# The RVM ruby api is implemented using an environment model. Each environment maps directly
+# to some ruby string interpretable by rvm (e.g. +ree+, +ruby-1.8.7-p174+, +system+, +rbx@rails+
+# and so on) and is considered a sandboxed environment (for commands like use etc) in which you
+# can deal with rvm. it's worth noting that a single environment can have multiple environment
+# instances and for the most part creating of these instances is best handled by the RVM.environment
+# and RVM.environments methods.
+#
+# Each Environment (and instance of RVM::Environment) provides access to the rvm ruby api (in some
+# cases, the api may not directly be related to the current ruby - but for simplicity / consistency
+# purposes, they are still implemented as methods of RVM::Environment).
+#
+# When you perform an action with side effects (e.g. RVM::Environment#gemset_use or RVM::Environment#use)
+# this will mutate the ruby string of the given environment (hence, an environment is considered mutable).
+#
+# Lastly, for the actual command line work, RVM::Environment works with an instance of RVM::Shell::AbstractWrapper.
+# This performs logic (such as correctly escaping strings, calling the environment and such) in a way that
+# is both reusable and simplified.
+#
+# By default, method_missing is used on the RVM module to proxy method calls to RVM.current (itself
+# calling RVM::Environment.current), meaning things like RVM.gemset_name, RVM.alias_create and the like
+# work. This is considered the 'global' instance and should be avoided unless needed directly.
+#
+# RVM::Environment.current will first attempt to use the current ruby string (determined by
+# +ENV['GEM_HOME']+ but will fall back to using the rubies load path if that isn't available).
+#
+# In many cases, (e.g. +alias+, +list+ and the like) there is a more ruby-like wrapper class,
+# typically available via <tt>RVM::Environment#<action></tt>.
+#
+# == Side Notes
+#
+# In the cases this api differs, see the RVM::Environment class for more information.
+#
+# You can check the name of a given environment in two ways - RVM::Environment#environment_name
+# for the short version / the version set by RVM::Environment#use, RVM::Environment#gemset_use
+# or RVM.environment. If you wish to get the full, expanded string (which has things such as
+# the actual version of the selected ruby), you instead with to use RVM::Environment#expanded_name.
+#
+# Lastly, If you do need to pass environment variables to a specific environment, please use
+# RVM::Environment.new, versus RVM.environment
+#
+module RVM
+  require 'rvm/errors'
+
+  autoload :Shell,       'rvm/shell'
+  autoload :Environment, 'rvm/environment'
+  autoload :Version,     'rvm/version'
+
+  class << self
+
+    # Returns the current global environment.
+    def current
+      Environment.current
+    end
+
+    # Reset the current global environment to the default / what it was
+    # when the process first started.
+    def reset_current!
+      Environment.reset_current!
+    end
+
+    # Returns an array of multiple environments. If given
+    # a block, will yield each time with the given environment.
+    #
+    #   RVM.environments("ree@rails3,rbx@rails3") do |env|
+    #     puts "Full environment: #{env.expanded_name}"
+    #   end
+    #
+    # Alternatively, you can use the more ruby-like fashion:
+    #
+    #   RVM.environments("ree@rails3", "rbx@rails3") do |env|
+    #     puts "Full environment: #{env.expanded_name}"
+    #   end
+    #
+    def environments(*names, &blk)
+      # Normalize the names before using them on for the environment.
+      names.flatten.join(",").split(",").uniq.map do |n|
+        environment(n, &blk)
+      end
+    end
+
+    # Returns the environment with the given name.
+    # If passed a block, will yield with that as the single argument.
+    #
+    #   RVM.environment("ree@rails3") do |env|
+    #     puts "Gemset is #{env.gemset.name}"
+    #   end
+    #
+    def environment(name)
+      # TODO: Maintain an Environment cache.
+      # The cache needs to track changes via use etc though.
+      env = Environment.new(name)
+      yield env if block_given?
+      env
+    end
+
+    # Merges items into the default config, essentially
+    # setting environment variables passed to child processes:
+    #
+    #   RVM.merge_config!({
+    #     :some_shell_variable => "me",
+    #   })
+    #
+    def merge_config!(config = {})
+      Environment.merge_config!(config)
+    end
+
+    # Returns the current 'best guess' value for rvm_path.
+    def path
+      Environment.rvm_path
+    end
+
+    #  Shortcut to set rvm_path. Will set it on all new instances
+    #  but wont affect currently running environments.
+    def path=(value)
+      Environment.rvm_path = value
+    end
+
+    private
+
+    def cache_method_call(name)
+      class_eval <<-END, __FILE__, __LINE__
+        def #{name}(*args, &blk)
+          current.__send__(:#{name}, *args, &blk)
+        end
+      END
+    end
+
+    # Proxies methods to the current environment, creating a
+    # method before dispatching to speed up future calls.
+    def method_missing(name, *args, &blk)
+      if current.respond_to?(name)
+        cache_method_call name
+        current.__send__ name, *args, &blk
+      else
+        super
+      end
+    end
+
+  end
+
+end