fig 0.1.0

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009, Matthew Foemmel
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * The names of the contributors may not be used to endorse or promote 
+      products derived from this software without specific prior written 
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= fig
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Matthew Foemmel. See LICENSE for details.

data/bin/fig

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'rubygems'
+require 'net/ftp'
+
+require 'fig/options'
+require 'fig/environment'
+require 'fig/repository'
+require 'fig/os'
+require 'fig/parser'
+
+include Fig
+
+def parse_descriptor(descriptor)
+  # todo should use treetop for these:
+  package_name = descriptor =~ /^([^:\/]+)/ ? $1 : nil
+  config_name = descriptor =~ /:([^:\/]+)/ ? $1 : nil
+  version_name = descriptor =~ /\/([^:\/]+)/ ? $1 : nil  
+  return package_name, config_name, version_name
+end
+
+ARGV.each_with_index do |arg, i|
+  if arg == "-"
+    $stderr.puts "Use of single dash (-) is deprecated. Use double dash (--) instead"
+    exit 1 
+  elsif arg == "--"
+    ARGV[i] = "-"
+  end
+end
+
+options, argv = parse_options(ARGV)
+
+vars = {}
+ENV.each {|key,value| vars[key]=value }
+
+remote_url = nil
+if options[:update] || options[:publish]
+  remote_url = ENV['FIG_REMOTE_URL']
+  if remote_url.nil?
+    $stderr.puts "Please define the FIG_REMOTE_URL environment variable" 
+    exit 1
+  end
+end
+
+remote_user = nil
+if options[:publish]
+#  remote_user = ENV['FIG_REMOTE_USER']
+#  if remote_user.nil?
+#    $stderr.puts "Please define the FIG_REMOTE_USER environment variable" 
+#    exit 1
+#  end
+end
+
+os = OS.new
+repos = Repository.new(os, File.expand_path("~/.fighome/repos"), remote_url, remote_user)
+env = Environment.new(os, repos, vars)
+
+options[:includes].each do |descriptor|
+  package_name, config_name, version_name = parse_descriptor(descriptor)
+  puts "Package: #{package_name}, config_name: #{config_name}, Version: #{version_name}"
+  env.include_config(nil, package_name, config_name, version_name)
+end
+
+options[:sets].each do |name_val|
+  env.set_variable(nil, name_val[0], name_val[1]) 
+end
+
+options[:appends].each do |name_val|
+  env.append_variable(nil, name_val[0], name_val[1]) 
+end
+
+if os.exist?("./.fig")
+  package = Parser.new.parse_package(nil, nil, ".", os.read("./.fig"))
+  if options[:retrieve]
+    package.retrieves.each do |var, path|
+      env.add_retrieve(var, path)
+    end
+  end
+  unless options[:publish] || options[:list]
+    env.register_package(package)
+    env.apply_config(package, options[:config])
+  end
+else
+  package = Package.new(nil, nil, ".", [])
+end
+
+if options[:echo]
+  puts env[options[:echo]]
+end
+
+if options[:list]
+  repos.list_packages.sort.each do |item|
+    puts item
+  end
+end
+
+if options[:publish]
+  raise "Unexpected arguments: #{argv.join(' ')}" if !argv.empty?
+  package_name, config_name, version_name = parse_descriptor(options[:publish])
+  if package_name.nil? || version_name.nil?
+    raise "Please specify a package name and a version name"
+  end
+  repos.publish_package(package.publish_statements, package_name, version_name)
+elsif argv[0] == "-"
+  argv.shift
+  env.execute_shell(argv) { |cmd| exec cmd.join(' ') }
+elsif argv[0]
+  package_name, config_name, version_name = parse_descriptor(argv.shift)
+  env.include_config(package, package_name, config_name, version_name)
+  env.execute_config(package, package_name, config_name, nil) { |cmd| exec((cmd + argv).join(' ')) }
+else
+  env.execute_config(package, nil, options[:config], nil) { |cmd| exec((cmd + argv).join(' ')) }
+end

