gemrage 0.0.0

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

@@ -0,0 +1,245 @@
+require 'bundler/dependency'
+
+module Bundler
+  class Dsl
+    def self.evaluate(gemfile)
+      builder = new
+      builder.instance_eval(Bundler.read_file(gemfile.to_s), gemfile.to_s, 1)
+      builder.to_definition
+    end
+
+    VALID_PLATFORMS = Bundler::Dependency::PLATFORM_MAP.keys.freeze
+
+    def initialize
+      @rubygems_source = Source::Rubygems.new
+      @source          = nil
+      @sources         = []
+      @dependencies    = []
+      @groups          = []
+      @platforms       = []
+      @env             = nil
+    end
+
+    def gemspec(opts = nil)
+      path              = opts && opts[:path] || '.'
+      name              = opts && opts[:name] || '*'
+      development_group = opts && opts[:development_group] || :development
+      path              = File.expand_path(path, Bundler.default_gemfile.dirname)
+      gemspecs = Dir[File.join(path, "#{name}.gemspec")]
+
+      case gemspecs.size
+      when 1
+        spec = Gem::Specification.load(gemspecs.first)
+        gem spec.name, :path => path
+        spec.runtime_dependencies.each do |dep|
+          gem dep.name, *dep.requirement.as_list
+        end
+        group(development_group) do
+          spec.development_dependencies.each do |dep|
+            gem dep.name, *dep.requirement.as_list
+          end
+        end
+      when 0
+        raise InvalidOption, "There are no gemspecs at #{path}."
+      else
+        raise InvalidOption, "There are multiple gemspecs at #{path}. Please use the :name option to specify which one."
+      end
+    end
+
+    def gem(name, *args)
+      if name.is_a?(Symbol)
+        raise GemfileError, %{You need to specify gem names as Strings. Use 'gem "#{name.to_s}"' instead.}
+      end
+
+      options = Hash === args.last ? args.pop : {}
+      version = args || [">= 0"]
+
+      _deprecated_options(options)
+      _normalize_options(name, version, options)
+
+      dep = Dependency.new(name, version, options)
+
+      if current = @dependencies.find { |d| d.name == dep.name }
+        if current.requirement != dep.requirement
+          raise DslError, "You cannot specify the same gem twice with different version requirements. " \
+                          "You specified: #{current.name} (#{current.requirement}) and " \
+                          "#{dep.name} (#{dep.requirement})"
+        end
+
+        if current.source != dep.source
+          raise DslError, "You cannot specify the same gem twice coming from different sources. You " \
+                          "specified that #{dep.name} (#{dep.requirement}) should come from " \
+                          "#{current.source || 'an unspecfied source'} and #{dep.source}"
+        end
+      end
+      @dependencies << Dependency.new(name, version, options)
+    end
+
+    def source(source, options = {})
+      case source
+      when :gemcutter, :rubygems, :rubyforge then
+        rubygems_source "http://rubygems.org"
+        return
+      when String
+        rubygems_source source
+        return
+      end
+
+      @source = source
+      options[:prepend] ? @sources.unshift(@source) : @sources << @source
+
+      yield if block_given?
+      @source
+    ensure
+      @source = nil
+    end
+
+    def path(path, options = {}, source_options = {}, &blk)
+      source Source::Path.new(_normalize_hash(options).merge("path" => Pathname.new(path))), source_options, &blk
+    end
+
+    def git(uri, options = {}, source_options = {}, &blk)
+      unless block_given?
+        msg = "You can no longer specify a git source by itself. Instead, \n" \
+              "either use the :git option on a gem, or specify the gems that \n" \
+              "bundler should find in the git source by passing a block to \n" \
+              "the git method, like: \n\n" \
+              "  git 'git://github.com/rails/rails.git' do\n" \
+              "    gem 'rails'\n" \
+              "  end"
+        raise DeprecatedError, msg
+      end
+
+      source Source::Git.new(_normalize_hash(options).merge("uri" => uri)), source_options, &blk
+    end
+
+    def to_definition(lockfile, unlock)
+      @sources << @rubygems_source
+      @sources.uniq!
+      Definition.new(lockfile, @dependencies, @sources, unlock)
+    end
+
+    def group(*args, &blk)
+      @groups.concat args
+      yield
+    ensure
+      args.each { @groups.pop }
+    end
+
+    def platforms(*platforms)
+      @platforms.concat platforms
+      yield
+    ensure
+      platforms.each { @platforms.pop }
+    end
+    alias_method :platform, :platforms
+
+    def env(name)
+      @env, old = name, @env
+      yield
+    ensure
+      @env = old
+    end
+
+    # Deprecated methods
+
+    def self.deprecate(name, replacement = nil)
+      define_method(name) do |*|
+        message = "'#{name}' has been removed from the Gemfile DSL, "
+        if replacement
+          message << "and has been replaced with '#{replacement}'."
+        else
+          message << "and is no longer supported."
+        end
+        message << "\nSee the README for more information on upgrading from Bundler 0.8."
+        raise DeprecatedError, message
+      end
+    end
+
+    deprecate :only, :group
+    deprecate :except
+    deprecate :disable_system_gems
+    deprecate :disable_rubygems
+    deprecate :clear_sources
+    deprecate :bundle_path
+    deprecate :bin_path
+
+  private
+
+    def rubygems_source(source)
+      @rubygems_source.add_remote source
+      @sources << @rubygems_source
+    end
+
+    def _normalize_hash(opts)
+      # Cannot modify a hash during an iteration in 1.9
+      opts.keys.each do |k|
+        next if String === k
+        v = opts[k]
+        opts.delete(k)
+        opts[k.to_s] = v
+      end
+      opts
+    end
+
+    def _normalize_options(name, version, opts)
+      _normalize_hash(opts)
+
+      invalid_keys = opts.keys - %w(group groups git path name branch ref tag require submodules platform platforms)
+      if invalid_keys.any?
+        plural = invalid_keys.size > 1
+        message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
+        if plural
+          message << "as options for gem '#{name}', but they are invalid."
+        else
+          message << "as an option for gem '#{name}', but it is invalid."
+        end
+        raise InvalidOption, message
+      end
+
+      groups = @groups.dup
+      opts["group"] = opts.delete("groups") || opts["group"]
+      groups.concat Array(opts.delete("group"))
+      groups = [:default] if groups.empty?
+
+      platforms = @platforms.dup
+      opts["platforms"] = opts["platform"] || opts["platforms"]
+      platforms.concat Array(opts.delete("platforms"))
+      platforms.map! { |p| p.to_sym }
+      platforms.each do |p|
+        next if VALID_PLATFORMS.include?(p)
+        raise DslError, "`#{p}` is not a valid platform. The available options are: #{VALID_PLATFORMS.inspect}"
+      end
+
+      # Normalize git and path options
+      ["git", "path"].each do |type|
+        if param = opts[type]
+          if version.first && version.first =~ /^\s*=?\s*(\d[^\s]*)\s*$/
+            options = opts.merge("name" => name, "version" => $1)
+          else
+            options = opts.dup
+          end
+          source = send(type, param, options, :prepend => true) {}
+          opts["source"] = source
+        end
+      end
+
+      opts["source"]  ||= @source
+      opts["env"]     ||= @env
+      opts["platforms"] = platforms.dup
+      opts["group"]     = groups
+    end
+
+    def _deprecated_options(options)
+      if options.include?(:require_as)
+        raise DeprecatedError, "Please replace :require_as with :require"
+      elsif options.include?(:vendored_at)
+        raise DeprecatedError, "Please replace :vendored_at with :path"
+      elsif options.include?(:only)
+        raise DeprecatedError, "Please replace :only with :group"
+      elsif options.include?(:except)
+        raise DeprecatedError, "The :except option is no longer supported"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Bundler
+  class Environment
+    attr_reader :root
+
+    def initialize(root, definition)
+      @root = root
+      @definition = definition
+
+      env_file = Bundler.app_config_path.join('environment.rb')
+      env_file.rmtree if env_file.exist?
+    end
+
+    def inspect
+      @definition.to_lock.inspect
+    end
+
+    # TODO: Remove this method. It's used in cli.rb still
+    def index
+      @definition.index
+    end
+
+    def requested_specs
+      @definition.requested_specs
+    end
+
+    def specs
+      @definition.specs
+    end
+
+    def dependencies
+      @definition.dependencies
+    end
+
+    def current_dependencies
+      @definition.current_dependencies
+    end
+
+    def lock
+      @definition.lock(Bundler.default_lockfile)
+    end
+
+    def update(*gems)
+      # Nothing
+    end
+
+  end
+end

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

