fig18 0.1.50-i386-mswin32 → 0.1.51-i386-mswin32

data/Changes

@@ -1,3 +1,7 @@
+v0.1.51
+
+  - You can now set an environment variable to the empty string with "set".
+
 v0.1.50
 
   - Trying to get releases via rake to work properly for multiple platforms.

data/VERSION

@@ -1 +1 @@
-0.1.50
+0.1.51

data/lib/fig.rb

@@ -16,6 +16,7 @@ require 'fig/retriever'
 require 'fig/userinputerror'
 require 'fig/windows'
 
+# Main program
 module Fig
   DEFAULT_FIG_FILE = 'package.fig'
 
@@ -27,7 +28,15 @@ module Fig
     return package_name, config_name, version_name
   end
 
-  def run_fig(argv)
+  def read_in_package_config_file(options)
+    if File.exist?(options[:package_config_file])
+      return File.read(options[:package_config_file])
+    else
+      raise UserInputError.new(%Q<File not found: "#{options[:package_config_file]}".>)
+    end
+  end
+
+  def initialize_shell_command(argv)
     shell_command = nil
     argv.each_with_index do |arg, i|
       if arg == '--'
@@ -37,168 +46,204 @@ module Fig
       end
     end
 
-    options, argv, exit_value = parse_options(argv)
-    if not exit_value.nil?
-      return exit_value
-    end
-
-    Logging.initialize_pre_configuration(options[:log_level])
-
-    vars = {}
-    ENV.each {|key,value| vars[key]=value }
+    return shell_command
+  end
 
-    remote_url = nil
+  def initialize_remote_url(options)
     if options[:update] || options[:publish] || options[:update_if_missing] || options[:list_remote]
-      remote_url = ENV['FIG_REMOTE_URL']
-      if remote_url.nil?
-        $stderr.puts 'Please define the FIG_REMOTE_URL environment variable.'
-        return 1
+      if ENV['FIG_REMOTE_URL'].nil?
+        raise UserInputError.new 'Please define the FIG_REMOTE_URL environment variable.'
       end
+      return ENV['FIG_REMOTE_URL']
     end
 
-    configuration = FigRC.find(
-      options[:figrc],
-      remote_url,
-      options[:login],
-      options[:home],
-      options[:no_figrc]
-    )
-
-    Logging.initialize_post_configuration(options[:log_config] || configuration['log configuration'], options[:log_level])
+    return nil
+  end
 
-    remote_user = nil
+  def load_package_config_file_contents(options)
+    package_config_file = options[:package_config_file]
 
-    os = OS.new(options[:login])
-    repos = Repository.new(
-      os,
-      File.expand_path(File.join(options[:home], 'repos')),
-      remote_url,
-      configuration,
-      remote_user,
-      options[:update],
-      options[:update_if_missing]
-    )
-    retriever = Retriever.new('.')
-    # Check to see if this is still happening with the new layers of abstraction.
-    at_exit { retriever.save }
-    env = Environment.new(os, repos, vars, retriever)
+    if package_config_file == :none
+      return nil
+    elsif package_config_file == '-'
+      return $stdin.read
+    elsif package_config_file.nil?
+      if File.exist?(DEFAULT_FIG_FILE)
+        return File.read(DEFAULT_FIG_FILE)
+      end
+    else
+      return read_in_package_config_file(options)
+    end
+  end
 
-    options[:modifiers].each do |modifier|
-      env.apply_config_statement(nil, modifier, nil)
+  def display_package_list(repository)
+    repository.list_packages.sort.each do |item|
+      puts item
     end
+  end
 
-    package_config_file = nil
-    if options[:package_config_file] == :none
-      # ignore
-    elsif options[:package_config_file] == '-'
-      package_config_file = $stdin.read
-    elsif options[:package_config_file].nil?
-      package_config_file = File.read(DEFAULT_FIG_FILE) if File.exist?(DEFAULT_FIG_FILE)
-    else
-      if File.exist?(options[:package_config_file])
-        package_config_file = File.read(options[:package_config_file])
-      else
-        $stderr.puts %Q<File not found: "#{options[:package_config_file]}".>
-        return 1
-      end
+  def display_remote_package_list(repository)
+    repository.list_remote_packages.sort.each do |item|
+      puts item
     end
+  end
 
