fig 0.1.51 → 0.1.52

data/lib/fig.rb

@@ -1,288 +0,0 @@
-require 'rubygems'
-require 'net/ftp'
-require 'log4r'
-
-require 'fig/environment'
-require 'fig/figrc'
-require 'fig/logging'
-require 'fig/options'
-require 'fig/os'
-require 'fig/package'
-require 'fig/package/configuration'
-require 'fig/package/publish'
-require 'fig/parser'
-require 'fig/repository'
-require 'fig/retriever'
-require 'fig/userinputerror'
-require 'fig/windows'
-
-# Main program
-module Fig
-  DEFAULT_FIG_FILE = 'package.fig'
-
-  def parse_descriptor(descriptor)
-    # todo should use treetop for these:
-    package_name = descriptor =~ %r< ^ ( [^:/]+ ) >x ? $1 : nil
-    config_name  = descriptor =~ %r< : ( [^:/]+ ) >x ? $1 : nil
-    version_name = descriptor =~ %r< / ( [^:/]+ ) >x ? $1 : nil
-    return package_name, config_name, version_name
-  end
-
-  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 == '--'
-        shell_command = argv[(i+1)..-1]
-        argv.slice!(i..-1)
-        break
-      end
-    end
-
-    return shell_command
-  end
-
-  def initialize_remote_url(options)
-    if options[:update] || options[:publish] || options[:update_if_missing] || options[:list_remote]
-      if ENV['FIG_REMOTE_URL'].nil?
-        raise UserInputError.new 'Please define the FIG_REMOTE_URL environment variable.'
-      end
-      return ENV['FIG_REMOTE_URL']
-    end
-
-    return nil
-  end
-
-  def load_package_config_file_contents(options)
-    package_config_file = options[:package_config_file]
-
-    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
-
-  def display_package_list(repository)
-    repository.list_packages.sort.each do |item|
-      puts item
-    end
-  end
-
-  def display_remote_package_list(repository)
-    repository.list_remote_packages.sort.each do |item|
-      puts item
-    end
-  end
-
-  def display_configs_in_local_packages_list(options, repository)
-    options[:list_configs].each do |descriptor|
-      package_name, version_name = descriptor.split('/')
-      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]
-      display_package_list(repository)
-      return true
-    end
-
-    if options[:list_remote]
-      display_remote_package_list(repository)
-      return true
-    end
-
-    if not options[:list_configs].empty?
-      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)
-      if options[:update] || options[:update_if_missing]
-        package.retrieves.each do |var, path|
-          environment.add_retrieve(var, path)
-        end
-      end
-
-      unless options[:publish] || options[:list] || options[:publish_local]
-        environment.register_package(package)
-        environment.apply_config(package, options[:config], nil)
-      end
-    else
-      package = Package.new(nil, nil, '.', [])
-    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
-    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
-      environment.execute_shell(shell_command) { |cmd| os.shell_exec cmd }
-    elsif not argv.empty?
-      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.>
-      return 1
-    end
-
-    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 => error
-      urls = exception.urls.join(', ')
-      $stderr.puts "Access to #{urls} in #{exception.package}/#{exception.version} not allowed."
-      return 1
-    rescue UserInputError => error
-      log_error_message(error)
-      return 1
-    rescue OptionParser::InvalidOption => error
-      $stderr.puts error.to_s
-      $stderr.puts USAGE
-      return 1
-    rescue RepositoryError => error
-      log_error_message(error)
-      return 1
-    end
-  end
-
-  def error_has_message?(error)
-    class_name = error.class.name
-    return error.message != class_name
-  end
-end

data/lib/fig/package/include.rb

@@ -1,32 +0,0 @@
-require 'fig/logging'
-require 'fig/packageerror'
-require 'fig/package/statement'
-
-module Fig; end
-class Fig::Package; end
-
-# Dual role: "include :configname" incorporates one configuration into another;
-# "include package[/version]" declares a dependency upon another package.
-class Fig::Package::Include
-  include Fig::Package::Statement
-
-  attr_reader :package_name, :config_name, :version_name, :overrides
-
-  def initialize(package_name, config_name, version_name, overrides)
-    @package_name = package_name
-    @config_name = config_name
-    @version_name = version_name
-    @overrides = overrides
-  end
-
-  def unparse(indent)
-    descriptor = ''
-    descriptor += @package_name if @package_name
-    descriptor += "/#{@version_name}" if @version_name
-    descriptor += ":#{@config_name}" if @config_name
-    @overrides.each do |override|
-      descriptor += override.unparse
-    end
-    return "#{indent}include #{descriptor}"
-  end
-end

data/lib/fig/package/install.rb

@@ -1,22 +0,0 @@
-require 'fig/logging'
-require 'fig/packageerror'
-require 'fig/package/statement'
-
-module Fig; end
-class Fig::Package; end
-
-# This class appears to be unused, though it is in the grammar.
-class Fig::Package::Install
-  include Fig::Package::Statement
-
-  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

data/lib/fig/package/statement.rb

@@ -1,13 +0,0 @@
-module Fig; end
-class Fig::Package; end
-
-# A statement within a package configuration file (package.fig).
-module Fig::Package::Statement
-  def walk_statements(&block)
-    return
-  end
-
-  def urls
-    return []
-  end
-end