@@ -0,0 +1,148 @@
+$:.unshift File.expand_path('../vendor', __FILE__)
+require 'open3'
+require 'thor'
+require 'bundler'
+
+module Bundler
+  class GemHelper
+    def self.install_tasks(opts = nil)
+      dir = caller.find{|c| /Rakefile:/}[/^(.*?)\/Rakefile:/, 1]
+      self.new(dir, opts && opts[:name]).install
+    end
+
+    attr_reader :spec_path, :base, :gemspec
+
+    def initialize(base, name = nil)
+      Bundler.ui = UI::Shell.new(Thor::Shell::Color.new)
+      @base = base
+      gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "*.gemspec")]
+      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
+      @spec_path = gemspecs.first
+      @gemspec = Bundler.load_gemspec(@spec_path)
+    end
+
+    def install
+      desc "Build #{name}-#{version}.gem into the pkg directory"
+      task 'build' do
+        build_gem
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems"
+      task 'install' do
+        install_gem
+      end
+
+      desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to Rubygems"
+      task 'release' do
+        release_gem
+      end
+    end
+
+    def build_gem
+      file_name = nil
+      sh("gem build #{spec_path}") { |out, err|
+        raise err if !out[/Successfully/]
+        file_name = File.basename(built_gem_path)
+        FileUtils.mkdir_p(File.join(base, 'pkg'))
+        FileUtils.mv(built_gem_path, 'pkg')
+        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}"
+      }
+      File.join(base, 'pkg', file_name)
+    end
+
+    def install_gem
+      built_gem_path = build_gem
+      out, err, code = sh_with_code("gem install #{built_gem_path}")
+      raise err if err[/ERROR/]
+      Bundler.ui.confirm "#{name} (#{version}) installed"
+    end
+
+    def release_gem
+      guard_clean
+      guard_already_tagged
+      built_gem_path = build_gem
+      tag_version {
+        git_push
+        rubygem_push(built_gem_path)
+      }
+    end
+
+    protected
+    def rubygem_push(path)
+      sh("gem push #{path}")
+      Bundler.ui.confirm "Pushed #{name} #{version} to rubygems.org"
+    end
+
+    def built_gem_path
+      Dir[File.join(base, "#{name}-*.gem")].sort_by{|f| File.mtime(f)}.last
+    end
+
+    def git_push
+      perform_git_push
+      perform_git_push ' --tags'
+      Bundler.ui.confirm "Pushed git commits and tags"
+    end
+
+    def perform_git_push(options = '')
+      out, err, code = sh_with_code "git push --quiet#{options}"
+      raise err unless err == ''
+    end
+
+    def guard_already_tagged
+      if sh('git tag').split(/\n/).include?(version_tag)
+        raise("This tag has already been committed to the repo.")
+      end
+    end
+
+    def guard_clean
+      clean? or raise("There are files that need to be committed first.")
+    end
+
+    def clean?
+      sh("git ls-files -dm").split("\n").size.zero?
+    end
+
+    def tag_version
+      sh "git tag -am 'Version #{version}' #{version_tag}"
+      Bundler.ui.confirm "Tagged #{tagged_sha} with #{version_tag}"
+      yield if block_given?
+    rescue
+      Bundler.ui.error "Untagged #{tagged_sha} with #{version_tag} due to error"
+      sh "git tag -d #{version_tag}"
+      raise
+    end
+
+    def tagged_sha
+      sh("git show-ref --tags #{version_tag}").split(' ').first[0, 8]
+    end
+
+    def version
+      gemspec.version
+    end
+
+    def version_tag
+      "v#{version}"
+    end
+
+    def name
+      gemspec.name
+    end
+
+    def sh(cmd, &block)
+      out, err, code = sh_with_code(cmd, &block)
+      code == 0 ? out : raise(out.empty? ? err : out)
+    end
+
+    def sh_with_code(cmd, &block)
+      outbuf, errbuf = '', ''
+      Dir.chdir(base) {
+        stdin, stdout, stderr = *Open3.popen3(cmd)
+        if $? == 0
+          outbuf, errbuf = stdout.read, stderr.read
+          block.call(outbuf, errbuf) if block
+        end
+      }
+      [outbuf, errbuf, $?]
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Bundler
+  class Graph
+
+    USER_OPTIONS = {:style => 'filled', :fillcolor => '#B9B9D5'}.freeze
+
+    def initialize(env)
+      @env = env
+    end
+
+    def nodes
+      populate
+      @nodes
+    end
+
+    def groups
+      populate
+      @groups
+    end
+
+    def viz(output_file, show_gem_versions = false, show_dependency_requirements = false)
+      require 'graphviz'
+      populate
+
+      graph_viz = GraphViz::new('Gemfile', {:concentrate => true, :normalize => true, :nodesep => 0.55})
+      graph_viz.edge[:fontname] = graph_viz.node[:fontname] = 'Arial, Helvetica, SansSerif'
+      graph_viz.edge[:fontsize] = 12
+
+      viz_nodes = {}
+
+      # populate all of the nodes
+      nodes.each do |name, node|
+        label = name.dup
+        label << "\n#{node.version}" if show_gem_versions
+        options = { :label => label }
+        options.merge!( USER_OPTIONS ) if node.is_user
+        viz_nodes[name] = graph_viz.add_node( name, options )
+      end
+
+      group_nodes = {}
+      @groups.each do |name, dependencies|
+        group_nodes[name] = graph_viz.add_node(name.to_s, { :shape => 'box3d', :fontsize => 16 }.merge(USER_OPTIONS))
+        dependencies.each do |dependency|
+          options = { :weight => 2 }
+          if show_dependency_requirements && (dependency.requirement.to_s != ">= 0")
+            options[:label] = dependency.requirement.to_s
+          end
+          graph_viz.add_edge( group_nodes[name], viz_nodes[dependency.name], options )
+        end
+      end
+
+      @groups.keys.select { |group| group != :default }.each do |group|
+        graph_viz.add_edge( group_nodes[group], group_nodes[:default], { :weight => 2 } )
+      end
+
+      viz_nodes.each do |name, node|
+        nodes[name].dependencies.each do |dependency|
+          options = { }
+          if nodes[dependency.name].is_user
+            options[:constraint] = false
+          end
+          if show_dependency_requirements && (dependency.requirement.to_s != ">= 0")
+            options[:label] = dependency.requirement.to_s
+          end
+
+          graph_viz.add_edge( node, viz_nodes[dependency.name], options )
+        end
+      end
+
+      graph_viz.output( :png => output_file )
+    end
+
+    private
+
+    def populate
+      return if @populated
+
+      # hash of name => GraphNode
+      @nodes = {}
+      @groups = {}
+
+      # Populate @nodes
+      @env.specs.each { |spec| @nodes[spec.name] = GraphNode.new(spec.name, spec.version) }
+
+      # For gems in Gemfile, add details
+      @env.current_dependencies.each do |dependency|
+        node = @nodes[dependency.name]
+        node.is_user = true
+
+        dependency.groups.each do |group|
+          if @groups.has_key? group
+            group = @groups[group]
+          else
+            group = @groups[group] = []
+          end
+          group << dependency
+        end
+      end
+
+      # walk though a final time and add edges
+      @env.specs.each do |spec|
+
+        from = @nodes[spec.name]
+        spec.runtime_dependencies.each do |dependency|
+          from.dependencies << dependency
+        end
+
+      end
+
+      @nodes.freeze
+      @groups.freeze
+      @populated = true
+    end
+
+  end
+
+  # Add version info
+  class GraphNode
+
+    def initialize(name, version)
+      @name = name
+      @version = version
+      @is_user = false
+      @dependencies = []
+    end
+
+    attr_reader :name, :dependencies, :version
+    attr_accessor :is_user
+
+  end
+end

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