data/lib/fig/environment.rb

@@ -0,0 +1,137 @@
+module Fig
+
+  # This class manages the program's state, including the value of all environment 
+  # variables, and which packages have already been applied
+  class Environment
+    DEFAULT_VERSION_NAME = "current"
+
+    def initialize(os, repository, variables)
+      @os = os
+      @repository = repository
+      @variables = variables
+      @retrieve_vars = {}
+      @packages = {}
+    end
+
+    # Returns the value of an envirionment variable
+    def [](name)
+      @variables[name]
+    end
+
+    # Indicates that the values from a particular envrionment variable path should
+    # be copied to a local directory 
+    def add_retrieve(name, path)
+      @retrieve_vars[name] = path
+    end
+
+    def register_package(package)
+      name = package.package_name
+      raise "Package already exists with name: #{name}" if @packages[name]
+      @packages[name] = package
+    end
+
+    def apply_config(package, config_name)
+      config = package[config_name]
+      config.statements.each { |stmt| apply_config_statement(package, stmt) }
+    end
+
+    def execute_shell(command)
+      with_environment do
+        yield command.map{|arg| expand_arg(arg)}
+      end
+    end
+
+    def execute_config(base_package, package_name, config_name, version_name)
+      package = lookup_package(package_name || base_package.package_name, version_name)
+      result = nil
+      commands = package[config_name || "default"].commands
+      with_environment do
+        # todo nil check
+        commands.each do |command|
+          result = yield expand_arg(command.command).gsub("@",package.directory).split(" ")
+        end
+      end
+      result
+    end
+
+    def include_config(base_package, package_name, config_name, version_name)
+      package = lookup_package(package_name || base_package.package_name, version_name)
+      apply_config(package, config_name || "default")
+    end
+
+    def set_variable(base_package, name, value)
+      @variables[name] = expand_value(base_package, name, value)
+    end
+
+    def append_variable(base_package, name, value)
+      value = expand_value(base_package, name, value)
+      prev = @variables[name]
+      if prev
+        @variables[name] = prev + File::PATH_SEPARATOR + value
+      else
+        @variables[name] = value
+      end
+    end
+
+    private 
+
+    def with_environment
+      old_env = {}
+      begin
+        @variables.each { |key,value| old_env[key] = ENV[key]; ENV[key] = value }
+        yield
+      ensure
+        old_env.each { |key,value| ENV[key] = value }
+      end
+    end
+
+    def apply_config_statement(base_package, statement)
+      case statement
+      when Path
+        append_variable(base_package, statement.name, statement.value)
+      when Set
+        set_variable(base_package, statement.name, statement.value)
+      when Include
+        include_config(base_package, statement.package_name, statement.config_name, statement.version_name)
+      when Command
+        # ignore
+      else
+        fail "Unexpected statement: #{statement}"
+      end
+    end
+
+    def lookup_package(package_name, version_name)
+      package = @packages[package_name]
+      if package.nil?
+        package = @repository.load_package(package_name, version_name || DEFAULT_VERSION_NAME)
+        @packages[package_name] = package
+      elsif version_name && version_name != package.version_name
+        raise "Version mismatch: #{package_name}" 
+      end
+      package
+    end
+
+    # Replace @ symbol with the package's directory
+    def expand_value(base_package, name, value)
+      return value if base_package.nil?
+      file = value.gsub(/\@/, base_package.directory)
+      if @retrieve_vars.member?(name)
+        target = File.join(@retrieve_vars[name].gsub(/\[package\]/, base_package.package_name), File.basename(file))
+        unless @os.exist?(target) && @os.mtime(target) >= @os.mtime(file)
+          @os.log_info("retrieving #{target}")
+          @os.copy(file, target)
+        end
+        file = target
+      end
+      file
+    end
+
+    def expand_arg(arg)
+      arg.gsub(/\@([a-zA-Z0-9\-\.]+)/) do |match|
+        package = @packages[$1]
+        raise "Package not found: #{$1}" if package.nil?
+        package.directory
+      end
+    end
+  end
+end

