rbp 0.0.2

data/README.md

@@ -0,0 +1,194 @@
+rbp: Ruby Package (manager)
+===========================
+
+rbp is a package manager for ruby. It is an alternative to rubygems as
+it installs dependencies locally to your application to make version
+management easier. Packages can also be installed globally, but the
+default is to keep all dependencies tidly inside your app directory.
+
+rbp is **not** required at runtime which also removes the additonal
+loading required to make rbp operate. All packages are installed into
+the `vendor/packages` directory inside your local directory.
+
+**rbp is still in pre-pre-pre-pre-alpha**
+
+Installation
+------------
+
+rbp can be installed directly by the following command. This will just
+download the latest version of rbp and install its `lib` and `bin`
+directories into the siteruby directory for your ruby install. Aslong as
+these are in the loadpath (which they should be), then rbp will just
+work.
+
+To install rbp just do:
+
+```
+$ curl -s https://raw.github.com/adambeynon/rbp/master/setup.rb | ruby
+```
+
+If you use rbenv or rvm then you may need to run this command for
+each ruby install. To make sure rbp is working, just run:
+
+```
+$ rbp version
+```
+
+If the command cannot be found, check your shells PATH variable.
+
+How it works
+-------------
+
+In your app directory there will be a `vendor/packages` directory where
+each dependancy is stored in its own directory by name. For example:
+
+```
+some_app/
+ |-bin/
+ |-lib/
+ |-vendor/
+    |-packages/
+       |-init.rb
+       |-rake/
+       |-otest/
+```
+
+Installing or removing (or updating) packages will be done through the
+`rbp` command, which is simply a ruby library. rbp is only needed during
+development - not production. Of course, the packages directory should be
+added to `.gitignore` (or similar).
+
+### init.rb
+
+`init.rb` in the packages directory is where all the magic happens. As
+packages are added or removed, their load paths are registered inside
+init.rb automatically by rbp, so when your package code runs, all the
+relevant load paths are setup so you can just require() away. Your
+packages own load path is also added to this file, so simply requiring
+this file will add your library to the load path as well.
+
+
+### Why use init.rb?
+
+Ruby can only load files from loadpaths that are set on the `$:` array.
+Rubygems works by overriding `require` to perform dynamic lookup for
+libraries. rbp does not have any runtime component, so dependencies must
+be in the loadpath on running. To do this, `init.rb` adds all
+dependency load paths automatically for you. The only requirement is
+that init.rb is run straight away, and this is what the `rbp` command
+does. 
+
+When deploying an application, `rbp` will not be available - and here
+you have two choices. Considering deployed applications will not be used
+as libraries themselves, you can load init.rb in your app directly. For
+example, in rails you might do this in config.ru:
+
+```ruby
+File.expand_path('../vendor/packages.init.rb', __FILE__)
+```
+
+which will run the init.rb file for you, so all dependencies will be
+ready to run. Also, this allows you to use a vendor version of rails
+itself which may be very specific to your app (2.3 vs 3.0 vs 3.1 etc).
+
+When a dependency is not found on the loadpath, a fallback on rubygems
+may be used to use a global gem as the last option (probably will happen
+as a lot of ruby installs will load rubygems automatically).
+
+### Local development
+
+rbp comes with a handy command `irb` which will open irb with the init
+file already added to the load path so you can just require your app
+dependencies directly. For example:
+
+```
+$ rbp irb
+
+irb> require 'dependency_1'
+```
+
+To run bin files either inside your local package, or an included
+dependency, the `exec` command will setup your load paths as well. Run
+from the command line:
+
+```
+$ rbp exec bin_from_a_dependency arg1 arg2 arg3
+```
+
+To get all dependencies on the load path, init.rb needs to be called.
+rbp does this for you by wrapping common ruby commands, but any
+additional methods might mean having to require init.rb directly. For
+example, a Rakefile:
+
+```ruby
+require File.expand_path('../vendor/packages/init.rb')
+require 'your_lib_name'
+```
+
+When your lib requires its dependencies they will already be on the load
+path thanks to init.rb.
+
+**NOTE:** init.rb also adds your actual app/packages load path into the
+ruby load paths as well so you don't have to.
+
+### Listing dependencies and package.yml
+
+An apps dependencies are listed in its package.yml file, which is in the
+base directory. It is based off/inspired by commonjs' package.json. rbp
+doesn't use gemspecs because it aims to be a replacement/alternative to
+rubygems.
+
+Dependencies are listed as a hash in the package.yml file and it can
+list either their required version numbers or a git url. Packages with
+versions numbers are download directly from rubygems.org server and
+converted from gems into packages.
+
+### Example init.rb
+----------------
+
+**Note:** this is created automatically by rbp - you do not need to
+create this yourself.
+
+```ruby
+# your packages' path
+path = File.expand_path('..', __FILE__)
+
+# your packages' lib
+$:.unshift File.expand_path("#{path}/../lib")
+
+# dependency 1: `otest'
+$:.unshift File.expand_path("#{path}/../packages/otest/lib")
+
+# dependency 2: `rake'
+$:.unshift File.expand_path("#{path}/../packages/rake/lib")
+```
+
+Installing packages globally
+----------------------------
+
+Some packages may want to be installed globally, mainly as a
+compatibility with the way rubygems does things. For example, rails
+generates a template directory for you, so it may not be possible to add
+rails as a dependency before you setup your dir structure. For this
+reason, global packages are supported.
+
+### Using rubygems as a 'legacy' system
+
+For the short term, global packages in rbp will just be gem
+installations - rbp will just search for, and install, gems. This will
+allow any package that is not in the local packages directory to be
+loaded by rubygems itself - we could add warnings stating that you are
+using a global package. If you then install a different version locally,
+then that will be used instead, as its lib path is already on the load
+path before rubygems searches for an alternative.
+
+In the longer term, the plan is to replace rubygems and global packages
+will be installed in a similar manner to rubygem packages, including
+wrapped bin files which allow this dynamic lib lookup. When local
+packages then need to use globally installed ones, a **very** smal
+runtime component from rvm can be loaded to assist lib lookup.
+
+Global packages should still be used for development purposes, and the
+idea will be to copy all required global packages to the local directory
+ready for production.
+

data/bin/rbp

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rbp'
+require 'rbp/command'
+
+Rbp::Command.new ARGV
+

data/lib/rbp.rb

@@ -0,0 +1,7 @@
+require 'rbp/package'
+
+module Rbp
+  VERSION = "0.0.1"
+  def self.version; VERSION; end
+end
+

data/lib/rbp/command.rb

@@ -0,0 +1,153 @@
+require 'rbp'
+require 'rbp/package'
+require 'rbp/package_manager'
+require 'rbp/dependency'
+require 'rbp/git_dependency'
+require 'rbp/dependency_installer'
+require 'rbp/dependency_uninstaller'
+
+module Rbp
+  class Command
+    # All valid commands that can be run from command line
+    COMMANDS = [:install, :exec, :irb, :ls, :version]
+
+    # Creates a nw instance of the command utility which will then delegate
+    # to sub commands (methods) to handle individual commands.
+    #
+    # @param [Array<String>] args command line args
+    def initialize(args)
+      command = args.shift
+
+      if command and COMMANDS.include?(command.to_sym)
+        __send__ command.to_sym, *args
+      else
+        help
+      end
+    end
+
+    def install(*)
+      manager = PackageManager.new
+      manager.install_dependencies
+    end
+
+    # Takes a Gem dependency and installs it into the local packages/
+    # directory.
+    #
+    # The installed gem/package is then inspected and all of its load
+    # paths are registered in init.rb so they are available at runtime.
+    #
+    # Finally, all of the dependecies of the dependency given will be
+    # installed.
+
+    def install_dependency(dependency, force = false)
+      name = dependency.name
+      path = package_install_path(name)
+
+      if File.exists? path
+        unless force
+          info "Skipping `#{name}'"
+          return
+        end
+
+        info "Removing `#{name}'"
+        uninstall_dependency name
+      end
+
+      spec = dependency.matching_specs.first
+
+      if spec and File.exists? spec.full_gem_path
+        info "Linking `#{name}'"
+        cp_r spec.full_gem_path, path
+      else
+        spec = install_remote_dependency dependency
+      end
+
+      register_load_paths spec
+
+      puts "going over dependencies.."
+
+      spec.runtime_dependencies.each do |dep|
+        install_dependency dep
+      end
+    end
+
+    ##
+    # Takes a Gem dependency and installs it into the local packages/
+    # directory. This will **always** go out and retrieve a remote gem
+    # matching the dependency, it will never link to a locally installed
+    # one.
+    #
+    # This can be seen as sandboxing a gem installation just to the local
+    # package - nothing is done globally.
+    #
+    # This will then return the spec file for the installed dependency as
+    # it is used for registering load paths etc
+
+    def install_remote_dependency(dependency)
+      name = dependency.name
+      dest = package_install_path(name)
+      info "Installing `#{name}'"
+
+      spec, uri = begin
+        ins = Gem::DependencyInstaller.new
+        ins.find_spec_by_name_and_version(name, dependency.requirement)[0]
+      rescue Gem::GemNotFoundException => e
+        abort "Could not find dependency `#{name}'"
+      end
+
+      gem_path = Gem::RemoteFetcher.fetcher.download(spec, uri, gems_path)
+
+      installer = Gem::Installer.new(gem_path, :unpack => true)
+      installer.unpack dest
+      installer.build_extensions
+
+      # erm, the installer somehow gets a different spec..?
+      return installer.spec
+    end
+
+    # Execute a bin file in (local?) packages/
+    #
+    # Currently hardcoded to load bin file in current packages actual
+    # bin directory. Using bins from dependencies not yet supported.
+    #
+    # Usage:
+    #
+    #     rbp exec bin_name arg1 arg2 arg3
+    #
+    # This command will also require the init.rb in the packages
+    # directory of the local package so all libs, including
+    # dependencies, will be available.
+    def exec(bin, *arg)
+      command = "ruby -r ./vendor/packages/init.rb bin/#{bin} #{arg.join ''}"
+      puts "  exec `#{command}'\n\n"
+      system command
+    end
+
+    # This command will simply open a regular irb session, passing
+    # any given arguments.
+    #
+    # The init.rb file will automatically be required so all
+    # installed dependencies, and the local package itself, will be
+    # ready on the load path.
+    def irb(*args)
+      command = "irb -r ./vendor/packages/init.rb #{args.join ' '}"
+      system command
+    end
+
+    # List all dependencies of this package
+    def ls
+      raise "not implemented"
+    end
+
+    # version info
+    def version
+      puts Rbp.version
+    end
+
+    # Simply print help
+    def help
+      puts "Usage: rbp <command>"
+    end
+  end
+end
+

