fig 0.1.65 → 0.1.67

data/Changes

@@ -1,3 +1,32 @@
+v0.1.67
+
+  Backwards incompatibilities:
+
+  - The --update and --update-if-missing options are always paid attention to.
+    (Hey, you said update; Fig endeavors to comply.) This causes problems where
+    these were previously ignored.
+
+    - If you specify --clean, you'll get an error about the options not
+      agreeing about whether the base package should be loaded.
+
+    - Publishing may fail if you have versionless includes.  Workaround: don't
+      use versionless includes or do the update and the publish separately.
+
+  Bug fixes:
+
+  - Updating and using any of the --list-* options would delete any previously
+    retrieved files.
+
+  - More fixes in dealing with symlinks.
+
+  - Better error reporting for failed installations and package version
+    conflicts.
+
+v0.1.66.beta.2
+v0.1.66.beta.1
+
+  - Test releases
+
 v0.1.65
 
   Bug fixes:

data/bin/fig

@@ -3,7 +3,7 @@
 if ENV['FIG_COVERAGE']
   require File.expand_path(
     File.join(
-      File.dirname(__FILE__), %w< .. lib fig command coveragesupport.rb >
+      File.dirname(__FILE__), %w< .. lib fig command coverage_support.rb >
     )
   )
 end

data/bin/fig-debug

@@ -3,7 +3,7 @@
 if ENV['FIG_COVERAGE']
   require File.expand_path(
     File.join(
-      File.dirname(__FILE__), %w< .. lib fig command coveragesupport.rb >
+      File.dirname(__FILE__), %w< .. lib fig command coverage_support.rb >
     )
   )
 end

data/lib/fig.rb

@@ -0,0 +1,3 @@
+module Fig
+  VERSION = '0.1.67'
+end

data/lib/fig/command.rb

@@ -2,131 +2,86 @@ require 'rubygems'
 require 'net/ftp'
 require 'set'
 
-require 'fig/atexit'
+require 'fig/at_exit'
+require 'fig/command/action'
 require 'fig/command/options'
-require 'fig/environment'
+require 'fig/command/package_applier'
+require 'fig/command/package_loader'
 require 'fig/figrc'
 require 'fig/logging'
-require 'fig/operatingsystem'
+require 'fig/operating_system'
 require 'fig/package'
 require 'fig/parser'
 require 'fig/repository'
-require 'fig/repositoryerror'
+require 'fig/repository_error'
+require 'fig/runtime_environment'
 require 'fig/statement/configuration'
-require 'fig/userinputerror'
-require 'fig/workingdirectorymaintainer'
-
-# The following are a break out of parts of this class simply to keep the file
-# size down.
-
-# You will need to look in this file for any stuff related to --list-* options.
-require 'fig/command/listing'
-
-# You will need to look in this file for any stuff related to loading the
-# base Package object.
-require 'fig/command/packageload'
+require 'fig/user_input_error'
+require 'fig/working_directory_maintainer'
 
 module Fig; end
 
 # Main program
 class Fig::Command
-  include Fig::Command::Listing
-  include Fig::Command::PackageLoad
-
-  def self.get_version()
-    line = nil
-
-    begin
-      File.open(
-        "#{File.expand_path(File.dirname(__FILE__) + '/../../VERSION')}"
-      ) do |file|
-        line = file.gets
-      end
-    rescue
-      $stderr.puts 'Could not retrieve version number. Something has mucked with your Fig install.'
-
-      return nil
-    end
-
-    # Note that we accept anything that contains three decimal numbers
-    # seperated by periods.  This allows for versions like
-    # "4.3.2-super-special-version-in-3D".
-    if line !~ %r< \b \d+ [.] \d+ [.] \d+ \b >x
-      $stderr.puts %Q<"#{line}" does not look like a version number. Something has mucked with your Fig install.>
-
-      return nil
-    end
-
-    return line
-  end
-
   def run_fig(argv)
     begin
       @options = Fig::Command::Options.new(argv)
     rescue Fig::UserInputError => error
       $stderr.puts error.to_s # Logging isn't set up yet.
-      return 1
+      return Fig::Command::Action::EXIT_FAILURE
     end
 
     if not @options.exit_code.nil?
       return @options.exit_code
     end
-    @descriptor = @options.descriptor
 
