gemrage 0.0.0

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/vendor/thor.rb

@@ -0,0 +1,319 @@
+require 'thor/base'
+
+class Thor
+  class << self
+    # Sets the default task when thor is executed without an explicit task to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the defaut task
+    #
+    def default_task(meth=nil)
+      case meth
+        when :none
+          @default_task = 'help'
+        when nil
+          @default_task ||= from_superclass(:default_task, 'help')
+        else
+          @default_task = meth.to_s
+      end
+    end
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    def desc(usage, description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.usage = usage             if usage
+        task.description = description if description
+      else
+        @usage, @desc, @hide = usage, description, options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next task.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.long_description = long_description if long_description
+      else
+        @long_desc = long_description
+      end
+    end
+
+    # Maps an input to a task. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list task.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
+    #
+    def map(mappings=nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each {|subkey| @map[subkey] = value}
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next task to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options=nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined task.
+    #
+    #   def previous_task
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_task
+    #
+    #   def next_task
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    #
+    def method_option(name, options={})
+      scope = if options[:for]
+        find_and_refresh_task(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+
+    # Prints help information for the given task.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      meth = normalize_task_name(task_name)
+      task = all_tasks[meth]
+      handle_no_task_error(meth) unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      if task.long_description
+        shell.say "Description:"
+        shell.print_wrapped(task.long_description, :ident => 2)
+      else
+        shell.say task.description
+      end
+    end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell, subcommand = false)
+      list = printable_tasks(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_tasks(false)
+      end
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      shell.say "Tasks:"
+      shell.print_table(list, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(all = true, subcommand = false)
+      (all ? all_tasks : tasks).map do |_, task|
+        next if task.hidden?
+        item = []
+        item << banner(task, false, subcommand)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
+      end.compact
+    end
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      self.subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      define_method(subcommand) { |*args| invoke subcommand_class, args }
+    end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options={})
+      @check_unknown_options ||= Hash.new
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      task = config[:current_task]
+      return true unless task
+
+      name = task.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    protected
+
+      # The method responsible for dispatching given the args.
+      def dispatch(meth, given_args, given_opts, config) #:nodoc:
+        meth ||= retrieve_task_name(given_args)
+        task = all_tasks[normalize_task_name(meth)]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+        else
+          args, opts = given_args, nil
+          task = Thor::DynamicTask.new(meth)
+        end
+
+        opts = given_opts || opts || []
+        config.merge!(:current_task => task, :task_options => task.options)
+
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke_task(task, trailing || [])
+      end
+
+      # The banner for this class. You can customize it if you are invoking the
+      # thor class by another ways which is not the Thor::Runner. It receives
+      # the task that is going to be invoked and a boolean which indicates if
+      # the namespace should be displayed as arguments.
+      #
+      def banner(task, namespace = nil, subcommand = false)
+        base = File.basename($0).split(" ").first
+        "#{base} #{task.formatted_usage(self, $thor_runner, subcommand)}"
+      end
+
+      def baseclass #:nodoc:
+        Thor
+      end
+
+      def create_task(meth) #:nodoc:
+        if @usage && @desc
+          base_class = @hide ? Thor::HiddenTask : Thor::Task
+          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          @usage, @desc, @long_desc, @method_options, @hide = nil
+          true
+        elsif self.all_tasks[meth] || meth == "method_missing"
+          true
+        else
+          puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
+               "Call desc if you want this method to be available as task or declare it inside a " <<
+               "no_tasks{} block. Invoked from #{caller[1].inspect}."
+          false
+        end
+      end
+
+      def initialize_added #:nodoc:
+        class_options.merge!(method_options)
+        @method_options = nil
+      end
+
+      # Retrieve the task name from given args.
+      def retrieve_task_name(args) #:nodoc:
+        meth = args.first.to_s unless args.empty?
+
+        if meth && (map[meth] || meth !~ /^\-/)
+          args.shift
+        else
+          nil
+        end
+      end
+
+      # Receives a task name (can be nil), and try to get a map from it.
+      # If a map can't be found use the sent name or the default task.
+      def normalize_task_name(meth) #:nodoc:
+        meth = map[meth.to_s] || meth || default_task
+        meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
+      end
+
+      def subcommand_help(cmd)
+        desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+        class_eval <<-RUBY
+          def help(task = nil, subcommand = true); super; end
+        RUBY
+      end
+
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [TASK]", "Describe available tasks or one specific task"
+  def help(task = nil, subcommand = false)
+    task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
+  end
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/version.rb

@@ -0,0 +1,6 @@
+module Bundler
+  # We're doing this because we might write tests that deal
+  # with other versions of bundler and we are unsure how to
+  # handle this better.
+  VERSION = "1.0.3" unless defined?(::Bundler::VERSION)
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/vlad.rb

@@ -0,0 +1,9 @@
+# Vlad task for Bundler.
+#
+# Just add "require 'bundler/vlad'" in your Vlad deploy.rb, and
+# Bundler will be activated after each new deployment.
+require 'bundler/deployment'
+
+namespace :vlad do
+  Bundler::Deployment.define_task(Rake::RemoteTask, :remote_task, :roles => :app)
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler.rb

@@ -0,0 +1,284 @@
+require 'rbconfig'
+require 'fileutils'
+require 'pathname'
+require 'yaml'
+require 'bundler/rubygems_ext'
+require 'bundler/version'
+
+module Bundler
+  ORIGINAL_ENV = ENV.to_hash
+
+  autoload :Definition,          'bundler/definition'
+  autoload :Dependency,          'bundler/dependency'
+  autoload :Dsl,                 'bundler/dsl'
+  autoload :Environment,         'bundler/environment'
+  autoload :GemHelper,           'bundler/gem_helper'
+  autoload :Graph,               'bundler/graph'
+  autoload :Index,               'bundler/index'
+  autoload :Installer,           'bundler/installer'
+  autoload :LazySpecification,   'bundler/lazy_specification'
+  autoload :LockfileParser,      'bundler/lockfile_parser'
+  autoload :RemoteSpecification, 'bundler/remote_specification'
+  autoload :Resolver,            'bundler/resolver'
+  autoload :Runtime,             'bundler/runtime'
+  autoload :Settings,            'bundler/settings'
+  autoload :SharedHelpers,       'bundler/shared_helpers'
+  autoload :SpecSet,             'bundler/spec_set'
+  autoload :Source,              'bundler/source'
+  autoload :Specification,       'bundler/shared_helpers'
+  autoload :UI,                  'bundler/ui'
+
+  class BundlerError < StandardError
+    def self.status_code(code = nil)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class GemfileNotFound  < BundlerError; status_code(10) ; end
+  class GemNotFound      < BundlerError; status_code(7)  ; end
+  class GemfileError     < BundlerError; status_code(4)  ; end
+  class PathError        < BundlerError; status_code(13) ; end
+  class GitError         < BundlerError; status_code(11) ; end
+  class DeprecatedError  < BundlerError; status_code(12) ; end
+  class GemspecError     < BundlerError; status_code(14) ; end
+  class DslError         < BundlerError; status_code(15) ; end
+  class ProductionError  < BundlerError; status_code(16) ; end
+  class InvalidOption    < DslError                      ; end
+
+
+  WINDOWS = RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!
+  NULL    = WINDOWS ? "NUL" : "/dev/null"
+
+
+  class VersionConflict  < BundlerError
+    attr_reader :conflicts
+
+    def initialize(conflicts, msg = nil)
+      super(msg)
+      @conflicts = conflicts
+    end
+
+    status_code(6)
+  end
+
+  # Internal errors, should be rescued
+  class InvalidSpecSet < StandardError; end
+
+  class << self
+    attr_writer :ui, :bundle_path
+
+    def configure
+      @configured ||= begin
+        configure_gem_home_and_path
+        true
+      end
+    end
+
+    def ui
+      @ui ||= UI.new
+    end
+
+    def bundle_path
+      # STDERR.puts settings.path
+      @bundle_path ||= Pathname.new(settings.path).expand_path(root)
+    end
+
+    def bin_path
+      @bin_path ||= begin
+        path = settings[:bin] || "bin"
+        path = Pathname.new(path).expand_path(root)
+        FileUtils.mkdir_p(path)
+        Pathname.new(path).expand_path
+      end
+    end
+
+    def setup(*groups)
+      return @setup if defined?(@setup) && @setup
+
+      if groups.empty?
+        # Load all groups, but only once
+        @setup = load.setup
+      else
+        # Figure out which groups haven't been loaded yet
+        unloaded = groups - (@completed_groups || [])
+        # Record groups that are now loaded
+        @completed_groups = groups | (@completed_groups || [])
+        # Load any groups that are not yet loaded
+        unloaded.any? ? load.setup(*unloaded) : load
+      end
+    end
+
+    def require(*groups)
+      setup(*groups).require(*groups)
+    end
+
+    def load
+      @load ||= Runtime.new(root, definition)
+    end
+
+    def environment
+      Bundler::Environment.new(root, definition)
+    end
+
+    def definition(unlock = nil)
+      @definition = nil if unlock
+      @definition ||= begin
+        configure
+        upgrade_lockfile
+        Definition.build(default_gemfile, default_lockfile, unlock)
+      end
+    end
+
+    def ruby_scope
+      "#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}"
+    end
+
+    def user_bundle_path
+      Pathname.new(Gem.user_home).join(".bundler")
+    end
+
+    def home
+      bundle_path.join("bundler")
+    end
+
+    def install_path
+      home.join("gems")
+    end
+
+    def specs_path
+      bundle_path.join("specifications")
+    end
+
+    def cache
+      bundle_path.join("cache/bundler")
+    end
+
+    def root
+      default_gemfile.dirname.expand_path
+    end
+
+    def app_config_path
+      ENV['BUNDLE_APP_CONFIG'] ?
+        Pathname.new(ENV['BUNDLE_APP_CONFIG']).expand_path(root) :
+        root.join('.bundle')
+    end
+
+    def app_cache
+      root.join("vendor/cache")
+    end
+
+    def tmp
+      user_bundle_path.join("tmp", Process.pid.to_s)
+    end
+
+    def settings
+      @settings ||= Settings.new(app_config_path)
+    end
+
+    def with_clean_env
+      bundled_env = ENV.to_hash
+      ENV.replace(ORIGINAL_ENV)
+      yield
+    ensure
+      ENV.replace(bundled_env.to_hash)
+    end
+
+    def default_gemfile
+      SharedHelpers.default_gemfile
+    end
+
+    def default_lockfile
+      SharedHelpers.default_lockfile
+    end
+
+    def requires_sudo?
+      path = bundle_path
+      path = path.parent until path.exist?
+      sudo_present = !`which sudo 2>#{NULL}`.empty?
+
+      settings.allow_sudo? && !File.writable?(path) && sudo_present
+    end
+
+    def mkdir_p(path)
+      if requires_sudo?
+        sudo "mkdir -p '#{path}'" unless File.exist?(path)
+      else
+        FileUtils.mkdir_p(path)
+      end
+    end
+
+    def sudo(str)
+      `sudo -p 'Enter your password to install the bundled RubyGems to your system: ' #{str}`
+    end
+
+    def read_file(file)
+      File.open(file, "rb") { |f| f.read }
+    end
+
+    def load_gemspec(file)
+      path = Pathname.new(file)
+      # Eval the gemspec from its parent directory
+      Dir.chdir(path.dirname) do
+        begin
+          Gem::Specification.from_yaml(path.basename)
+          # Raises ArgumentError if the file is not valid YAML
+        rescue ArgumentError, SyntaxError, Gem::EndOfYAMLException, Gem::Exception
+          begin
+            eval(File.read(path.basename), TOPLEVEL_BINDING, path.expand_path.to_s)
+          rescue LoadError => e
+            original_line = e.backtrace.find { |line| line.include?(path.to_s) }
+            msg  = "There was a LoadError while evaluating #{path.basename}:\n  #{e.message}"
+            msg << " from\n  #{original_line}" if original_line
+            msg << "\n"
+
+            if RUBY_VERSION >= "1.9.0"
+              msg << "\nDoes it try to require a relative path? That doesn't work in Ruby 1.9."
+            end
+
+            raise GemspecError, msg
+          end
+        end
+      end
+    end
+
+  private
+
+    def configure_gem_home_and_path
+      if settings[:disable_shared_gems]
+        ENV['GEM_PATH'] = ''
+        ENV['GEM_HOME'] = File.expand_path(bundle_path, root)
+      elsif Gem.dir != bundle_path.to_s
+        paths = [Gem.dir, Gem.path].flatten.compact.uniq.reject{|p| p.empty? }
+        ENV["GEM_PATH"] = paths.join(File::PATH_SEPARATOR)
+        ENV["GEM_HOME"] = bundle_path.to_s
+      end
+
+      FileUtils.mkdir_p bundle_path.to_s
+      Gem.clear_paths
+    end
+
+    def upgrade_lockfile
+      lockfile = default_lockfile
+      if lockfile.exist? && lockfile.read(3) == "---"
+        Bundler.ui.warn "Detected Gemfile.lock generated by 0.9, deleting..."
+        lockfile.rmtree
+        # lock = YAML.load_file(lockfile)
+        #
+        # source_uris = lock["sources"].map{|s| s["Rubygems"]["uri"] }
+        # sources = [Bundler::Source::Rubygems.new({"remotes" => source_uris})]
+        #
+        # deps = lock["dependencies"].map do |name, opts|
+        #   version = opts.delete("version")
+        #   Bundler::Dependency.new(name, version, opts)
+        # end
+        #
+        # definition = Bundler::Definition.new(nil, deps, sources, {})
+        #
+        # File.open(lockfile, 'w') do |f|
+        #   f.write definition.to_lock
+        # end
+      end
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/man/bundle-config.ronn

@@ -0,0 +1,90 @@
+bundle-config(1) -- Set bundler configuration options
+=====================================================
+
+## SYNOPSIS
+
+`bundle config` [<name> [<value>]]
+
+## DESCRIPTION
+
+This command allows you to interact with bundler's configuration system.
+Bundler retrieves its configuration from the local application (`app/.bundle/config`),
+environment variables, and the user's home directory (`~/.bundle/config`),
+in that order of priority.
+
+Executing `bundle config` with no parameters will print a list of all
+bundler configuration for the current bundle, and where that configuration
+was set.
+
+Executing `bundle config <name>` will print the value of that configuration
+setting, and where it was set.
+
+Executing `bundle config <name> <value>` will set that configuration to the
+value specified for all bundles executed as the current user. The configuration
+will be stored in `~/.bundle/config`.
+
+## BUILD OPTIONS
+
+You can use `bundle config` to give bundler the flags to pass to the gem
+installer every time bundler tries to install a particular gem.
+
+A very common example, the `mysql` gem, requires Snow Leopard users to
+pass configuration flags to `gem install` to specify where to find the
+`mysql_config` executable.
+
+    gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config
+
+Since the specific location of that executable can change from machine
+to machine, you can specify these flags on a per-machine basis.
+
+    bundle config build.mysql --with-mysql-config=/usr/local/mysql/bin/mysql_config
+
+After running this command, every time bundler needs to install the
+`mysql` gem, it will pass along the flags you specified.
+
+## CONFIGURATION KEYS
+
+Configuration keys in bundler have two forms: the canonical form and the
+environment variable form.
+
+For instance, passing the `--without` flag to [bundle install(1)][bundle-install]
+prevents Bundler from installing certain groups specified in the Gemfile(5). Bundler
+persists this value in `app/.bundle/config` so that calls to `Bundler.setup`
+do not try to find gems from the `Gemfile` that you didn't install. Additionally,
+subsequent calls to [bundle install(1)][bundle-install] remember this setting and skip those
+groups.
+
+The canonical form of this configuration is `"without"`. To convert the canonical
+form to the environment variable form, capitalize it, and prepend `BUNDLE_`. The
+environment variable form of `"without"` is `BUNDLE_WITHOUT`.
+
+## LIST OF AVAILABLE KEYS
+
+The following is a list of all configuration keys and their purpose. You can
+learn more about their operation in [bundle install(1)][bundle-install].
+
+* `path` (`BUNDLE_PATH`):
+  The location on disk to install gems. Defaults to `$GEM_HOME` in development
+  and `vendor/bundler` when `--deployment` is used
+* `frozen` (`BUNDLE_FROZEN`):
+  Disallow changes to the `Gemfile`. Defaults to `true` when `--deployment`
+  is used.
+* `without` (`BUNDLE_WITHOUT`):
+  A `:`-separated list of groups whose gems bundler should not install
+* `bin` (`BUNDLE_BIN`):
+  Install executables from gems in the bundle to the specified directory.
+  Defaults to `false`.
+* `gemfile` (`BUNDLE_GEMFILE`):
+  The name of the file that bundler should use as the `Gemfile`. This location
+  of this file also sets the root of the project, which is used to resolve
+  relative paths in the `Gemfile`, among other things. By default, bundler
+  will search up from the current working directory until it finds a
+  `Gemfile`.
+
+In general, you should set these settings per-application by using the applicable
+flag to the [bundle install(1)][bundle-install] command.
+
+You can set them globally either via environment variables or `bundle config`,
+whichever is preferable for your setup. If you use both, environment variables
+will take preference over global settings.
+