data/lib/rbp/dependency.rb

@@ -0,0 +1,19 @@
+module Rbp
+  class Dependency
+    # dependency name, i.e. package name
+    attr_reader :name
+
+    # version required of dependency, e.g. 0.1.0
+    attr_reader :version
+
+    def initialize(name, version = nil)
+      @name = name
+      @version = version || ">= 0"
+    end
+
+    def inspect
+      "<#{self.class} name=#{name.inspect} version=#{version.inspect}>"
+    end
+  end
+end
+

data/lib/rbp/dependency_installer.rb

@@ -0,0 +1,123 @@
+require 'fileutils'
+require 'tmpdir'
+require 'rubygems/dependency_installer'
+
+module Rbp
+  class DependencyInstaller
+
+    attr_reader :package
+
+    def initialize(dependency)
+      @dependency = dependency
+    end
+
+    # Install the dependency into the given environment. The environment
+    # has all the paths and files etc needed for installing a dependency
+    # into.
+    #
+    # @param [Environment] environment the environment to install to
+    # @return [Package] returns the package for the installed dependency
+    def install(package_manager)
+      @package_manager = package_manager
+
+      case @dependency
+      when Dependency
+        install_dependency @dependency
+      when GitDependency
+        install_git_dependency @dependency
+      else
+        raise "Bad dependency to install"
+      end
+    end
+
+    private
+
+    def install_dependency(dependency)
+      gem_dep = Gem::Dependency.new dependency.name, dependency.version
+      name = dependency.name
+      destination = @package_manager.package_dir_for(name)
+
+      spec, uri = begin
+        ins = Gem::DependencyInstaller.new
+        ins.find_spec_by_name_and_version(name, gem_dep.requirement).first
+      rescue Gem::GemNotFoundException => e
+        raise "Could not find dependency `#{name}'"
+      end
+
+      tmp_path = File.join(Dir.tmpdir, "#{name}_#{Time.now.to_i}")
+      FileUtils.mkdir_p tmp_path
+
+      gem_path = Gem::RemoteFetcher.fetcher.download(spec, uri, tmp_path)
+
+      installer = Gem::Installer.new(gem_path, :unpack => true)
+      installer.unpack destination
+      installer.build_extensions
+
+      FileUtils.rm_rf tmp_path
+
+      @package = Package.from_gemspec installer.spec
+      descriptor_path = @package_manager.descriptor_file_for name
+      FileUtils.mkdir_p File.dirname(descriptor_path)
+
+      File.open(descriptor_path, 'w+') { |o| o.write @package.to_yaml }
+
+      register_load_paths @package
+
+      return @package
+    end
+
+    def install_git_dependency(dependency)
+      name = dependency.name
+      url  = dependency.url
+      dest = @package_manager.package_dir_for(name)
+
+      system "git clone --quiet #{url} #{dest}"
+
+      gemspec = Dir["#{dest}/*.gemspec"].first
+      package = File.join dest, "package.yml"
+
+      if gemspec
+        raise "gemspec given"
+      elsif File.exists? package
+        @package = Package.load_path package
+      else
+        raise "need to make fake package"
+      @package = Package.new
+      end
+
+      register_descriptor @package
+
+      return @package
+    end
+
+    def register_descriptor(package)
+      descriptor_path = @package_manager.descriptor_file_for package.name
+      FileUtils.mkdir_p File.dirname(descriptor_path)
+
+      File.open(descriptor_path, 'w+') { |o| o.write package.to_yaml }
+    end
+
+    # Looks through the package and registers all the required load paths
+    # into the environment init.rb file.
+    #
+    # Currently this will just register the 'lib' directory, but it should
+    # really look at the vendor lib paths as well
+    #
+    # @param [Package] package the package to register
+    def register_load_paths(package)
+      name  = package.name
+      paths = ['lib'] + package.vendor_lib_paths
+
+      code = paths.map do |p|
+        path = "packages/#{name}/#{p}"
+        "$:.unshift File.expand_path(\"\#{path}/#{path}\")\n"
+      end.join
+
+      out = @package_manager.init_file
+      read = File.read out
+
+      File.open(out, 'w+') { |o| o.write(read + code) }
+    end
+  end
+end
+

