g-gem 0.1.0

data/bin/g-gem

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+begin
+  require 'g-gem'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'g-gem'
+end
+
+Gem.manage_gems
+Gem::CommandManager.wave_all_with_portage
+load %w{
+/bin/gem
+/usr/bin/gem
+/usr/local/bin/gem
+}.find { |f| File.executable?(f) }

data/lib/g-gem.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+Gem.manage_gems
+%w{
+g-gem/core_extensions
+g-gem/spec_fetcher
+g-gem/utils
+g-gem/ebuild
+g-gem/command
+g-gem/portage_commands
+g-gem/gems_extensions
+g-gem/gems_commands_with_portage
+}.map { |f| require f }

data/lib/g-gem/command.rb

@@ -0,0 +1,150 @@
+module Gem::Portage
+  class Command < Gem::Command
+
+    def initialize(command, summary=nil, defaults=nil)
+      super(command, summary, defaults || {})
+      options_defaults = {}
+      class_command_options.each_pair do |k, option|
+        add_option(*option.optparse_args, &option.handler)
+        options_defaults[option.opt_id] = option.default unless option.default.nil?
+        extend option.module
+      end
+      self.defaults = options_defaults unless defaults
+    end
+
+    def defaults_str
+      defaults.keys.inject("") do |str, opt|
+        str + " " + class_command_options[opt].to_s
+      end
+    end
+
+    def register
+      command_manager.register_command self
+    end
+
+    def class_command_options(*args, &prc)
+      self.class.class_command_options(*args, &prc)
+    end
+
+    class << self
+      def has_option(id, *getopt_args, &handler)
+        option =  Option.new(id, *getopt_args, &handler)
+        class_command_options[option.opt_id] = option
+      end
+
+      def has_options_from(other, *opts)
+        defaults = Hash === opts.last ? opts.pop : {}
+        borrowed = opts.empty? ? other.class_command_options.keys : opts + defaults.keys
+        borrowed.each do |key|
+          next unless key
+          opt = other.class_command_options[key].dup
+          opt.default = defaults[key] if defaults.has_key? key
+          class_command_options[opt.opt_id] = opt
+        end
+      end
+
+      def register
+        new.register
+      end
+
+      def class_command_options
+        @command_options ||= if superclass.respond_to?(:class_command_options) 
+                               superclass.class_command_options.dup
+                             else
+                               {}
+                             end
+      end
+    end
+
+  end # class Command
+
+  class Command::Option
+    def initialize(sym, *optparse, &handler)
+      /[?=]?$/ === sym.to_s
+      @id = $`.to_sym 
+      @opt_id = $`.to_sym # $`.gsub('_','-').to_sym
+      @type = $&[0] if $&
+      @opts = Hash === optparse.last ? optparse.pop : {}
+      @optparse_args = optparse
+      long
+      @handler ||= lambda {|v, h| h[@opt_id] = v} 
+    end
+    
+    attr_reader :id, :opt_id, :handler
+    def boolean?
+      @type == ?? || default == true || default == false || !@opts[:boolean].nil?
+    end
+
+    def has_arg?
+      @type == ?= || !arg_name.nil?
+    end
+
+    def arg_name
+      @opts[:arg_name]
+    end
+
+    def default
+      return @default if not @default.nil?
+      def_name = @opts.keys.detect { |k| /^default(_(\S+))?/ === k.to_s }
+      @opts[:arg_name] = $2.upcase if $2 && arg_name.nil?
+      @default = @opts[def_name]
+    end
+
+    def long
+      return @long if @long
+      re = /^--(\[no-\])?(\S+)(\s+\[?([^\]\s]+))?/
+      long = @optparse_args.detect(@opts[:long]) { |a| re === a }
+      if long.to_s =~ re
+        @opt_id = $2.to_sym 
+        @opts[:boolean] = true if $1
+        @opts[:arg_name] = $4 if $4
+        @long = long
+      else
+        @long = "--"
+        @long << "[no-]" if boolean?
+        @long << @opt_id.to_s
+        @long << " "+arg_name.to_s if has_arg?
+        @long
+      end
+    end
+
+    def optparse_args
+      ([long] + @optparse_args).uniq.reject { |o| o.nil? }
+    end
+
+    def to_s
+      str = "--"
+      str << "no-" if boolean? and not default
+      str << opt_id.to_s
+      str << case default
+             when TrueClass, FalseClass; ""
+             when Array; " "+default.join(",").inspect
+             when String; " "+default.inspect
+             end
+      str
+    end
+
+    def module
+      src = <<-READER
+           def #{id} 
+             options["#{opt_id}".intern]
+           end
+      READER
+      src << <<-QUESTION if boolean?
+           def #{id}?
+             return false if options["#{opt_id}".intern] == false
+             not options["#{opt_id}".intern].nil? 
+           end
+      QUESTION
+      src << <<-WRITER if has_arg?
+          def #{id}=(value)
+            options["#{opt_id}".intern] = value
+          end
+      WRITER
+      Module.new do 
+         module_eval src
+      end
+   end
+
+  end # class Command::Option
+ end # module Gem::Portage