-    options[:cleans].each do |descriptor|
+  def display_configs_in_local_packages_list(options, repository)
+    options[:list_configs].each do |descriptor|
       package_name, version_name = descriptor.split('/')
-      repos.clean(package_name, version_name)
+      repository.read_local_package(package_name, version_name).configs.each do |config|
+        puts config.name
+      end
     end
+  end
+
+  def resolve_listing(options, repository)
     if options[:list]
-      repos.list_packages.sort.each do |item|
-        puts item
-      end
-      return 0
+      display_package_list(repository)
+      return true
     end
 
     if options[:list_remote]
-      repos.list_remote_packages.sort.each do |item|
-        puts item
-      end
-      return 0
+      display_remote_package_list(repository)
+      return true
     end
 
     if not options[:list_configs].empty?
-      options[:list_configs].each do |descriptor|
-        package_name, version_name = descriptor.split('/')
-        repos.read_local_package(package_name, version_name).configs.each do |config|
-          puts config.name
-        end
-      end
-      return 0
+      display_configs_in_local_packages_list(options, repository)
+      return true
     end
 
+    return false
+  end
+
+  def parse_package_config_file(options, package_config_file, environment, configuration)
     if package_config_file
       package = Parser.new(configuration).parse_package(nil, nil, '.', package_config_file)
-      direct_retrieves=[]
       if options[:update] || options[:update_if_missing]
         package.retrieves.each do |var, path|
-          if var =~ %r< ^ \@ ([^/]+) (.*) >x
-            direct_retrieves << [$1, $2, path]
-          else
-            env.add_retrieve(var, path)
-          end
+          environment.add_retrieve(var, path)
         end
       end
+
       unless options[:publish] || options[:list] || options[:publish_local]
-        env.register_package(package)
-        env.apply_config(package, options[:config], nil)
-        direct_retrieves.each do |info|
-          env.direct_retrieve(info[0], info[1], info[2])
-        end
+        environment.register_package(package)
+        environment.apply_config(package, options[:config], nil)
       end
     else
       package = Package.new(nil, nil, '.', [])
     end
 
-    if options[:publish] || options[:publish_local]
-      if !argv.empty?
-        $stderr.puts %Q<Unexpected arguments: #{argv.join(' ')}>
-        return 10
-      end
-      package_name, config_name, version_name = parse_descriptor(options[:publish] || options[:publish_local])
-      if package_name.nil? || version_name.nil?
-        $stderr.puts 'Please specify a package name and a version name.'
-        return 10
-      end
-      if not options[:modifiers].empty?
-        publish_statements = options[:resources] + options[:archives] + [Package::Configuration.new('default', options[:modifiers])]
-        publish_statements << Package::Publish.new('default','default')
-      elsif not package.statements.empty?
-        publish_statements = package.statements
-      else
-        $stderr.puts 'Nothing to publish.'
-        return 1
-      end
-      if options[:publish]
-        Logging.info "Checking status of #{package_name}/#{version_name}..."
-        if repos.list_remote_packages.include?("#{package_name}/#{version_name}")
-          Logging.info "#{package_name}/#{version_name} has already been published."
-          if not options[:force]
-            Logging.fatal 'Use the --force option if you really want to overwrite, or use --publish-local for testing.'
-            return 1
-          else
-            Logging.info 'Overwriting...'
-          end
+    return package, environment
+  end
+
+  def publish(argv, options, package, repository)
+    if not argv.empty?
+      $stderr.puts %Q<Unexpected arguments: #{argv.join(' ')}>
+      return 10
+    end
+
+    package_name, config_name, version_name = parse_descriptor(options[:publish] || options[:publish_local])
+
+    if package_name.nil? || version_name.nil?
+      $stderr.puts 'Please specify a package name and a version name.'
+      return 10
+    end
+
+    if not options[:non_command_package_statements].empty?
+      publish_statements = options[:resources] + options[:archives] + [Package::Configuration.new('default', options[:non_command_package_statements])]
+      publish_statements << Package::Publish.new('default','default')
+    elsif not package.statements.empty?
+      publish_statements = package.statements
+    else
+      $stderr.puts 'Nothing to publish.'
+      return 1
+    end
+
+    if options[:publish]
+      Logging.info "Checking status of #{package_name}/#{version_name}..."
+
+      if repository.list_remote_packages.include?("#{package_name}/#{version_name}")
+        Logging.info "#{package_name}/#{version_name} has already been published."
+
+        if not options[:force]
+          Logging.fatal 'Use the --force option if you really want to overwrite, or use --publish-local for testing.'
+          return 1
+        else
+          Logging.info 'Overwriting...'
         end
       end