data/lib/fig/grammar.treetop

@@ -0,0 +1,149 @@
+require 'fig/package'
+
+module Fig
+
+grammar Fig
+  rule package
+    ws statements:(package_statement*) {
+      def to_package(package_name, version_name, directory)
+        Package.new(package_name, version_name, directory, statements.elements.map { |statement| statement.to_package_statement })
+      end
+    }
+  end
+
+  rule package_statement
+    archive / resource / retrieve / config / publish 
+  end
+
+  rule archive
+    "archive" ws url {
+      def to_package_statement
+        Archive.new(url.value.text_value)
+      end
+    }
+  end
+
+  rule resource
+    "resource" ws url {
+      def to_package_statement
+        Resource.new(url.value.text_value)
+      end
+    }
+  end
+
+  rule retrieve
+    "retrieve" ws var:[a-zA-Z0-9]+ "->" path:[a-zA-Z0-9/\.-\[\]]+ ws {
+      def to_package_statement
+        Retrieve.new(var.text_value, path.text_value)
+      end
+    }
+  end
+
+  rule publish
+    "publish" ws statements:(package_statement / install)* "end" ws {
+      def to_package_statement
+        Publish.new(statements.elements.map { |statement| statement.to_package_statement })
+      end
+    }
+  end
+
+  rule install
+    "install" ws statements:config_statement* "end" ws {
+      def to_package_statement
+        Install.new(statements.elements.map { |statement| statement.to_config_statement })
+      end
+    }
+  end
+
+  rule config
+    "config" ws config_name ws statements:config_statement* "end" ws {
+      def to_package_statement
+        Configuration.new(config_name.text_value, statements.elements.map { |statement| statement.to_config_statement })
+      end
+    }
+  end
+
+  rule config_statement
+    include / command / path / set
+  end
+
+  rule include
+    "include" ws descriptor {
+      def to_config_statement
+        package = descriptor.respond_to?(:package) ? descriptor.package.text_value : nil
+        config = descriptor.get_config
+        version = descriptor.get_version
+        Include.new(package, config, version)
+      end
+    }
+  end
+
+  rule path
+    "append" ws name:[a-zA-Z0-9]+ "=" value:[@a-zA-Z0-9/\-\\._]+ ws {
+      def to_config_statement
+        Path.new(name.text_value, value.text_value)
+      end
+    }
+  end
+
+  rule set
+    "set" ws name:[a-zA-Z0-9]+ "=" value:[@a-zA-Z0-9/\-\\._]+ ws {
+      def to_config_statement
+        Set.new(name.text_value, value.text_value)
+      end
+    }
+  end
+
+  rule command
+    "command" ws string {
+      def to_config_statement
+        Command.new(string.value.text_value)
+      end
+    }
+  end
+
+  rule string
+    '"' value:(!'"' . )* '"' ws
+  end
+
+  rule descriptor
+    ((package:[a-zA-Z0-9.-]+ ("/" version:[a-zA-Z0-9.\-]+)? (":" config:config_name)? ws) / 
+    (":" config:config_name ws)) {
+      def get_version
+        elements.each do |element|
+          if element.respond_to?(:version)
+            return element.version.text_value
+          end
+        end
+        nil
+      end
+      def get_config
+        return self.config.text_value if self.respond_to?(:config)
+        elements.each do |element|
+          if element.respond_to?(:config)
+            return element.config.text_value
+          end
+        end
+        nil
+      end
+    }
+  end
+
+  rule config_name
+    [a-zA-Z0-9\\-]+
+  end
+
+  rule name
+    value:[a-zA-Z0-9]+ ws
+  end
+
+  rule url
+    '"' value:[a-zA-Z0-9:/\-\\._]+ '"' ws
+  end
+
+  rule ws
+    [ \n\t]+
+  end
+end
+
+end

data/lib/fig/options.rb