-    if @options.help?
-      return @options.help
+    actions = @options.actions()
+    if actions.empty?
+      $stderr.puts "Nothing to do.\n\n"
+      $stderr.puts %q<Run "fig --help" for a full list of commands.>
+      return Fig::Command::Action::EXIT_FAILURE
     end
 
-    if @options.version?
-      return emit_version()
+    actions.each do
+      |action|
+
+      if action.execute_immediately_after_command_line_parse?
+        # Note that the action doesn't get an execution context.
+        return action.execute()
+      end
     end
 
-    configure()
+    Fig::Logging.initialize_pre_configuration(@options.log_level())
 
-    if @options.clean?
-      check_required_package_descriptor('to clean')
+    @descriptor = @options.descriptor
+    check_descriptor_requirement()
+    if actions.any? {|action| not action.allow_both_descriptor_and_file? }
       ensure_descriptor_and_file_were_not_both_specified()
-      @repository.clean(@descriptor)
-      return 0
-    end
-
-    if handle_pre_parse_list_options()
-      return 0
     end
 
-    if @options.publishing?
-      return publish()
-    end
+    configure()
+    set_up_base_package()
+
+    context = ExecutionContext.new(
+      @base_package,
+      base_config(),
+      @environment,
+      @repository,
+      @operating_system
+    )
 
-    ensure_descriptor_and_file_were_not_both_specified()
+    actions.each do
+      |action|
 
-    load_package_object()
+      action.execution_context = context
 
-    if @options.listing()
-      handle_post_parse_list_options()
-    elsif @options.get()
-      # Ruby v1.8 emits "nil" for nil, whereas ruby v1.9 emits the empty
-      # string, so, for consistency, we need to ensure that we always emit the
-      # empty string.
-      puts @environment[@options.get()] || ''
-    elsif @options.shell_command
-      @environment.execute_shell(@options.shell_command) do
-        |command| @operating_system.shell_exec command
+      exit_code = action.execute
+      if exit_code != Fig::Command::Action::EXIT_SUCCESS
+        return exit_code
       end
-    elsif @descriptor
-      @environment.include_config(@base_package, @descriptor, nil)
-      @environment.execute_config(
-        @base_package,
-        @descriptor,
-        @options.command_extra_argv || []
-      ) { |cmd| @operating_system.shell_exec cmd }
-    elsif not @repository.updating?
-      $stderr.puts "Nothing to do.\n\n"
-      $stderr.puts %q<Run "fig --help" for a full list of commands.>
-      return 1
     end
 
-    return 0
+    return Fig::Command::Action::EXIT_SUCCESS
   end
 
   def run_with_exception_handling(argv)
@@ -136,31 +91,20 @@ class Fig::Command
     rescue Fig::URLAccessError => error
       urls = error.urls.join(', ')
       $stderr.puts "Access to #{urls} in #{error.package}/#{error.version} not allowed."
-      return 1
+      return Fig::Command::Action::EXIT_FAILURE
     rescue Fig::UserInputError => error
       log_error_message(error)
-      return 1
-    rescue OptionParser::InvalidOption => error
-      $stderr.puts error.to_s
-      $stderr.puts Fig::Command::Options::USAGE
-      return 1
-    rescue Fig::RepositoryError => error
-      log_error_message(error)
-      return 1
+      return Fig::Command::Action::EXIT_FAILURE
     end
   end
 
-  def emit_version()
-    version = Fig::Command.get_version()
-    return 1 if version.nil?
-
-    puts File.basename($0) + ' v' + version
-
-    return 0
-  end
-
   private
 
+  ExecutionContext =
+    Struct.new(
+      :base_package, :base_config, :environment, :repository, :operating_system
+    )
+
   def derive_remote_url()
     if remote_operation_necessary?()
       if ENV['FIG_REMOTE_URL'].nil?
@@ -182,9 +126,20 @@ class Fig::Command
   end
 
   def configure()
-    Fig::Logging.initialize_pre_configuration(@options.log_level())
+    set_up_application_configuration()
+
+    Fig::Logging.initialize_post_configuration(
+      @options.log_config() || @configuration['log configuration'],
+      @options.log_level()
+    )
 
+    @operating_system = Fig::OperatingSystem.new(@options.login?)
+
+    prepare_repository()
+    prepare_environment()
+  end
 
+  def set_up_application_configuration()
     @configuration = Fig::FigRC.find(
       @options.figrc(),
       derive_remote_url(),
@@ -193,39 +148,44 @@ class Fig::Command
       @options.no_figrc?
     )
 
