gemrage 0.1.1 → 0.1.2

data/vendor/ruby/1.8/gems/rvm-1.0.14/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/vendor/ruby/1.8/gems/rvm-1.0.14/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/vendor/ruby/1.8/gems/rvm-1.0.14/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/vendor/ruby/1.8/gems/rvm-1.0.14/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, environment_name).stdout
+    end
+
+    # Returns the path to the env file
+    def env_path
+      rvm(:env, environment_name, :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/vendor/ruby/1.8/gems/rvm-1.0.14/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

data/vendor/ruby/1.8/gems/rvm-1.0.14/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/vendor/ruby/1.8/gems/rvm-1.0.14/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/vendor/ruby/1.8/gems/rvm-1.0.14/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