@@ -0,0 +1,49 @@
+require 'optparse'
+
+module Fig
+  def parse_options(argv)
+    options = {}
+
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: fig [--debug] [--update] [--config <config>] [-echo <var> | --list | <package> | - <command>]"
+
+      opts.on('-?', '-h','--help','display this help text') do
+        puts opts
+	exit 1
+      end 
+
+      options[:debug] = false
+      opts.on('-d', '--debug', 'print debug info') { options[:debug] = true }
+
+      options[:update] = false
+      opts.on('-u', '--update', 'check remote repository for updates') { options[:update] = true; options[:retrieve] = true }
+
+      options[:config] = "default"
+      opts.on('-c', '--config CFG', 'name of configuration to apply') { |config| options[:config] = config }
+
+      options[:echo] = nil
+      opts.on('-g', '--echo VAR', 'print value of environment variable') { |echo| options[:echo] = echo }
+
+      options[:publish] = nil
+      opts.on('--publish PKG', 'install package in local and remote repositories') { |publish| options[:publish] = publish }
+
+      options[:list] = false
+      opts.on('--list', 'list packages in local repository') { options[:list] = true }
+
+      options[:includes] = []
+      opts.on('-i', '--include PKG', 'include package in environment') { |descriptor| options[:includes] << descriptor }
+
+      options[:sets] = []
+      opts.on('-s', '--set VAR=VAL', 'set environment variable') { |var_val| options[:sets] << var_val.split('=') }
+
+      options[:appends] = []
+      opts.on('-p', '--append VAR=VAL', 'append environment variable') { |var_val| options[:appends] << var_val.split('=') }
+
+      options[:home] = ENV['FIG_HOME'] || File.expand_path("~/.fighome")
+    end
+
+    parser.parse!(argv)
+
+    return options, argv
+  end
+end

data/lib/fig/os.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+require 'ftools'
+require 'uri'
+require 'net/http'
+
+module Fig
+ class OS
+   def list(dir)
+     Dir.entries(dir) - ['.','..']
+   end
+
+   def exist?(path)
+     File.exist?(path)
+   end
+
+   def mtime(path)
+     File.mtime(path)
+   end
+
+   def read(path)
+     File.read(path)
+   end
+
+   def write(path, content)
+     File.open(path, "w") { |f| f << content }
+   end
+
+   def download(url, path)
+     FileUtils.mkdir_p(File.dirname(path))
+     uri = URI.parse(url)
+     case uri.scheme
+     when "ftp"
+       ftp = Net::FTP.new(uri.host)
+       ftp.login
+       if File.exist?(path) && ftp.mtime(uri.path) <= File.mtime(path)
+         return false
+       else 
+         puts "downloading #{url}"
+         ftp.getbinaryfile(uri.path, path, 256*1024)
+         return true
+       end
+     when "http"
+       http = Net::HTTP.new(uri.host)
+       puts "downloading #{url}"
+       File.open(path, "w") do |file|
+         http.get(uri.path) do |block|
+           file.write(block)
+         end
+       end
+     else
+       raise "Unknown protocol: #{url}"
+     end
+   end
+
+   def download_resource(url, dir)
+     FileUtils.mkdir_p(dir)
+     download(url, File.join(dir, URI.parse(url).path.split('/').last))
+   end
+
+   def download_archive(url, dir)
+     FileUtils.mkdir_p(dir)
+     basename = URI.parse(url).path.split('/').last
+     path = File.join(dir, basename)
+     download(url, path)
+     case basename
+     when /\.tar\.gz$/
+       fail unless system "tar -C #{dir} -zxf #{path}"
+     when /\.tgz$/
+       fail unless system "tar -C #{dir} -zxf #{path}"
+     when /\.tar\.bz2$/
+       fail unless system "tar -C #{dir} -jxf #{path}"       
+     when /\.zip$/
+       fail unless system "unzip -q -d #{dir} #{path}"
+     else
+       raise "Unknown archive type: #{basename}"
+     end
+   end
+
+   def upload(local_file, remote_file, user)
+     puts "uploading #{remote_file}"
+       fail unless system "curl -p -T #{local_file} --create-dirs --ftp-create-dirs #{remote_file}"
+   end
+
+   def clear_directory(dir)
+     FileUtils.rm_rf(dir)
+     FileUtils.mkdir_p(dir)
+   end
+
+   def exec(dir,command)
+     Dir.chdir(dir) { raise "Command failed" unless system command }
+   end
+
+   def copy(source, target)
+     FileUtils.mkdir_p(File.dirname(target))
+     File.copy(source, target)
+     target
+   end
+
+   def log_info(msg)
+     puts msg
+   end
+ end
+end

