rip 0.0.1

data/lib/rip/commands.rb

@@ -0,0 +1,113 @@
+module Rip
+  module Commands
+    extend self
+
+    def invoke(args)
+      command, options, args = parse_args(args)
+
+      if command.nil? || command == ''
+        command = :help
+      end
+
+      command = find_command(command)
+
+      begin
+        send(command, options, *args)
+      rescue => e
+        if options[:error]
+          raise e
+        else
+          ui.puts "rip: #{command} failed"
+          ui.puts "-> #{e.message}"
+        end
+      end
+    end
+
+    def public_instance_methods
+      super - %w( invoke public_instance_methods )
+    end
+
+  private
+    # tasty dsl for adding help text
+
+    def o(usage)
+      @usage ||= {}
+      @next_usage = usage
+    end
+
+    def x(help)
+      @help ||= {}
+      @next_help ||= []
+      @next_help.push help
+    end
+
+    def method_added(method)
+      @help[method.to_s] = @next_help if @next_help
+      @usage[method.to_s] = @next_usage if @next_usage
+      @next_help = nil
+      @next_usage = nil
+    end
+
+    def ui
+      Rip.ui
+    end
+
+    def manager(env = nil)
+      @manager ||= PackageManager.new(env)
+    end
+
+    def find_command(command)
+      matches = public_instance_methods.select do |method|
+        method =~ /^#{command}/
+      end
+
+      if matches.size == 0
+        :help
+      elsif matches.size == 1
+        matches.first
+      else
+        ui.abort "rip: which command did you mean? #{matches.join(' or ')}"
+      end
+    end
+
+    def parse_args(args)
+      command = args.shift
+      options = args.select { |piece| piece =~ /^-/ }
+      args   -= options
+      options = options.inject({}) do |hash, flag|
+        key, value = flag.split('=')
+        hash[key.sub(/^--?/,'').intern] = value.nil? ? true : value
+        hash
+      end
+
+      [command, options, args]
+    end
+  end
+end
+
+
+#
+# rip plugin commands
+#
+
+# load ~/.rip/rip-commands/*.rb
+if File.exists? dir = File.join(Rip.dir, 'rip-commands')
+  Dir[dir + '/*.rb'].each do |file|
+    require file
+  end
+end
+
+# load lib/rip/commands/*.rb from the active ripenv
+if File.exists? dir = File.join(Rip::Env.active_dir, 'lib', 'rip', 'commands')
+  Dir[dir + '/*.rb'].each do |file|
+    require file
+  end
+end
+
+
+# load lib/rip/commands/*.rb from rip itself
+if File.exists? dir = File.join(File.dirname(__FILE__), 'commands')
+  Dir[dir + '/*.rb'].each do |file|
+    require file
+  end
+end

data/lib/rip/commands/build.rb