@@ -0,0 +1,114 @@
+module Bundler
+  class Index
+    include Enumerable
+
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    def initialize
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def initialize_copy(o)
+      super
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+      merge!(o)
+    end
+
+    def empty?
+      each { return false }
+      true
+    end
+
+    def search(query)
+      case query
+      when Gem::Specification, RemoteSpecification, LazySpecification then search_by_spec(query)
+      when String then @specs[query]
+      else search_by_dependency(query)
+      end
+    end
+
+    def search_for_all_platforms(dependency, base = [])
+      specs = @specs[dependency.name] + base
+
+      wants_prerelease = dependency.requirement.prerelease?
+      only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+      found = specs.select { |spec| dependency =~ spec }
+
+      unless wants_prerelease || only_prerelease
+        found.reject! { |spec| spec.version.prerelease? }
+      end
+
+      found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
+    end
+
+    def sources
+      @specs.values.map do |specs|
+        specs.map{|s| s.source.class }
+      end.flatten.uniq
+    end
+
+    alias [] search
+
+    def <<(spec)
+      arr = @specs[spec.name]
+
+      arr.delete_if do |s|
+        s.version == spec.version && s.platform == spec.platform
+      end
+
+      arr << spec
+      spec
+    end
+
+    def each(&blk)
+      @specs.values.each do |specs|
+        specs.each(&blk)
+      end
+    end
+
+    def use(other)
+      return unless other
+      other.each do |s|
+        next if search_by_spec(s).any?
+        @specs[s.name] << s
+      end
+      self
+    end
+
+    def ==(o)
+      all? do |s|
+        s2 = o[s].first and (s.dependencies & s2.dependencies).empty?
+      end
+    end
+
+  private
+
+    def search_by_spec(spec)
+      @specs[spec.name].select do |s|
+        s.version == spec.version && Gem::Platform.new(s.platform) == Gem::Platform.new(spec.platform)
+      end
+    end
+
+    def search_by_dependency(dependency)
+      @cache[dependency.hash] ||= begin
+        specs = @specs[dependency.name]
+
+        wants_prerelease = dependency.requirement.prerelease?
+        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+        found = specs.select { |spec| dependency =~ spec && Gem::Platform.match(spec.platform) }
+
+        unless wants_prerelease || only_prerelease
+          found.reject! { |spec| spec.version.prerelease? }
+        end
+
+        found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
+      end
+    end
+  end
+end