-      Logging.info "Publishing #{package_name}/#{version_name}."
-      repos.publish_package(publish_statements, package_name, version_name, options[:publish_local])
-    elsif options[:echo]
-      puts env[options[:echo]]
+    end
+
+    Logging.info "Publishing #{package_name}/#{version_name}."
+    repository.publish_package(publish_statements, package_name, version_name, options[:publish_local])
+
+    return 0
+  end
+
+  def run_fig(argv)
+    shell_command = initialize_shell_command(argv)
+
+    options, argv, exit_value = parse_options(argv)
+    if not exit_value.nil?
+      return exit_value
+    end
+
+    Logging.initialize_pre_configuration(options[:log_level])
+
+    remote_url = initialize_remote_url(options)
+
+    configuration = FigRC.find(
+      options[:figrc], remote_url, options[:login], options[:home], options[:no_figrc]
+    )
+
+    Logging.initialize_post_configuration(options[:log_config] || configuration['log configuration'], options[:log_level])
+
+    os = OS.new(options[:login])
+    repository = Repository.new(
+      os,
+      File.expand_path(File.join(options[:home], 'repos')),
+      remote_url,
+      configuration,
+      nil, # remote_user
+      options[:update],
+      options[:update_if_missing]
+    )
+
+    retriever = Retriever.new('.')
+    # Check to see if this is still happening with the new layers of abstraction.
+    at_exit { retriever.save }
+    environment = Environment.new(os, repository, nil, retriever)
+
+    options[:non_command_package_statements].each do |statement|
+      environment.apply_config_statement(nil, statement, nil)
+    end
+
+    package_config_file = load_package_config_file_contents(options)
+
+    options[:cleans].each do |descriptor|
+      package_name, version_name = descriptor.split('/')
+      repository.clean(package_name, version_name)
+      return true
+    end
+
+    if resolve_listing(options, repository)
+      return true
+    end
+
+    package, environment = parse_package_config_file(options, package_config_file, environment, configuration)
+
+    if options[:publish] || options[:publish_local]
+      return publish(argv, options, package, repository)
+    elsif options[:get]
+      puts environment[options[:get]]
     elsif shell_command
       argv.shift
-      env.execute_shell(shell_command) { |cmd| os.shell_exec cmd }
-    elsif argv[0]
-      package_name, config_name, version_name = parse_descriptor(argv.shift)
-      env.include_config(package, package_name, config_name, version_name, {}, nil)
-      env.execute_config(package, package_name, config_name, nil, argv) { |cmd| os.shell_exec cmd }
+      environment.execute_shell(shell_command) { |cmd| os.shell_exec cmd }
     elsif not argv.empty?
-      env.execute_config(package, nil, options[:config], nil, argv) { |cmd| os.shell_exec cmd }
-    elsif not repos.updating?
+      package_name, config_name, version_name = parse_descriptor(argv.shift)
+      environment.include_config(package, package_name, config_name, version_name, {}, nil)
+      environment.execute_config(package, package_name, config_name, nil, argv) { |cmd| os.shell_exec cmd }
+    elsif not repository.updating?
       $stderr.puts "Nothing to do.\n"
       $stderr.puts USAGE
       $stderr.puts %q<Run "fig --help" for a full list of commands.>
@@ -208,37 +253,36 @@ module Fig
     return 0
   end
 
+  def log_error_message(error)
+    # If there's no message, we assume that the cause has already been logged.
+    if error_has_message?(error)
+      Logging.fatal error.to_s
+    end
+  end
+
   def run_with_exception_handling(argv)
     begin
       return_code = run_fig(argv)
       return return_code
-    rescue URLAccessError => exception
+    rescue URLAccessError => error
       urls = exception.urls.join(', ')
       $stderr.puts "Access to #{urls} in #{exception.package}/#{exception.version} not allowed."
       return 1
-    rescue UserInputError => exception
-      # If there's no message, we assume that the cause has already been logged.
-      if not exception_has_message?(exception)
-        Logging.fatal exception.to_s
-      end
-
+    rescue UserInputError => error
+      log_error_message(error)
       return 1