data/lib/fig/package.rb

@@ -0,0 +1,195 @@
+module Fig
+  class Package
+    attr_reader :package_name, :version_name, :directory, :statements
+    
+    def initialize(package_name, version_name, directory, statements) 
+      @package_name = package_name
+      @version_name = version_name
+      @directory = directory
+      @statements = statements
+    end
+
+    def [](config_name)
+      @statements.each do |stmt|
+        return stmt if stmt.is_a?(Configuration) && stmt.name == config_name
+      end
+      raise "Configuration not found: #{@package_name}/#{@version_name}:#{config_name}"
+    end
+
+    def retrieves
+      retrieves = {}
+      statements.each { |statement| retrieves[statement.var] = statement.path if statement.is_a?(Retrieve) }
+      retrieves
+    end
+    def archive_urls
+      @statements.select{|s| s.is_a?(Archive)}.map{|s|s.url}
+    end
+    
+    def resource_urls
+      @statements.select{|s| s.is_a?(Resource)}.map{|s|s.url}
+    end
+    
+    def publish_statements
+      statements = []
+      @statements.each{ |s| statements += s.statements if s.is_a?(Publish) }
+      statements
+    end
+    
+    def unparse
+      @statements.map { |statement| statement.unparse('') }.join("\n")
+    end
+
+    def ==(other)
+      @package_name == other.package_name && @version_name == other.version_name && @statements.to_yaml == other.statements.to_yaml
+    end
+  end
+  
+  class Archive
+    attr_reader :url
+    
+    def initialize(url)
+      @url = url
+    end
+    
+    def unparse(indent)
+      "#{indent}archive \"#{url}\""
+    end
+  end
+  
+  class Resource
+    attr_reader :url
+    
+    def initialize(url)
+      @url = url
+    end
+    
+    def unparse(indent)
+      "#{indent}resource \"#{url}\""
+    end
+  end
+  
+  class Retrieve
+    attr_reader :var, :path
+
+    def initialize(var, path)
+      @var = var
+      @path = path
+    end
+
+    def unparse(indent)
+      "#{indent}retrieve #{var}->#{path}"
+    end
+  end
+
+  class Publish
+    attr_reader :statements
+
+    def initialize(statements)
+      @statements = statements
+    end
+    
+    def unparse(indent)
+      prefix = "\n#{indent}publish"
+      body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+      suffix = "#{indent}end"
+      return [prefix, body, suffix].join("\n")
+    end
+  end
+
+  class Install
+    def initialize(statements)
+      @statements = statements
+    end
+
+    def unparse(indent)
+      prefix = "\n#{indent}install"
+      body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+      suffix = "#{indent}end"
+      return [prefix, body, suffix].join("\n")
+    end 
+  end
+  
+  class Configuration
+    attr_reader :name, :statements
+
+    def initialize(name, statements)
+      @name = name
+      @statements = statements
+    end
+
+    def commands
+      result = statements.select { |statement| statement.is_a?(Command) }
+#      if result.empty?
+#        raise "No commands found for config: #{@name}"
+#      end
+      result
+    end
+
+    def unparse(indent)
+      unparse_statements(indent, "config #{@name}", @statements, "end")
+    end
+  end
+
+  class Path
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+  
+    def unparse(indent)
+      "#{indent}append #{name}=#{value}"
+    end
+  end
+
+  class Set
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+  
+    def unparse(indent)
+      "#{indent}set #{name}=#{value}"
+    end
+  end
+
+  class Include
+    attr_reader :package_name, :config_name, :version_name
+
+    def initialize(package_name, config_name, version_name)
+      @package_name = package_name
+      @config_name = config_name
+      @version_name = version_name
+    end
+
+    def unparse(indent)
+      descriptor = ""
+      descriptor += @package_name if @package_name
+      descriptor += "/#{@version_name}" if @version_name
+      descriptor += ":#{@config_name}" if @config_name
+      "#{indent}include #{descriptor}"
+    end
+  end
+
+  class Command
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+    end
+
+    def unparse(indent)
+      "#{indent}command \"#{@command}\""
+    end
+  end
+
+end
+
+def unparse_statements(indent, prefix, statements, suffix)
+  body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+  return ["\n#{indent}#{prefix}", body, "#{indent}#{suffix}"].join("\n")
+end   
+