data/lib/g-gem/core_extensions.rb

@@ -0,0 +1,39 @@
+class << ENV
+  def with(hash)
+      oldenv = {}
+      hash.each_pair do |key, val|
+        oldenv[key.to_sym], ENV[key.to_s] = ENV[key.to_s], val
+      end
+      yield
+      oldenv.each_pair do |key, val|
+        ENV[key.to_s] = val
+      end
+  end
+end
+
+class Object
+  def singleton_class
+    class << self; self; end
+  end
+  def singleton_eval(code=nil, filename=nil, lineno=nil, &block)
+    if code 
+      singleton_class.module_eval(code, 
+                                  *[filename, lineno].reject{ |n| n.nil? })
+    else
+      singleton_class.module_eval(&block)
+    end
+  end
+end
+
+class Class
+  def superclass
+    ancestors[1..-1].find {|a| Class === a}
+  end
+end
+
+class String
+  def head_indented
+    return self unless self =~ /^\s+/
+    self.gsub(/^\s{0,#{$&.length}}/, '')
+  end
+end

data/lib/g-gem/ebuild.rb

@@ -0,0 +1,292 @@
+module Gem::Portage
+  class Ebuild
+    portdir = Gem::Portage::Utils::ConfigFile.new[:RUBYGEMS_PORTDIR] || 
+      Gem::Portage::Utils::ConfigFile.new[:PORTDIR_OVERLAY]
+    if portdir and not (portdir = portdir.split(/\s+/)).empty?
+      portdir = portdir.detect { |s| s =~ /gems/ } || portdir.first
+    end
+
+    DEFAULT_PORTDIR = portdir || "/usr/local/portage"
+    DEFAULT_CATEGORY = Gem::Portage::Utils::ConfigFile.new[:RUBYGEMS_CATEGORY] || "dev-ruby"
+  end
+
+  class Ebuild
+
+    DEFAULT_INSTALL_DIR = ::Gem.dir
+
+    EXTENSION = ".ebuild"
+
+    COMMANDS = %w(help setup clean fetch digest unpack compile test
+                  preinst install postinst qmerge merge unmerge 
+                  prerm postrm config package rpm generate) 
+
+    class << self
+      alias_method :for, :new
+    end
+
+    require 'forwardable'
+    extend Forwardable
+
+    def_delegators :@spec, :name, :version, :date, :summary, :email, 
+                   :homepage, :rubyforge_project, :description, :local?, :remote?
+
+    attr_reader :spec, :file_path
+    attr_accessor :install_dir, :license, :portdir, :category
+
+    def initialize(spec, portdir=nil, category=nil)
+      @portdir = DEFAULT_PORTDIR
+      @category = DEFAULT_CATEGORY
+      @spec = spec
+    end
+
+    def file_path
+      File.expand_path(File.join(portdir, category, spec.name,
+                                 "#{spec.full_name}#{EXTENSION}"))
+    end
+
+    def dirname
+      File.dirname(file_path)
+    end
+
+    def basename(include_extension=true)
+      File.basename(file_path, (EXTENSION unless include_extension) )
+    end
+
+    def exists?
+      File.exists? file_path
+    end
+
+    def write
+      require 'fileutils'
+      dir = File.dirname(file_path)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      File.open(file_path, 'w') { |f| f.write(content) }
+    end
+    alias_method :generate, :write
+
+    def local_fetch_command
+      "cp -Lvgf --target-directory \${DISTDIR} \${URI}"
+    end
+
+    def local_gentoo_mirror
+      File.dirname(spec.fetched_from) if spec.local?
+    end
+
+    def execute(*commands)
+      raise "Invalid emerge command" unless (commands - COMMANDS).empty?
+      callcc do |c|
+        if spec.local?
+          ENV.with(:FETCHCOMMAND => local_fetch_command, 
+                   :GENTOO_MIRRORS => local_gentoo_mirror) do 
+            c.call
+          end
+        end
+      end
+      generate if commands.delete('generate')
+      raise "Missing #{file_path}" unless exists?
+      system("ebuild #{file_path} #{commands.join(' ')}") unless commands.empty?
+    end
+
+    def digest_file
+      File.join(dirname, "files", "digest-#{basename(false)}")
+    end
+
+    def src_uri
+      uri = spec.fetched_from if spec.respond_to? :fetched_from
+      case uri
+      when /gems.rubyforge.org/
+        "#{uri}/gems/#{spec.full_name}.gem"
+      else; uri
+      end
+    end
+
+    def gem_src
+      return spec.fetched_from if spec.local?
+      "${DISTDIR}/${P}"
+    end
+
+    def license
+      "Ruby | BSD | GPL-2"
+    end
+
+    def install_dir
+      @install_dir || DEFAULT_INSTALL_DIR
+    end
+
+    def keywords
+      Gem::Portage::Utils::ConfigFile[:ARCH]
+    end
+
+    def iuse
+      "#{'doc' if spec.has_rdoc}" 
+    end
+
+    def enable_test_phase
+      @test_phase = true
+    end
+
+    def disable_test_phase
+      @test_phase = false
+    end
+
+    def test_phase_enabled?
+      @test_phase
+    end
+
+    def gem_command_args
+      args = [] # %w(--no-portage)
+      args << "--test" if test_phase_enabled?
+      args.join(' ')
+    end
+
+    def depend
+      spec.dependencies.inject("virtual/ruby\ndev-ruby/rubygems") do |s, d|
+        s + "\n" + DependencyAtom.from_gem_dependency(d, category).to_s
+      end
+    end
+
+    def content
+      require 'date'
+      doc = (<<-EBUILD).head_indented
+      # Copyright 1999-#{Date.today.year} Gentoo Foundation
+      # Distributed under the terms of the GNU General Public License v2
+      #
+      # #{spec.full_name}.ebuild was auto-generated on #{Date.today}
+      # by g-gem and rubygems using a gemspec dated #{spec.date.to_s} from
+      # #{spec.fetched_from}
+      # 
+      inherit ruby gems
+      
+      DESCRIPTION=#{description.inspect}
+      
+      HOMEPAGE=#{homepage.inspect}
+
+      USERUBY="ruby18"
+      
+      SLOT="0"
+      
+      # Please see the homepage for licensing issues
+      # at it's current state g-gem cannot detect gemspec's license
+      LICENSE=#{license.inspect}
+      # Auto detected architecture keyword
+      # Modify this if you intend to distribute this ebuild to other architectures
+      KEYWORDS=#{keywords.inspect}
+      
+      IUSE=#{iuse.inspect}
+      # Dependencies obtained from the gemspec (only other gems)
+      DEPEND=#{depend.inspect.gsub('\n', "\n")}
+      
+      #{"# FETCHCOMMAND="+local_fetch_command.inspect if local?}
+      SRC_URI=#{src_uri.inspect}
+      
+      GEMSARGS=#{gem_command_args.inspect}
+      
+      gems_location() {
+         # Installation directory from the gem command
+         export GEMSDIR=#{install_dir.inspect}
+         # Actually gems.eclass unconditionally searches the gem in ${DISTDIR}
+         export GEM_SRC=#{gem_src.inspect}
+      }
+      
+      # TODO: support gems_src_compile for have-to-be-compiled gems
+      # TODO: support test stage for gems
+      
+      gems_src_install() {
+         gems_location
+         dodir ${GEMSDIR}
+         gem install ${GEM_SRC} -v ${PV} -l -i ${D}/${GEMSDIR} ${GEMSARGS} || die "gem install failed"
+         if [ -d ${D}/${GEMSDIR}/bin ] ; then
+            exeinto /usr/bin
+            for exe in ${D}/${GEMSDIR}/bin/* ; do
+                doexe ${exe}
+            done
+         fi
+      }
+      
+      EBUILD
+    end
+  end # class Ebuild
+end # module Gem::Portage
+
+
+module Gem::Portage
+  class DependencyAtom
+    
+    PREFIX_EXT_RE = /[!~]/
+    PREFIX_RE = /(>=|<=|<|>|=)/
+    CATEGORY_RE = /\w+-\w+/
+    POSTFIX_RE = /\*/
+    VERSION_RE = /(\d+(\.\d+)*)+/
+    VERSION_EXT_RE = /[a-z]?(_(alpha|beta|pre|rc|p)\d+)?/
+    PACKAGE_NAME_RE = /[a-zA-Z0-9_-]+/
+
+    attr_reader :package_name, :version, :version_ext, 
+                :prefix, :prefix_ext, :postfix, :origin
+    
+    def initialize(str)
+      @origin = str
+      @prefix_ext, str = $&, $' if /^#{PREFIX_EXT_RE}/ === str
+      @prefix, str = $&, $' if /^#{PREFIX_RE}/ === str
+      @category, str = $1, $' if /^(#{CATEGORY_RE})\// === str
+      @postfix, str = $&, $` if /#{POSTFIX_RE}$/ === str
+      @version, @version_ext, str = $1, $3, $` if /-#{VERSION_RE}(#{VERSION_EXT_RE})/ === str
+      raise "Invalid atom: #{@origin}" unless /^#{PACKAGE_NAME_RE}$/ === str
+      @package_name = $&
+    end
+    private :initialize
+
+    alias_method :name, :package_name
+    attr_accessor :category
+
+    def category
+      @category or Gem::Portage::Ebuild::DEFAULT_CATEGORY
+    end
+
+    ##
+    # FIXME: support other gentoo atom prefixes
+    ##
+    def gem_requirement
+      return Gem::Version::Requirement.default unless version
+      full_prefix = "#{prefix_ext}#{prefix}"
+      gem_prefix = if /^(~>|>|>=|=|!=|<=|<)$/ === full_prefix
+                     full_prefix
+                   elsif not prefix
+                     "="
+                   end
+      Gem::Version::Requirement.create(["#{gem_prefix} #{version}"])
+    end
+
+    def gem_dependency
+      Gem::Dependency.new(package_name, [gem_requirement.to_s])
+    end
+
+    def to_s
+      "#{prefix_ext}#{(prefix or "=") if version}#{category+"/" if category}#{package_name}"+
+        "#{"-"+version+version_ext if version}#{postfix}"
+    end
+
+    class << self
+      def from_s(str)
+        if str =~ /(.*\/)?(\S+)\.gem$/ # From gem file
+          atom = from_s($2)
+          atom.instance_eval { @origin = str }
+          atom
+        else
+          new(str)
+        end
+      end
+      
+      alias_method :parse, :from_s
+
+      def parse_list(list)
+        list.map { |str| parse(str) }
+      end
+
+      def from_gem_dependency(dep, category)
+        # fixme: 
+        prefix, version = *dep.version_requirements.instance_eval { @requirements.first }
+        new("#{prefix}#{category}/#{dep.name}-#{version}")
+      end
+    end
+  end  # class DependencyAtom
+end # module Gem::Portage

data/lib/g-gem/gems_commands_with_portage.rb

@@ -0,0 +1,70 @@
+module Gem::Portage
+  module InstallWithPortage
+    include Gem::Command::WithPortage(:execute)
+    include Gem::Portage::GemSpecFetcher
+
+    def default_portage_args
+      %w(--verbose)
+    end
+    
+    def execute_with_portage
+      fail (<<-EOE).head_indented if options[:args].empty?
+      Please specify a gem name on the command line (e.g. gem #{command} GEMNAME)
+      As with the ebuild command you can also specify a portage dependency-atom.
+      (see ebuild(5) under 'DEPEND Atoms' for more info)                                                       
+
+      Note that everything after the '--portage' option is ignored by this 
+      command and is used as arguments for the emerge program.
+      EOE
+      ecmd = Gem::Portage::EbuildCommand.new :command => %w(generate digest),
+                                             :overwrite => false,
+                                             :force => false,
+                                             :test_phase => options[:test],
+                                             :install_dir => options[:install_dir],
+                                             :domain => options[:domain],
+                                             :dependencies => options[:include_dependencies]
+      self.portage_args += %w(--nodeps) if options[:ignore_dependencies]
+      ENV['USE'] = "#{ENV['USE']} doc" if options[:generate_rdoc]
+      ENV['FEATURES'] = "#{ENV['FEATURES']} test" if options[:test]
+      atoms = Gem::Portage::DependencyAtom.parse_list(options[:args])
+      ecmd.execute_on(atoms)
+      atoms_s = atoms.inject("") { |s, a| s + " " + a.to_s }
+      system("emerge #{portage_args_s} #{atoms_s}")
+    end
+
+  end # module InstallWithPortage
+end # module Gem::Portage
+
+module Gem::Portage
+  module UpdateWithPortage
+    include Gem::Command::WithPortage(:execute)
+    include Gem::Portage::GemSpecFetcher
+    
+    def execute_with_portage
+      p "Unimplemented"
+      exit 0 
+    end
+  end # module InstallWithPortage
+end # module Gem::Portage
+
+class Gem::CommandManager
+  WITH_PORTAGE_COMMANDS = {
+    :install => Gem::Portage::InstallWithPortage,
+    :update => Gem::Portage::UpdateWithPortage
+  }
+
+  def with_portage(name)
+    return self.class.instance[name] unless 
+      WITH_PORTAGE_COMMANDS.has_key?(name.to_sym)
+    Gem::Command::WithPortage.wave_with_portage(self.class.instance[name], 
+                                                WITH_PORTAGE_COMMANDS[name.to_sym])
+  end
+
+  class << self
+    def wave_all_with_portage
+      WITH_PORTAGE_COMMANDS.each_key do |name|
+        self.instance.with_portage(name.to_s)
+      end
+    end
+  end
+end

data/lib/g-gem/gems_extensions.rb

@@ -0,0 +1,133 @@
+require 'rubygems'
+Gem.manage_gems
+
+class Gem::DependencyList
+  class << self
+    def from_atoms(fetcher, atoms)
+      deps = self.new
+      atoms.each do |atom|
+        dep = atom.gem_dependency
+        if atom.origin =~ /^(.*\/)/
+          dep.singleton_eval do
+            define_method(:origin_dir) { $1 }
+          end
+        end
+        deps.add(fetcher[dep])
+      end
+      deps
+    end
+  end
+
+  def satisfied?(dependency)
+    @specs.any? { |s| s.satisfies_requirement?(dependency) }
+  end
+
+  def include_dependencies(fetcher)
+    return self if ok?
+    size = @specs.size
+    @specs.each do |spec|
+      spec.dependencies.each do |dep|
+        next if satisfied?(dep)
+        add fetcher[dep]
+      end
+    end
+    @specs.size != size ? include_dependencies(fetcher) : self
+  end
+ 
+  def each_spec
+    @specs.each do |spec| yield spec ; end
+  end
+  
+end # class Gem::DependencyList
+
+class Gem::Command
+  def handle_options_with_portage(args)
+    port_arg = args.index('--portage')
+    port_arg = args.slice!(port_arg.succ .. -1) if port_arg
+    handle_options_without_portage(args)
+    @options[:portage_args] = port_arg if port_arg
+    @options[:args]
+  end
+  
+  alias_method :handle_options_without_portage, :handle_options
+  alias_method :handle_options, :handle_options_with_portage
+
+  module WithPortage
+    DEFAULT_PORTAGE_ARGS = %w(--verbose --ask)
+
+    def default_portage_args
+      DEFAULT_PORTAGE_ARGS
+    end
+
+    def portage_args
+      @portage_args || default_portage_args + @options[:portage_args].to_a
+    end
+
+    def portage_args=(arr)
+      @portage_args = arr
+    end
+    
+    def portage_args_s
+      portage_args.join(' ')
+    end
+    
+    def with_portage?
+      return false if options[:with_portage] == false
+      options[:with_portage] || Process.euid == 0
+    end
+    
+    def waved_with_portage?
+      true
+    end
+
+    class << self
+      def wave_with_portage(cmd, with_portage_module)
+        cmd.extend with_portage_module
+      end
+    end
+
+  end # module WithPortage
+
+  def self.WithPortage(methname, &block)
+    Module.new do
+      include WithPortage     
+
+      if block
+        define_method("maybe_#{methname}_with_portage".intern, &block)
+      else
+        module_eval <<-MAYBE
+        def maybe_#{methname}_with_portage(*args, &prc)
+          if with_portage?
+            #{methname}_with_portage(*args, &prc)
+          else
+            #{methname}_without_portage(*args, &prc)
+          end
+        end
+        MAYBE
+      end
+
+      singleton_eval do # class << self
+        define_method(:append_features) do |mod|
+          super
+          mod.singleton_eval do # class << mod
+            define_method(:extend_object) do |obj|
+              super
+              obj.singleton_eval <<-ALIAS # class << obj
+              alias_method :#{methname}_without_portage, :#{methname}
+              alias_method :#{methname}, :maybe_#{methname}_with_portage
+              ALIAS
+              obj.instance_eval do 
+                add_option '--[no-]portage', 
+                "#{command.capitalize} using the portage system" do |v, h|
+                  h[:with_portage] = v
+                end
+              end
+              obj.instance_eval &block if block
+            end
+          end
+        end
+      end
+    end # WithPortage anon module
+  end
+end # class Gem::Command
+

data/lib/g-gem/portage_commands.rb

@@ -0,0 +1,78 @@
+require 'g-gem/ebuild'
+
+module Gem::Portage
+  class PortageCommand < Command
+    has_option :category, 'Portage category for the gems ebuilds',
+               :default_category => Gem::Portage::Ebuild::DEFAULT_CATEGORY
+  end # class PortageCommand
+
+  class EbuildCommand < PortageCommand
+    include Gem::LocalRemoteOptions
+    include GemSpecFetcher
+
+    has_option :overwrite, 'Whether to overwrite existing ebuilds or not', 
+               :default => false
+    has_option :force, 'Execute actions even if the ebuild file was not generated by this command',
+               :default => true
+    has_option :dependencies, 'Execute actions for dependent gems also',
+               :default => true
+    has_option :portdir, 'Set the portage directory',
+               :default_dir => Gem::Portage::Ebuild::DEFAULT_PORTDIR
+    has_option :test_phase, 'Whether to generate ebuilds with test phase',
+               :default => true
+    has_option :install_dir, 'Target installation directory for the ebuild',
+               :default_dir => Gem::Portage::Ebuild::DEFAULT_INSTALL_DIR
+    has_option :ebuild_command, '--command x,y,z', Array, "The 'list' of ebuild(1) commands to execute or 'generate'",
+               :default => %w(generate digest)
+
+    def initialize(defaults=nil)
+      super('ebuild', 'Generate portage ebuilds from gem specification', defaults)
+      add_local_remote_options
+    end
+
+    def usage
+      "#{program_name} GEM_NAME"
+    end
+
+    def arguments
+      return <<-ARGUMENTS
+      GEMNAME 
+      ARGUMENTS
+    end
+
+    def execute
+      fail Gem::CommandLineError, show_help if options[:args].empty?
+      fail <<-EOE unless (ebuild_command - Gem::Portage::Ebuild::COMMANDS).empty?
+      Invalid ebuild commands: #{ebuild_command.inspect}
+
+      Valid values are those listed on ebuild(1) and 'generate'
+      EOE
+      atoms = DependencyAtom.parse_list(options[:args])
+      execute_on(atoms)
+    end
+
+    def execute_on(atoms)
+      specs = Gem::DependencyList.from_atoms(spec_fetcher, atoms)
+      specs.include_dependencies(spec_fetcher) if dependencies?
+      create = ebuild_command.delete('generate')
+      specs.each_spec do |spec|
+        ebuild = Ebuild.for(spec, portdir, category)
+        if create and (overwrite? or not ebuild.exists?)
+          say "Generating #{ebuild.file_path} ..."
+          begin
+            File.delete(ebuild.digest_file)
+          rescue
+          end
+          ebuild.install_dir = File.expand_path(install_dir, Dir.pwd)
+          ebuild.enable_test_phase if test_phase?
+          ebuild.generate
+          ebuild.execute(*ebuild_command)
+        elsif force?
+          ebuild.execute(*ebuild_command)
+        end
+      end
+    end
+
+    register
+  end # class EbuildCommand
+end # module Gem::Portage

data/lib/g-gem/spec_fetcher.rb

@@ -0,0 +1,77 @@
+module Gem::Portage
+  module GemSpecFetcher
+    class << self
+      def LocalOrRemote(domain)
+        Module.new do 
+          define_method(:local?) do 
+            domain == :local || domain == :both
+          end
+          define_method(:remote?) do
+            domain == :remote || domain == :both
+          end
+        end 
+      end
+    end
+
+    def LocalOrRemote(domain)
+      GemSpecFetcher.LocalOrRemote(domain)
+    end
+
+    def fetch_local(dependency)
+      dir = dependency.respond_to?(:origin_dir) ? dependency.origin_dir : Dir.pwd
+      file = Gem::Portage::Utils::gem_file_for(dependency, dir)
+      raise "Gem for #{dependency} not found" unless file
+      spec = Gem::Format.from_file_by_path(file).spec
+      spec.singleton_eval do 
+        define_method(:fetched_from) { file }
+      end
+      spec.extend LocalOrRemote(:local)
+    end
+
+    def fetch_remote(dependency)
+      remote_installer = Gem::RemoteInstaller.new
+      remote_source_index = remote_installer.source_index_hash
+      fetcher_proc = lambda do |dep|
+        spec, uri = remote_installer.find_gem_to_install(dep.name, 
+                                                         dep.version_requirements,
+                                                         remote_source_index)
+        spec.singleton_eval do 
+          define_method(:fetched_from) { uri }
+        end
+        spec.extend LocalOrRemote(:remote)
+      end
+      singleton_eval do 
+        define_method(:fetch_remote, &fetcher_proc)
+      end
+      fetch_remote(dependency)
+    end
+
+    def local_fetcher
+      method(:fetch_local).extend LocalOrRemote(:local)
+    end
+
+    def remote_fetcher
+      method(:fetch_remote).extend LocalOrRemote(:remote)
+    end
+
+    def spec_fetcher(domain=nil)
+      domain = domain ? Object.new.extend(LocalOrRemote(domain)) : self
+      if domain.local? ^ domain.remote?
+        domain.local? ? local_fetcher : remote_fetcher
+      else
+        lambda do |dependency|
+          begin
+            local_fetcher[dependency]
+          rescue
+            remote_fetcher[dependency]
+          end
+        end.extend LocalOrRemote(:both)
+      end
+    end
+
+    def fetch_spec(dependency)
+      spec_fetcher[dependency]
+    end
+  end # class GemFetcher
+
+end # module Gem::Portage

data/lib/g-gem/utils.rb

@@ -0,0 +1,85 @@
+module Gem::Portage; end
+module Gem::Portage::Utils
+  GEMFILE_VERSION_RE = /-(\d+(\.\d+)*)\.gem$/
+  class << self
+    def gem_file_for(dependency, dir=nil)
+      dir ||= Dir.pwd
+      dir = File.expand_path(dir, Dir.pwd)
+      entries = Dir.glob(File.join(dir, "#{dependency.name}-*.gem"))
+      entries.find do |f| 
+        next unless f =~ GEMFILE_VERSION_RE
+        dependency.version_requirements.satisfied_by?(Gem::Version.create($1))
+      end
+    end
+  end
+  
+  class ConfigFile
+    def initialize(path="/etc/make.conf")
+      @path = path
+    end
+
+    def to_s
+      @path
+    end
+    
+    def exists?
+      File.exists?(@path)
+    end
+    
+    def readable?
+      File.readable?(@path)
+    end
+    
+    def cache
+      @@cache ||= {}
+    end
+    private :cache
+    
+    def succ
+      res = case @path
+            when "/etc/make.conf"
+              ConfigFile.new("/etc/profile/make.defaults")
+            when "/etc/profile/make.defaults"
+              ConfigFile.new(File.join(File.expand_path(File.readlink("/etc/make.profile"), "/etc"), "make.defaults"))
+            else
+              parent = @path.sub(/make.defaults$/, 'parent')
+              if File.readable?(parent)
+                File.open(parent, 'r') do |f|
+            f.each_line do |line|
+              next if /^\s*$|^\s*#.*$/ === line
+              parent = line.chomp
+              break
+            end
+          end
+                parent = File.expand_path(parent, File.dirname(@path))
+                ConfigFile.new(File.join(parent, "make.defaults"))
+              end
+            end
+      res.exists? ? res : res.succ unless res.nil?
+    end
+    
+    def [](var)
+      var = var.to_sym
+      cache[var] or \
+      if readable? && !File.read(@path).scan(/^\s*#{var.to_s}\s*=\s*(.+)/).empty?
+        cache[var] = $1.gsub(/^"|"$/, '') unless $1.nil?
+      end
+    end
+    
+    def search(var)
+      self[var] or \
+      begin
+        succ_conf = self.succ
+        succ_conf.search(var) if succ_conf
+      end
+    end
+    
+    class << self
+      def [](var)
+        new.search(var)
+      end
+    end
+    
+  end # class ConfigFile
+  
+end # module Gem::Portage::Utils

metadata

@@ -0,0 +1,51 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: g-gem
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2005-10-10
+summary: g-gem is a plugin for rubygems for integration with the gentoo's portage system
+require_paths: 
+- lib
+email: vhborja@gmail.com
+homepage: http://www.rubyforge.org/projects/g-gem
+rubyforge_project: 
+description: 
+autorequire: g-gem
+default_executable: g-gem
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+- Victor Borja
+files: 
+- lib/g-gem.rb
+- lib/g-gem/core_extensions.rb
+- lib/g-gem/portage_commands.rb
+- lib/g-gem/gems_commands_with_portage.rb
+- lib/g-gem/gems_extensions.rb
+- lib/g-gem/ebuild.rb
+- lib/g-gem/command.rb
+- lib/g-gem/spec_fetcher.rb
+- lib/g-gem/utils.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- g-gem
+extensions: []
+
+requirements: []
+
+dependencies: []
+