-    rescue OptionParser::InvalidOption => exception
-      $stderr.puts exception.to_s
+    rescue OptionParser::InvalidOption => error
+      $stderr.puts error.to_s
       $stderr.puts USAGE
       return 1
     rescue RepositoryError => error
-      # If there's no message, we assume that the cause has already been logged.
-      if not exception_has_message?(error)
-        Logging.fatal error.to_s
-      end
-
+      log_error_message(error)
       return 1
     end
   end
 
-  def exception_has_message?(exception)
-    class_name = exception.class.name
-    return exception.message == class_name
+  def error_has_message?(error)
+    class_name = error.class.name
+    return error.message != class_name
   end
 end

data/lib/fig/applicationconfiguration.rb

@@ -1,5 +1,6 @@
-
 module Fig
+  # Configuration for the Fig program, as opposed to the configuration for a
+  # package.
   class ApplicationConfiguration
     def initialize(remote_repository_url)
       @data = []

data/lib/fig/backtrace.rb

@@ -1,3 +1,5 @@
+# Contains traces of file inclusions so that the user can track down which file
+# an error occurred in.
 class Backtrace
   attr_reader :overrides
 

data/lib/fig/environment.rb

@@ -7,23 +7,31 @@ require 'fig/package/include'
 require 'fig/package/path'
 require 'fig/package/set'
 require 'fig/repositoryerror'
+require 'fig/userinputerror'
 
 module Fig
-  # This class manages the program's state, including the value of all
-  # environment variables, and which packages have already been applied.
+  # Manages the program's metadata, including packages and environment
+  # variables, and sets things up for running commands (from "command"
+  # statements in configuration files).
   class Environment
     DEFAULT_VERSION_NAME = 'current'
 
-    def initialize(os, repository, variables, retriever)
+    def initialize(os, repository, variables_override, retriever)
       @os = os
       @repository = repository
-      @variables = variables
+      @variables = variables_override || get_environment_variables
       @retrieve_vars = {}
       @packages = {}
       @applied_configs = {}
       @retriever = retriever
     end
 
+    def get_environment_variables
+      vars = {}
+      ENV.each { |key,value| vars[key]=value }
+      return vars
+    end
+
     # Returns the value of an envirionment variable
     def [](name)
       @variables[name]
@@ -60,26 +68,35 @@ module Fig
       end
     end
 
-    def execute_config(base_package, package_name, config_name, version_name, args)
+    def execute_command(command, args, package)
+      with_environment do
+        argument =
+          expand_command_line_argument(
+            "#{command.command} #{args.join(' ')}"
+          )
+
+        yield expand_path(argument, package).split(' ')
+      end
+    end
+
+    def find_config_name_in_package(package_name)
+      return @applied_configs.key?(package_name) ? @applied_configs[package_name].first : 'default'
+    end
+
+    def execute_config(base_package, package_name, config_name, version_name, args, &block)
+      config_name ||= find_config_name_in_package(package_name)
       package = lookup_package(
         package_name || base_package.package_name,
         version_name,
         Backtrace.new(nil, package_name, version_name, config_name)
       )
-      result = nil
-      commands = package[config_name || 'default'].commands
-      with_environment do
-        # TODO nil check
-        commands.each do |command|
-          argument =
-            expand_command_line_argument(
-              "#{command.command} #{args.join(' ')}"
-            )
-
-          result = yield expand_path(argument, package).split(' ')
-        end
+
+      command = package[config_name].command
+      if command
+        execute_command(command, args, package, &block)
+      else
+        raise UserInputError.new(%Q<The "#{package.to_s}" package with the "#{config_name}" configuration does not contain a command.>)
       end
-      result
     end
 
     def apply_config_statement(base_package, statement, backtrace)
@@ -113,12 +130,6 @@ module Fig
       apply_config(package, config_name || 'default', new_backtrace)
     end
 
-    def direct_retrieve(package_name, source_path, target_path)
-      package = lookup_package(package_name, nil, nil)
-      FileUtils.mkdir_p(target_path)
-      FileUtils.cp_r(File.join(package.directory, source_path, '.'), target_path)
-    end
-
     private
 
     def set_variable(base_package, name, value)