-    Fig::Logging.initialize_post_configuration(
-      @options.log_config() || @configuration['log configuration'],
-      @options.log_level()
-    )
+    return
+  end
 
-    @operating_system = Fig::OperatingSystem.new(@options.login?)
+  def prepare_repository()
     @repository = Fig::Repository.new(
       @operating_system,
       @options.home(),
       @configuration,
       nil, # remote_user
-      @options.update?,
-      @options.update_if_missing?,
       check_include_statements_versions?
     )
 
-    @working_directory_maintainer = Fig::WorkingDirectoryMaintainer.new('.')
-
-    Fig::AtExit.add do
-      @working_directory_maintainer.prepare_for_shutdown(@options.updating?)
+    case @options.update_packages
+    when :unconditionally
+      @repository.update_unconditionally
+    when :if_missing
+      @repository.update_if_missing
     end
 
-    prepare_environment()
+    return
   end
 
   def prepare_environment()
+    working_directory_maintainer = Fig::WorkingDirectoryMaintainer.new('.')
+
+    Fig::AtExit.add do
+      working_directory_maintainer.prepare_for_shutdown(
+        @base_package && retrieves_should_happen?
+      )
+    end
+
     environment_variables = nil
-    if @options.reset_environment?
+    if reset_environment?
       environment_variables = Fig::OperatingSystem.get_environment_variables({})
     end
 