data/lib/fig/parser.rb

@@ -0,0 +1,25 @@
+require 'polyglot'
+require 'treetop'
+
+require 'fig/grammar'
+
+module Fig
+  class Parser
+    def initialize
+      @parser = FigParser.new
+    end
+
+    def parse_package(package_name, version_name, directory, input)
+      result = @parser.parse(" #{input} ")
+      if result.nil? 
+        raise "#{directory}: #{@parser.failure_reason}"
+      end
+      result.to_package(package_name, version_name, directory)
+    end
+
+    def parse_descriptor(descriptor)
+      puts @parser.methods.sort
+    end
+  end
+
+end

data/lib/fig/repository.rb

@@ -0,0 +1,149 @@
+require 'fig/parser'
+
+module Fig
+  class Repository
+    def initialize(os, local_repository_dir, remote_repository_url, remote_repository_user=nil)
+      @os = os
+      @local_repository_dir = local_repository_dir
+      @remote_repository_url = remote_repository_url
+      @remote_repository_user = remote_repository_user
+      @parser = Parser.new
+    end
+
+    def list_packages
+      results = []
+      @os.list(@local_repository_dir).each do |package_name|
+        @os.list(File.join(@local_repository_dir, package_name)).each do |version_name|
+          results << "#{package_name}/#{version_name}"
+        end
+      end
+      results
+    end
+
+    def publish_package(package_statements, package_name, version_name) 
+      temp_dir = temp_dir_for_package(package_name, version_name)
+      @os.clear_directory(temp_dir)
+      fig_file = File.join(temp_dir, ".fig")
+      content = package_statements.map do |statement| 
+        if statement.is_a?(Archive) || statement.is_a?(Resource)
+          archive_name = statement.url.split("/").last
+          archive_remote = "#{remote_dir_for_package(package_name, version_name)}/#{archive_name}"
+          if is_url?(statement.url)
+            archive_local = File.join(temp_dir, archive_name)
+            @os.download(statement.url, archive_local)
+          else
+            archive_local = statement.url
+          end
+          @os.upload(archive_local, archive_remote, @remote_repository_user)
+          statement.class.new(archive_name).unparse('')
+        else
+          statement.unparse('')
+        end
+      end
+      @os.write(fig_file, content.join("\n"))
+      @os.upload(fig_file, remote_fig_file_for_package(package_name, version_name), @remote_repository_user)
+      update_package(package_name, version_name)
+    end
+
+    def load_package(package_name, version_name)
+      update_package(package_name, version_name) if @remote_repository_url
+      read_local_package(package_name, version_name)
+    end
+
+    def update_package(package_name, version_name)
+      remote_fig_file = remote_fig_file_for_package(package_name, version_name)
+      local_fig_file = local_fig_file_for_package(package_name, version_name)
+      if @os.download(remote_fig_file, local_fig_file)
+        install_package(package_name, version_name)
+      end
+    end
+
+    def read_local_package(package_name, version_name)
+      dir = local_dir_for_package(package_name, version_name)
+      read_package_from_directory(dir, package_name, version_name)
+    end 
+
+    def read_remote_package(package_name, version_name)
+      url = remote_fig_file_for_package(package_name, version_name)
+      content = @os.read_url(url)
+      @parser.parse_package(package_name, version_name, nil, content)
+    end
+
+    def read_package_from_directory(dir, package_name, version_name)
+      read_package_from_file(File.join(dir, ".fig"), package_name, version_name)
+    end
+
+    def read_package_from_file(file_name, package_name, version_name)
+      raise "Package not found: #{file_name}" unless @os.exist?(file_name)
+      modified_time = @os.mtime(file_name)
+      content = @os.read(file_name)
+      @parser.parse_package(package_name, version_name, File.dirname(file_name), content)
+    end
+
+    def local_dir_for_package(package_name, version_name)
+      File.join(@local_repository_dir, package_name, version_name)
+    end
+
+  private
+
+    def install_package(package_name, version_name)
+      begin
+        package = read_local_package(package_name, version_name)
+        temp_dir = temp_dir_for_package(package_name, version_name)
+        @os.clear_directory(temp_dir)
+        package.archive_urls.each do |archive_url|
+          if not is_url?(archive_url)
+            archive_url = remote_dir_for_package(package_name, version_name) + "/" + archive_url
+          end
+          @os.download_archive(archive_url, File.join(temp_dir))
+        end
+        package.resource_urls.each do |resource_url|
+          if not is_url?(resource_url)
+            resource_url = remote_dir_for_package(package_name, version_name) + "/" + resource_url
+          end
+          @os.download_resource(resource_url, File.join(temp_dir))
+        end
+        local_dir = local_dir_for_package(package_name, version_name)
+        @os.clear_directory(local_dir)
+        # some packages contain no files, only a fig file.
+        if not (package.archive_urls.empty? && package.resource_urls.empty?)
+          @os.exec(temp_dir, "mv * #{local_dir}/")
+        end
+        write_local_package(package_name, version_name, package)
+      rescue
+        $stderr.puts "install failed, cleaning up" 
+        delete_local_package(package_name, version_name)
+        raise
+      end
+    end
+
+    def is_url?(url)
+      not (/ftp:\/\/|http:\/\/|file:\/\/|ssh:\/\// =~ url).nil?
+    end
+
+    def delete_local_package(package_name, version_name)
+      FileUtils.rm_rf(local_dir_for_package(package_name, version_name))
+    end
+
+    def write_local_package(package_name, version_name, package)
+      file = local_fig_file_for_package(package_name, version_name)
+      @os.write(file, package.unparse)
+    end
+
+    def remote_fig_file_for_package(package_name, version_name)
+      "#{@remote_repository_url}/#{package_name}/#{version_name}/.fig"
+    end  
+
+    def local_fig_file_for_package(package_name, version_name)
+      File.join(local_dir_for_package(package_name, version_name), ".fig")
+    end
+
+    def remote_dir_for_package(package_name, version_name)
+      "#{@remote_repository_url}/#{package_name}/#{version_name}"
+    end
+
+    def temp_dir_for_package(package_name, version_name)
+      File.join(@local_repository_dir, "tmp")
+    end
+  end
+end

data/spec/fig_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Fig" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'fig'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: fig
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthew Foemmel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-29 00:00:00 -06:00
+default_executable: fig
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: polyglot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: |-
+  Fig is a utility for dynamically assembling an
+        environment from a set of packages. Shell commands can then be 
+        executed in that environment, after which the environment
+        is thrown away. The caller's environment is never affected.
+email: git@foemmel.com
+executables: 
+- fig
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- bin/fig
+- lib/fig.rb
+- lib/fig/environment.rb
+- lib/fig/grammar.treetop
+- lib/fig/options.rb
+- lib/fig/os.rb
+- lib/fig/package.rb
+- lib/fig/parser.rb
+- lib/fig/repository.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/mfoemmel/fig
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Fig is a utility for dynamically assembling an environment from a set of packages.
+test_files: 
+- spec/fig_spec.rb
+- spec/spec_helper.rb