data/lib/rbp/dependency_uninstaller.rb

@@ -0,0 +1,40 @@
+require 'fileutils'
+
+module Rbp
+  class DependencyUninstaller
+
+    def initialize(name)
+      @name = name
+    end
+
+    def uninstall(package_manager)
+      @package_manager = package_manager
+
+      unless package_manager.installed? @name
+        raise "No dependency to uninstall: `#{@name}'"
+      end
+
+      descriptor_path = package_manager.environment.descriptor_file_for(@name)
+      @package = Package.load_path descriptor_path
+
+      FileUtils.rm_rf package_manager.environment.package_dir_for(@name)
+      FileUtils.rm_f descriptor_path
+
+      unregister_load_paths @package
+    end
+
+    private
+
+    def unregister_load_paths(package)
+      name = package.name
+      init = @package_manager.environment.init_file
+
+      amended = File.read(init).each_line.reject do |line|
+        line =~ /packages\/#{name}/
+      end.join
+
+      File.open(init, 'w+') { |o| o.write amended }
+    end
+  end
+end
+

data/lib/rbp/git_dependency.rb

@@ -0,0 +1,18 @@
+module Rbp
+  class GitDependency
+
+    attr_reader :name
+
+    attr_reader :url
+
+    def initialize(name, url)
+      @name = name
+      @url = url
+    end
+
+    def inspect
+      "<#{self.class} name=#{@name.inspect} url=#{@url.inspect}>"
+    end
+  end
+end
+