@@ -0,0 +1,23 @@
+# file: lib/rip/commands/build.rb
+#
+# rip build
+# Builds Ruby extensions for installed packages
+
+module Rip
+  module Commands
+    def build(options={}, *packages)
+      packages.each do |package_name|
+        ui.puts "rip: building package: #{package_name}"
+        package = manager.package(package_name)
+
+        Dir["#{package.cache_path}/**/extconf.rb"].each do |build_file|
+          build_dir = File.dirname(build_file)
+          Dir.chdir(build_dir) {
+            system "ruby extconf.rb"
+            system "make install RUBYARCHDIR=#{manager.dir}/lib"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rip/commands/core.rb

@@ -0,0 +1,82 @@
+module Rip
+  module Commands
+    x 'Display libraries installed in the current ripenv.'
+    def list(*args)
+      ui.puts 'ripenv: ' + Rip::Env.active, ''
+      if manager.packages.any?
+        ui.puts manager.packages
+      else
+        ui.puts "nothing installed"
+      end
+    end
+
+    def help(options = {}, command = nil, *args)
+      command = command.to_s
+      if !command.empty? && respond_to?(command)
+        ui.puts "Usage: %s" % (@usage[command] || "rip #{command.downcase}")
+        if @help[command]
+          ui.puts
+          ui.puts(*@help[command])
+        end
+      else
+        show_general_help
+      end
+    end
+
+    o 'rip env COMMAND'
+    x 'Commands for managing your ripenvs.'
+    x 'Type rip env to see valid options.'
+    def env(options = {}, command = nil, *args)
+      if command && Rip::Env.respond_to?(command)
+        ui.puts 'ripenv: ' + Rip::Env.call(command, *args).to_s
+      else
+        show_help :env, Rip::Env.commands
+        ui.puts '', "current ripenv: #{Rip::Env.active}"
+      end
+    end
+
+    x 'Outputs all installed libraries (and their versions) for the active env.'
+    x 'Can be saved as a .rip and installed by other rip users with:'
+    x '  rip install file.rip'
+    def freeze(options = {}, env = nil, *args)
+      manager(env).packages.each do |package|
+        ui.puts "#{package.source} #{package.version}"
+      end
+    end
+
+    x 'Prints the current version and exits.'
+    def version(options = {}, *args)
+      ui.puts "Rip #{Rip::Version}"
+    end
+    alias_method        "-v", :version
+    alias_method "--version", :version
+
+  private
+    def show_help(command, commands)
+      subcommand = command.to_s.empty? ? nil : "#{command} "
+      ui.puts "Usage: rip #{subcommand}COMMAND [options]", ""
+      ui.puts "Commands available:"
+
+      commands.each do |method|
+        ui.puts "  #{method}"
+      end
+    end
+
+    def show_general_help
+      commands = public_instance_methods.reject do |method|
+        method =~ /-/ || %w( help version ).include?(method)
+      end
+
+      show_help nil, commands
+
+      ui.puts
+      ui.puts "For more information on a a command use:"
+      ui.puts "  rip help COMMAND"
+      ui.puts
+
+      ui.puts "Options: "
+      ui.puts "  -h, --help     show this help message and exit"
+      ui.puts "  -v, --version  show the current version and exit"
+    end
+  end
+end

data/lib/rip/commands/install.rb

@@ -0,0 +1,37 @@
+module Rip
+  module Commands
+    x 'Checks that your rip installation is valid.'
+    def check(*args)
+      Setup.check_installation
+      ui.puts "All systems go."
+    rescue => e
+      ui.abort "Installation failed: #{e.message}"
+    end
+
+    o 'rip install SOURCE [options]'
+    x 'Installs a package from SOURCE.'
+    x '-f forces installation (overwrites existing)'
+    def install(options = {}, source = nil, version = nil, *args)
+      if source.to_s.empty?
+        ui.abort "Please tell me what to install."
+      end
+
+      package = Rip::Package.for(source, version)
+
+      if !package
+        ui.abort "I don't know how to install #{source}"
+      end
+
+      if options[:f]
+        Installer.new.uninstall(package) if package.installed?
+        Installer.new.install(package)
+      elsif package.installed?
+        ui.puts "#{package} already installed"
+      else
+        installer = Installer.new
+        installer.install(package)
+#         puts "#{installer.installed.size.to_i} packages installed"
+      end
+    end
+  end
+end

data/lib/rip/commands/uninstall.rb

@@ -0,0 +1,43 @@
+module Rip
+  module Commands
+    o 'rip uninstall PACKAGE [options]'
+    x 'Uninstalls a single Rip package.'
+    x '-y removes the package no matter what.'
+    x '-d removes the package and its dependents.'
+    def uninstall(options = {}, name = nil, *args)
+      if name.to_s.empty?
+        ui.abort "Please tell me what to uninstall."
+      end
+
+      force = options[:y] || options[:d]
+      package = manager.package(name)
+
+      if !package
+        ui.abort "#{name} isn't installed."
+      end
+
+      dependents = manager.packages_that_depend_on(name)
+
+      if dependents.any? && !force
+        ui.puts "You have requested to uninstall the package:"
+        ui.puts "  #{package}"
+        ui.puts
+        ui.puts "The following packages depend on #{name}:"
+
+        dependents.each do |dependent|
+          ui.puts "  #{dependent}"
+        end
+
+        ui.puts
+        ui.puts "If you remove this package one or more dependencies will not be met."
+        ui.puts "Pass -y if you really want to remove #{name}"
+        ui.abort "Pass -d if you want to remove #{name} and its dependents."
+      end
+
+      if force || dependents.empty?
+        Installer.new.uninstall(package, options[:d])
+        ui.puts "Successfully uninstalled #{package}"
+      end
+    end
+  end
+end

data/lib/rip/env.rb

@@ -0,0 +1,128 @@
+module Rip
+  module Env
+    extend self
+
+    def commands
+      instance_methods - %w( call active_dir commands ui )
+    end
+
+    def create(env)
+      dir = File.join(Rip.dir, env)
+
+      if env.strip.empty?
+        return "must give a ripenv to create"
+      end
+
+      if File.exists? dir
+        "#{env} exists"
+      else
+        FileUtils.mkdir_p File.join(dir, 'bin')
+        FileUtils.mkdir_p File.join(dir, 'lib')
+
+        use env
+        "created #{env}"
+      end
+    end
+
+    def use(env)
+      if env.strip.empty?
+        return "must give a ripenv to use"
+      end
+
+      if !File.exists?(target = File.join(Rip.dir, env))
+        return "#{env} doesn't exist"
+      end
+
+      begin
+        FileUtils.rm active_dir
+      rescue Errno::ENOENT
+      end
+      FileUtils.ln_s(target, active_dir)
+
+      "using #{env}"
+    end
+
+    def delete(env)
+      if active == env
+        return "can't delete active environment"
+      end
+
+      if env.strip.empty?
+        return "must give a ripenv to delete"
+      end
+
+      if File.exists?(target = File.join(Rip.dir, env))
+        FileUtils.rm_rf target
+        "deleted #{env}"
+      else
+        "can't find #{env}"
+      end
+    end
+
+    def list(env = nil)
+      envs = Dir.glob(File.join(Rip.dir, '*')).map do |env|
+        env.split('/').last
+      end
+
+      envs.reject! { |env| env =~ /^(rip-|active)/ }
+
+      if envs.empty?
+        "none. make one with `rip env create <env>`"
+      else
+        envs.join(' ')
+      end
+    end
+
+    def active
+      active = File.readlink(active_dir)
+      active.split('/').last
+    end
+
+    def copy(new)
+      if new.strip.empty?
+        return "must give a ripenv to copy to"
+      end
+
+      dest = File.join(Rip.dir, new)
+      src  = Rip::Env.active_dir
+      env  = Rip::Env.active
+
+      if File.exists?(dest)
+        return "#{new} exists"
+      end
+
+      FileUtils.cp_r src, dest
+
+      if File.exists? ripfile = File.join(dest, "#{env}.ripenv")
+        FileUtils.cp ripfile, File.join(dest, "#{new}.ripenv")
+      end
+
+      use new
+      "cloned #{env} to #{new}"
+    end
+
+    # for being lazy about what we have vs what we want.
+    # enables javascript-style method calling where
+    # the number of arguments doesn't need to match
+    # the arity
+    def call(meth, *args)
+      arity = method(meth).arity.abs
+
+      if arity == args.size
+        send(meth, *args)
+      elsif arity == 0
+        send(meth)
+      else
+        send(meth, args[0, arity])
+      end
+    end
+
+    def active_dir
+      File.join(Rip.dir, 'active')
+    end
+
+    def ui
+      Rip.ui
+    end
+  end
+end

data/lib/rip/installer.rb

@@ -0,0 +1,130 @@
+module Rip
+  class Installer
+    include Memoize
+
+    attr_reader :installed
+    def initialize
+      @installed = {}
+      @uninstalled = {}
+    end
+
+    memoize :manager
+    def manager
+      PackageManager.new
+    end
+
+    def install(package, parent = nil)
+      if !package.exists?
+        error = package.name
+        error += " requested by #{parent} but" if parent
+        error += " not found at #{package.source}"
+        ui.abort error
+      end
+
+      Dir.chdir File.join(Rip.dir, 'rip-packages') do
+        begin
+          installed = @installed[package.name] || package.installed?
+
+          manager.add_package(package, parent) unless package.meta_package?
+
+          return if installed
+          @installed[package.name] = package
+
+          if !package.version
+            ui.abort "can't install #{package} - it has no version"
+          end
+
+          package.fetch
+          package.unpack
+          install_dependencies(package)
+          run_install_hook(package)
+          copy_files(package)
+          cleanup(package)
+          ui.puts "Successfully installed #{package}" unless package.meta_package?
+
+        rescue VersionConflict => e
+          ui.puts e.message
+          rollback
+          ui.abort "installation failed"
+
+        rescue => e
+          rollback
+          raise e
+        end
+      end
+    end
+
+    def install_dependencies(package)
+      package.dependencies.each do |dependency|
+        install(dependency, package)
+      end
+    end
+
+    def run_install_hook(package)
+      return unless File.exists? File.join(package.cache_path, 'Rakefile')
+
+      Dir.chdir package.cache_path do
+        ui.puts "running install hook for #{package.name}"
+        system "rake -s rip:install >& /dev/null"
+      end
+    end
+
+    def copy_files(package)
+      package_lib = File.join(package.cache_path, 'lib')
+      package_bin = File.join(package.cache_path, 'bin')
+
+      dest = Rip::Env.active_dir
+      dest_lib = File.join(dest, 'lib')
+      dest_bin = File.join(dest, 'bin')
+
+      if File.exists? package_lib
+        FileUtils.cp_r package_lib + '/.', dest_lib
+      end
+
+      if File.exists? package_bin
+        FileUtils.cp_r package_bin + '/.', dest_bin
+      end
+    end
+
+    def cleanup(package)
+      FileUtils.rm_rf package.cache_path unless package.cached?
+    end
+
+    def rollback
+      @installed.values.each do |package|
+        uninstall(package)
+        cleanup(package)
+      end
+    end
+
+    def uninstall(package, remove_dependencies = false)
+      packages = [package]
+
+      if remove_dependencies
+        packages.concat manager.packages_that_depend_on(package.name)
+      end
+
+      Dir.chdir Rip::Env.active_dir do
+        packages.each do |package|
+          begin
+            next if @uninstalled[package.name]
+            @uninstalled[package.name] = true
+
+            package.files.each do |file|
+              FileUtils.rm_rf file
+            end
+
+            manager.remove_package(package)
+          rescue => e
+            ui.puts e.message
+            next
+          end
+        end
+      end
+    end
+
+    def ui
+      Rip.ui
+    end
+  end
+end