-    @environment = Fig::Environment.new(
-      @repository, environment_variables, @working_directory_maintainer
+    @environment = Fig::RuntimeEnvironment.new(
+      @repository, environment_variables, working_directory_maintainer
     )
 
     Fig::AtExit.add { @environment.check_unused_retrieves() }
@@ -233,9 +193,36 @@ class Fig::Command
     return
   end
 
-  def config_was_specified_by_user()
-    return ! @options.config().nil?                   ||
-           @descriptor && ! @descriptor.config().nil?
+  def set_up_base_package()
+    return if ! load_base_package?
+
+    # We get these before loading the package so that we detect conflicts
+    # between actions.
+    retrieves_should_happen = retrieves_should_happen?
+    register_base_package   = register_base_package?
+    apply_config            = apply_config?
+    apply_base_config       = apply_config ? apply_base_config? : nil
+
+    package_loader = new_package_loader()
+    if @options.actions.all? {|action| action.base_package_can_come_from_descriptor?}
+      @base_package = package_loader.load_package_object()
+    else
+      @base_package = package_loader.load_package_object_from_file()
+    end
+
+    applier = new_package_applier(package_loader.package_source_description())
+
+    if retrieves_should_happen
+      applier.activate_retrieves()
+    end
+    if register_base_package
+      applier.register_package_with_environment()
+    end
+    if apply_config
+      applier.apply_config_to_environment(! apply_base_config)
+    end
+
+    return
   end
 
   def base_config()
@@ -244,12 +231,30 @@ class Fig::Command
            Fig::Package::DEFAULT_CONFIG
   end
 
+  def new_package_loader()
+    return Fig::Command::PackageLoader.new(
+      @configuration,
+      @descriptor,
+      @options.package_definition_file,
+      base_config(),
+      @repository
+    )
+  end
+
+  def new_package_applier(package_source_description)
+    return Fig::Command::PackageApplier.new(
+      @base_package,
+      @environment,
+      @options,
+      @descriptor,
+      base_config(),
+      package_source_description
+    )
+  end
+
   # If the user has specified a descriptor, than any package.fig or --file
   # option is ignored.  Thus, in order to avoid confusing the user, we make
   # specifying both an error.
-  #
-  # The one exception to this rule is when we are publishing, which should
-  # already have been invoked by the time this is called.
   def ensure_descriptor_and_file_were_not_both_specified()
     file = @options.package_definition_file()
 
@@ -267,96 +272,81 @@ class Fig::Command
     return
   end
 
-  def check_required_package_descriptor(operation_description)
-    if not @descriptor
-      raise Fig::UserInputError.new(
-        "Need to specify a package #{operation_description}."
-      )
+  def check_descriptor_requirement()
+    @options.actions.each do
+      |action|
+
+      case action.descriptor_requirement()
+      when :required
+        if not @descriptor
+          raise Fig::UserInputError.new(
+            "Need to specify a descriptor for #{action.primary_option()}."
+          )
+        end
+      when :warn
+        if @descriptor
+          Fig::Logging.warn(
+            %Q<Ignored descriptor "#{@descriptor.to_string}".>
+          )
+        end
+      end
     end
 
     return
   end
 
-  def check_disallowed_package_descriptor(operation_description)
-    if @descriptor
-      raise Fig::UserInputError.new(
-        "Cannot specify a package for #{operation_description}."
-      )
-    end
+  def remote_operation_necessary?()
+    return @options.actions.any? {|action| action.remote_operation_necessary?}
   end
 
-  def remote_operation_necessary?()
-    return @options.updating?                     ||
-           @options.publish?                      ||
-           @options.listing == :remote_packages
+  def load_base_package?()
+    return should_perform?(
+      @options.actions, %Q<the base package should be loaded>
+    ) {|action| action.load_base_package?}
   end
 
-  def publish()
-    check_required_package_descriptor('to publish')
+  def retrieves_should_happen?()
+    return @options.actions.any? {|action| action.retrieves_should_happen?}
+  end
 
-    if @descriptor.name.nil? || @descriptor.version.nil?
-      raise Fig::UserInputError.new(
-        'Please specify a package name and a version name.'
-      )
-    end
-    if @descriptor.name == '_meta'
-      raise Fig::UserInputError.new(
-        %q<Due to implementation issues, cannot create a package named "_meta".>
-      )
-    end
+  def register_base_package?()
+    return should_perform?(
+      @options.actions, %Q<the base package should be in the starting set of packages>
+    ) {|action| action.register_base_package?}
+  end
 
-    publish_statements = nil
-    if not @options.environment_statements().empty?
-      publish_statements =
-        @options.resources() +
-        @options.archives() +
-        [
-          Fig::Statement::Configuration.new(
-            nil,
-            nil,
-            Fig::Package::DEFAULT_CONFIG,
-            @options.environment_statements()
-          )
-        ]
-    elsif not @options.resources().empty? or not @options.archives().empty?
-      raise Fig::UserInputError.new(
-        '--resource/--archive options were specified, but no --set/--append option was given. Will not publish.'
-      )
-    else
-      load_package_object_from_file()
-      if not @base_package.statements.empty?
-        publish_statements = @base_package.statements
-      else
-        $stderr.puts 'Nothing to publish.'
-        return 1
-      end
-    end
+  def apply_config?()
+    return should_perform?(
+      @options.actions, %Q<any config should be applied>
+    ) {|action| action.apply_config?}
+  end
 
-    apply_base_config_to_environment(:ignore_base_package)
+  def apply_base_config?()
+    actions_wanting_application =
+      @options.actions.select {|action| action.apply_config?}
 
-    if @options.publish?
-      Fig::Logging.info "Checking status of #{@descriptor.to_string()}..."
+    return should_perform?(
+      actions_wanting_application, %Q<the base config should be applied>
+    ) {|action| action.apply_base_config?}
+  end
 
-      package_description =
-        Fig::PackageDescriptor.format(@descriptor.name, @descriptor.version, nil)
-      if @repository.list_remote_packages.include?("#{package_description}")
-        Fig::Logging.info "#{@descriptor.to_string()} has already been published."
+  def should_perform?(actions, failure_description, &predicate)
+    yes_actions, no_actions = actions.partition &predicate
+    # Filter out the "don't care" actions".
+    no_actions = no_actions.select { |action| ! predicate.call(action).nil?  }
 
-        if not @options.force?
-          Fig::Logging.fatal 'Use the --force option if you really want to overwrite, or use --publish-local for testing.'
-          return 1
-        else
-          Fig::Logging.info 'Overwriting...'
-        end
-      end
-    end
+    return false if yes_actions.empty?
+    return true if no_actions.empty?
 
-    Fig::Logging.info "Publishing #{@descriptor.to_string()}."
-    @repository.publish_package(
-      publish_statements, @descriptor, @options.publish_local?
+    action_strings = actions.map {|action| action.options.join}
+    action_string = action_strings.join %q<", ">
+    raise Fig::UserInputError.new(
+      %Q<Cannot use "#{action_string}" together because they disagree on whether #{failure_description}.>
     )
+  end
 
-    return 0
+  def reset_environment?()
+    return @options.actions.any? {|action| action.reset_environment?}
   end
 
   def log_error_message(error)