data/lib/rbp/installer.rb

@@ -0,0 +1,16 @@
+require 'rubygems/dependency_installer'
+
+module Rbp
+  class DependencyInstaller
+    def self.install(dependency, options = {})
+      installer = new
+      installer.install(dependency, options)
+      installer
+    end
+
+    def install(options)
+      name = dependency.name
+    end
+  end
+end
+

data/lib/rbp/package.rb

@@ -0,0 +1,225 @@
+require 'yaml'
+
+module Rbp
+  # When package not found when loading Package
+  class PackageNotFoundError < StandardError; end
+
+  # A package is a gem
+  class Package
+
+    attr_reader :root
+
+    ##
+    # The package's name.
+    #
+    # Most remote packages are wrapped as gems, so this name must be a
+    # valid rubygem name.
+
+    attr_accessor :name
+
+    # The package's version (as a string), e.g. "0.1.0"
+    attr_accessor :version
+
+    # @return [Array<Gem::Dependency>] an array of dependencies
+    attr_reader :dependencies
+
+    # Compatibility with Gem::Specification
+    alias_method :runtime_dependencies, :dependencies
+
+    # @return [Array<Gem::Dependency>] and array of development dependencies
+    attr_reader :dev_dependencies
+
+    # Compatibility with Gem::Specification
+    alias_method :development_dependencies, :dev_dependencies
+
+    # @return [String] path to the directory that this descriptor represents.
+    attr_reader :package_dir
+
+    # @return [Array<String>] array of additional load paths relevant to the
+    # package root. This is a way of supporting multiple load paths as offered
+    # by rubygems. Rbp doesn't technically support this, so if we pretend to
+    # support vendor paths, then this works nicely(ish).
+    attr_accessor :vendor_lib_paths
+
+    # Load a package from the given directory, or the current working
+    # directory if no path specified.
+    #
+    # @param [String] root the root directory to load package.yml from
+    # @return [Package] the package that is loaded
+    def self.load(root = Dir.getwd)
+      p = self.new
+      p.load_yaml root
+      p
+    end
+
+    # load some/path/to/package.yml (must given package.yml in filename
+    # as well)
+    def self.load_path(path)
+      p = self.new
+
+      unless File.exists? path
+        raise PackageNotFoundError, "Missing package file at `#{path}'"
+      end
+
+      p.load_yaml YAML.load(File.read(path))
+
+      p.package_dir = File.dirname(path)
+
+      p
+    end
+
+    # Creates a new Package instance
+    def initialize
+      @dependencies = []
+      @dev_dependencies = []
+    end
+
+    # @param [Hash] yml the yaml object (hash) to load
+    def load_yaml(yml)
+      @yml = yml
+      raise "Bad package.yml format" unless yml
+
+      @name     = @yml['name']
+      @version  = @yml['version']
+
+      # dependencies
+      if deps = @yml['dependencies']
+        raise "Bad dependencies hash in `#{@root}'" unless Hash === deps
+
+        deps.each do |name, version|
+
+          d = if version and version =~ /^git\:\/\//
+            GitDependency.new name, version
+          else
+            Dependency.new name, version
+          end
+
+          dependencies << d
+        end
+      end
+
+      # dev dependencies
+      if deps = @yml['dev_dependencies']
+        raise "Bad dev_dependencies hash in `#{@root}'" unless Hash === deps
+
+        deps.each do |name, version|
+
+          d = if version and version =~ /^git\:\/\//
+            GitDependency.new name, version
+          else
+            Dependency.new name, version
+          end
+
+          dev_dependencies << d
+        end
+      end
+    end
+
+    def to_s
+      "#<#{self.class} name=\"#{@name}\" version=\"#{@version}\">"
+    end
+
+    # Sets the directory for the package that this package descriptor
+    # represents.
+    #
+    # This may invalidate some other variables such as lib paths, so
+    # we reset all those variables here as well.
+    #
+    # @param [String] path the directory
+    def package_dir=(path)
+      @package_dir = path
+    end
+
+    # Returns an array of all lib directories for this package. By default
+    # this will just be `['lib']`, but additional paths may be added.
+    #
+    # Usage:
+    #
+    #   package.lib_dirs
+    #   # => ['lib', 'ext']
+    #
+    # @return [Array<String>] relative lib directories.
+    def lib_dirs
+      ['lib']
+    end
+
+    # Returns an array of all files in the lib directory. Vendor directories
+    # are currently ignored.
+    #
+    # **Note:** These will be full paths, not relative.
+    #
+    # @return [Array<String>] array of paths.
+    def lib_files
+      Dir["#{package_dir}/lib/**/*.rb"]
+    end
+
+    # Returns an array of the relative lib files for this package. This
+    # takes the fully qualified libs and removes the package path. For
+    # example, this will return an array such as:
+    #
+    #   ['lib/my_package.rb', 'lib/my_package/version.rb', 'ext/foo.rb']
+    #
+    # @return [Array<String>] array of relative paths.
+    def relative_lib_files
+      libs_regexp = /^#{package_dir}\/(.*)$/
+
+      lib_files.map do |lib|
+        match = libs_regexp.match lib
+        raise "Something went wrong in `relative_lib_files`" unless match
+
+        match[1]
+      end
+    end
+
+    # @return [Hash] returns a hash version of the package which can then
+    # be written to a yaml file.
+    def to_yaml
+      validate_package!
+
+      hash = {
+        'name'    => name,
+        'version' => version.to_s
+      }
+
+      deps = {}
+      dev_deps = {}
+
+      dependencies.each { |dep| deps[dep.name] = dep.version.to_s }
+      dev_dependencies.each { |dep| dev_deps[dep.name] = dep.version.to_s }
+
+      hash['dependencies'] = deps
+      hash['dev_dependencies'] = dev_deps
+
+      hash.to_yaml
+    end
+
+    # Ensure this package is valid - needs to be done before install or
+    # before writing to file.
+    #
+    # FIXME: need to implement
+    def validate_package!
+      true
+    end
+
+    # Create a Package from the given gemspec file
+    def self.from_gemspec(spec)
+      p = self.new
+
+      p.name    = spec.name
+      p.version = spec.version
+
+      spec.runtime_dependencies.each do |d|
+        p.dependencies << Dependency.new(d.name, d.requirement)
+      end
+
+      spec.development_dependencies.each do |d|
+        p.dev_dependencies << Dependency.new(d.name, d.requirement)
+      end
+
+      p.vendor_lib_paths = spec.require_paths.reject { |p| p == 'lib' }
+
+      p
+    end
+  end
+end
+

data/lib/rbp/package_manager.rb

@@ -0,0 +1,198 @@
+require 'fileutils'
+
+module Rbp
+  # PackageManager is used for installing, updating and managing packages
+  # installed locally inside an app/development package.
+  #
+  # The package manager can either be used through the command interface,
+  # or directly, but the cli tools are the recomended approach.
+  class PackageManager
+    include FileUtils
+
+    # @return [Package] the package for the local context
+    attr_reader :package
+
+    # @return [Array<Package>] an array of locally installed packages
+    attr_reader :installed_packages
+
+    # @return [Hash<String, Dependency>] a hash of packnames to their
+    # dependency. The top package registers its dependencies here, and
+    # as those are added then their dependencies are added recursively.
+    # We can use this to find dependency mismatches, i.e. when two
+    # packages depend on different versions of packages.
+    attr_reader :dependencies
+
+    # Returns a new package manager with the given root. The root is the
+    # local app dir which packages should be managed for. This defaults to
+    # the current working directory.
+    #
+    # @param [String] root the root directory
+    def initialize(root = Dir.getwd)
+      @root = root
+      @dependencies = {}
+
+      if @package = load_package(File.join(@root, 'package.yml'))
+        # register_package @package
+      end
+
+      # find installed packages
+      @installed_packages = Dir['vendor/packages/descriptors/*.yml'].map do |p|
+        Package.load_path p
+      end
+    end
+    # @return [String] the directory where our dependencies go within the
+    # local app dir. This is 'vendor/packages'.
+    def dependencies_dir
+      @dependencies_dir ||= File.join @root, 'vendor', 'packages'
+    end
+
+    # @return [String] the directory where all the package.yml for locally
+    # installed packages go. This is '$dependencies_dir/descriptors'
+    def descriptors_dir
+      @descriptors_dir ||= File.join dependencies_dir, 'descriptors'
+    end
+
+    # @return [String] the directory where actual packages are installed
+    # to. This is '$dependencies_dir/packages'
+    def packages_dir
+      @packages_dir ||= File.join dependencies_dir, 'packages'
+    end
+
+    # @return [String] the file where all the load paths are stored and
+    # manipulated. This is '$dependencies/init.rb'
+    def init_file
+      @init_file ||= File.join dependencies_dir, 'init.rb'
+    end
+
+    # @return [String] the directory where a package with the given name
+    # should be installed to. Will be '$dependencies/packages/$name'
+    def package_dir_for(name)
+      File.join packages_dir, name
+    end
+
+    # @return [String] the file where a packages' yaml will be written to.
+    # This will be `$dependencies/descriptors/$name.yml'
+    def descriptor_file_for(name)
+      File.join descriptors_dir, "#{name}.yml"
+    end
+
+    # Tries to load a package with the given name in the given directory.
+    # If it can't, it returns nil. We don't throw an error as some methods
+    # use this just to see if one exists.
+    #
+    # @param [String] path the full path to the package
+    # @return [Package] the package loaded
+    def load_package(path)
+      begin
+        Package.load_path path
+      rescue PackageNotFoundError => e
+        nil
+      end
+    end
+
+    # Install all of the dependencies for this package recursively. This
+    # will start with the top level package and install all of its
+    # packages, and then those packages' dependencies.
+    #
+    # If a dependency has already been installed, then it is skipped.
+    def install_dependencies
+      raise "Cannot find root package" unless @package
+
+      bootstrap
+
+      install_dependencies_for @package, true
+    end
+
+    # do the work for a given package..
+    def install_dependencies_for(package, include_dev = false)
+      deps = package.dependencies
+      deps += package.dev_dependencies if include_dev
+
+      puts "* Need to install for `#{package.name}'"
+
+      deps.each do |dep|
+        if installed? dep.name
+          log "Skipping #{dep.name}"
+          next
+        end
+
+        pkg = install_dependency dep
+        puts "installed: #{pkg}"
+
+        install_dependencies_for pkg
+      end
+    end
+
+    # Checkes whether a package with the given name has been installed or
+    # not. Returns true/false.
+    def installed?(name)
+      @installed_packages.each { |p| return true if p.name == name }
+
+      false
+    end
+
+    private
+
+    # @return [Package] returns the package for the installed dependency
+    def install_dependency(dependency = nil, force = false)
+
+      name = dependency.name
+
+      if installed? name
+        raise "Already installed `#{name}'" unless force
+
+        uninstaller = DependencyUninstaller.new name
+
+        log "Uninstalling `#{name}'"
+        uninstaller.uninstall self
+      end
+
+      installer  = DependencyInstaller.new dependency
+
+      log "Installing `#{name}'"
+      package = installer.install self
+
+      return package
+    end
+
+    # This setups the local environment by ensuring that the packages/
+    # directory and init.rb files are ready to use. This should not be
+    # called directly as methods that require the environment call it
+    # automatically.
+    #
+    # The `force` option can be used to reset the environment. This will
+    # simply remove the existing packages directory, and recreate all
+    # needed files. This will therefore require all dependencies to be
+    # re-installed locally.
+    #
+    # @param [Boolean] force whether to clear the environment to start
+    # from scratch.
+    def bootstrap(force = false)
+      packages_dir = self.packages_dir
+      init_file    = self.init_file
+
+      rm_rf packages_dir if force and File.exists? packages_dir
+      return if File.exists?(packages_dir) && File.exists?(init_file)
+
+      mkdir_p packages_dir
+
+      File.open(init_file, 'w+') do |o|
+        init = <<-OUT
+          # root packages' path
+          path = File.expand_path('..', __FILE__)
+
+          # root packages' lib directory
+          $:.unshift File.expand_path("\#{path}/../../lib")
+        OUT
+
+        o.write init.each_line.map { |l| l.lstrip }.join("")
+      end
+    end
+
+    # Simple log we can control with @verbose
+    def log(str)
+      puts str
+    end
+  end
+end
+

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: rbp
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Adam Beynon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-22 00:00:00.000000000Z
+dependencies: []
+description: A ruby package manager for managing local packages
+email:
+- adam@adambeynon.com
+executables:
+- rbp
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rbp
+- lib/rbp/command.rb
+- lib/rbp/dependency.rb
+- lib/rbp/dependency_installer.rb
+- lib/rbp/dependency_uninstaller.rb
+- lib/rbp/git_dependency.rb
+- lib/rbp/installer.rb
+- lib/rbp/package.rb
+- lib/rbp/package_installer.rb
+- lib/rbp/package_manager.rb
+- lib/rbp.rb
+- README.md
+homepage: http://opalscript.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A ruby package manager for managing local packages
+test_files: []