fig 0.1.51 → 0.1.52

data/lib/fig/options.rb

@@ -1,254 +1,476 @@
 require 'optparse'
+
 require 'fig/package'
-require 'fig/package/archive'
-require 'fig/package/include'
-require 'fig/package/path'
-require 'fig/package/resource'
-require 'fig/package/set'
+require 'fig/packagedescriptor'
+require 'fig/statement/archive'
+require 'fig/statement/include'
+require 'fig/statement/path'
+require 'fig/statement/resource'
+require 'fig/statement/set'
+
+module Fig; end
 
 # Command-line processing.
+class Fig::Options
+  USAGE = <<-EOF
 
+Usage:
 
-module 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
+  fig [...] [DESCRIPTOR] [--update | --update-if-missing] [-- COMMAND]
+
+  fig {--publish | --publish-local} DESCRIPTOR
+      [--resource PATH]
+      [--archive  PATH]
+      [--include  DESCRIPTOR]
+      [--force]
+      [...]
+
+  fig --clean DESCRIPTOR [...]
+
+  fig --get VARIABLE                                         [DESCRIPTOR] [...]
+  fig --list-configs                                         [DESCRIPTOR] [...]
+  fig --list-dependencies [--list-tree] [--list-all-configs] [DESCRIPTOR] [...]
+  fig {--list-local | --list-remote}                                      [...]
+
+  fig {--version | --help}
+
+Not yet implemented:
+  fig --list-variables [--list-tree] [--list-all-configs]    [DESCRIPTOR] [...]
+
+A DESCRIPTOR looks like <package name>[/<version>][:<config>] e.g. "foo",
+"foo/1.2.3", and "foo/1.2.3:default". Whether ":<config>" and "/<version>" are
+required or allowed is dependent upon what your are doing
+
+Standard options (represented as "[...]" above):
 
-  USAGE = <<EOF
+      [--set    VARIABLE=VALUE]
+      [--append VARIABLE=VALUE]
+      [--file PATH] [--no-file]
+      [--config CONFIG]
+      [--login]
+      [--log-level LEVEL] [--log-config PATH]
+      [--figrc PATH] [--no-figrc]
 
-Usage: fig [--update | --update-if-missing] [--file <path>] [--set <VAR=value>] [--config <config>] [--login] [--log-level <level>] [--log-config <path>] [--figrc <path>] [--no-figrc] [-- <command>]
-       fig [--publish | --publish-local] [--append <VAR=val>] [--resource <fullpath>] [--include <package name/version>] [--force] [--no-file] [--archive <path>] [--file] [--set <VAR=value>] [--config <config>] [--login] [--log-level <level>] [--log-config <path>] [--figrc <path>] [--no-figrc]
-       fig [--set <VAR=value>] [--get <VAR> | --list-configs <package name>/<version> | --list | --list-remote | --clean <package name/version> | --version] [--log-level <level>] [--log-config <path>] [--figrc <path>] [--no-figrc] [-- <command>]
-       fig [<package name>/<version>] [--log-level <level>] [--log-config <path>] [--figrc <path>] [--no-figrc]
+Environment variables:
 
-Relevant env vars: FIG_REMOTE_URL (required), FIG_HOME (path to local repository cache, defaults
-to $HOME/.fighome).
+  FIG_REMOTE_URL (required),
+  FIG_HOME (path to local repository cache, defaults to $HOME/.fighome).
 
-EOF
+  EOF
 
   LOG_LEVELS = %w[ off fatal error warn info debug all ]
   LOG_ALIASES = { 'warning' => 'warn' }
 
-  # Returns hash of option values, the remainders of argv, and an exit code if
-  # full program processing occured in this method, otherwise nil.
-  def parse_options(argv)
-    options = {}
-
-    parser = OptionParser.new do |opts|
-      opts.banner = USAGE
-      opts.on('-?', '-h','--help','display this help text') do
-        puts opts.help
-        puts "\n    --  end of fig options; everything following is a command to run in the fig environment.\n\n"
-        return nil, nil, 0
-      end
+  attr_reader :shell_command
+  attr_reader :descriptor
+  attr_reader :exit_code
 
-      opts.on('-v', '--version', 'Print fig version') do
-        line = nil
+  def initialize(argv)
+    strip_shell_command(argv)
 
-        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 gem install.'
-          return nil, nil, 1
-        end
+    @options = {}
 
-        if line !~ /\d+\.\d+\.\d+/
-          $stderr.puts %Q<"#{line}" does not look like a version number. Something has mucked with your gem install.>
-          return nil, nil, 1
-        end
+    @options[:home] = ENV['FIG_HOME'] || File.expand_path('~/.fighome')
 
-        puts File.basename($0) + ' v' + line
+    parser = new_parser()
 
-        return nil, nil, 0
-      end
+    # TODO: Need to catch the exception thrown from parser and retranslate into a fig exception
+    begin
+      parser.parse!(argv)
+    rescue OptionParser::MissingArgument => error
+      $stderr.puts "Please provide the #{error}."
+      @exit_code = 1
+      return
+    end
 
-      options[:non_command_package_statements] = []
-      opts.on(
-        '-p',
-        '--append VAR=VAL',
-        'append (actually, prepend) VAL to environment var VAR, delimited by separator'
-      ) do |var_val|
-        var, val = var_val.split('=')
-        options[:non_command_package_statements] << Package::Path.new(var, val)
-      end
+    if not exit_code.nil?
+      return
+    end
 
-      options[:archives] = []
-      opts.on(
-        '--archive FULLPATH',
-        'include FULLPATH archive in package (when using --publish)'
-      ) do |path|
-        options[:archives] << Package::Archive.new(path)
-      end
+    if argv.size > 1
+      $stderr.puts %q<Extra arguments. Should only have a package/version after all other options. Had "> + argv.join(%q<", ">) + %q<" left over.>
+      @exit_code = 1
+      return
+    end
 
-      options[:cleans] = []
-      opts.on('--clean PKG', 'remove package from $FIG_HOME') do |descriptor|
-        options[:cleans] << descriptor
-      end
+    package_text = argv.first
+    if package_text
+      @descriptor = Fig::PackageDescriptor.parse(package_text)
+    end
 
-      options[:config] = 'default'
-      opts.on(
-        '-c',
-        '--config CFG',
-        %q<apply configuration CFG, default is 'default'>
-      ) do |config|
-        options[:config] = config
-      end
+    return
+  end
 
-      options[:package_config_file] = nil
-      opts.on(
-        '--file FILE',
-        %q<read fig file FILE. Use '-' for stdin. See also --no-file>
-      ) do |path|
-        options[:package_config_file] = path
-      end
+  def archives()
+    return @options[:archives]
+  end
 
-      options[:force] = nil
-      opts.on(
-        '--force',
-        'force-overwrite existing version of a package to the remote repo'
-      ) do |force|
-        options[:force] = force
-      end
+  def clean?()
+    return @options[:clean]
+  end
 
-      options[:get] = nil
-      opts.on(
-        '-g',
-        '--get VAR',
-        'print value of environment variable VAR'
-      ) do |get|
-        options[:get] = get
-      end
+  def config()
+    return @options[:config]
+  end
 
-      opts.on(
-        '-i',
-        '--include PKG',
-        'include PKG (with any variable prepends) in environment'
-      ) do |descriptor|
-        package_name, config_name, version_name = parse_descriptor(descriptor)
-        options[:non_command_package_statements] << Package::Include.new(package_name, config_name, version_name, {})
-      end
+  def figrc()
+    return @options[:figrc]
+  end
 
-      options[:list] = false
-      opts.on('--list', 'list packages in $FIG_HOME') do
-        options[:list] = true
-      end
+  def force?()
+    return @options[:force]
+  end
 
-      options[:list_configs] = []
-      opts.on(
-        '--list-configs PKG', 'list configurations in package'
-      ) do |descriptor|
-        options[:list_configs] << descriptor
-      end
+  def get()
+    return @options[:get]
+  end
 
-      options[:list_remote] = false
-      opts.on('--list-remote', 'list packages in remote repo') do
-        options[:list_remote] = true
-      end
+  def home()
+    return @options[:home]
+  end
 
-      options[:login] = false
-      opts.on(
-        '-l', '--login', 'login to remote repo as a non-anonymous user'
-      ) do
-        options[:login] = true
-      end
+  def listing()
+    return @options[:listing]
+  end
 
-      opts.on(
-        '--no-file', 'ignore package.fig file in current directory'
-      ) do |path|
-        options[:package_config_file] = :none
-      end
+  def list_tree?()
+    return @options[:list_tree]
+  end
 
-      options[:publish] = nil
-      opts.on(
-        '--publish PKG', 'install PKG in $FIG_HOME and in remote repo'
-      ) do |publish|
-        options[:publish] = publish
-      end
+  def list_all_configs?()
+    return @options[:list_all_configs]
+  end
 
-      options[:publish_local] = nil
-      opts.on(
-        '--publish-local PKG', 'install package only in $FIG_HOME'
-      ) do |publish_local|
-        options[:publish_local] = publish_local
-      end
+  def log_config()
+    return @options[:log_config]
+  end
 
-      options[:resources] =[]
-      opts.on(
-        '--resource FULLPATH',
-        'include FULLPATH resource in package (when using --publish)'
-      ) do |path|
-        options[:resources] << Package::Resource.new(path)
-      end
+  def login?()
+    return @options[:login]
+  end
 
-      opts.on(
-        '-s', '--set VAR=VAL', 'set environment variable VAR to VAL'
-      ) do |var_val|
-        var, val = var_val.split('=')
-        options[:non_command_package_statements] << Package::Set.new(var, val)
-      end
+  def log_level()
+    return @options[:log_level]
+  end
 
-      options[:update] = false
-      opts.on(
-        '-u',
-        '--update',
-        'check remote repo for updates and download to $FIG_HOME as necessary'
-      ) do
-        options[:update] = true
-      end
+  def no_figrc?()
+    return @options[:no_figrc]
+  end
 
-      options[:update_if_missing] = false
-      opts.on(
-        '-m',
-        '--update-if-missing',
-        'check remote repo for updates only if package missing from $FIG_HOME'
-      ) do
-        options[:update_if_missing] = true
-      end
+  def non_command_package_statements()
+    return @options[:non_command_package_statements]
+  end
 
-      opts.on(
-        '--figrc PATH', 'add PATH to configuration used for Fig'
-      ) do |path|
-        options[:figrc] = path
-      end
+  def package_config_file()
+    return @options[:package_config_file]
+  end
 
-      opts.on('--no-figrc', 'ignore ~/.figrc') { options[:no_figrc] = true }
+  def publish?()
+    return @options[:publish]
+  end
+
+  def publish_local?()
+    return @options[:publish_local]
+  end
 
-      opts.on(
-        '--log-config PATH', 'use PATH file as configuration for Log4r'
-      ) do |path|
-        options[:log_config] = path
+  def publishing?()
+    return publish? || publish_local?
+  end
+
+  def resources()
+    return @options[:resources]
+  end
+
+  def update?()
+    return @options[:update]
+  end
+
+  def update_if_missing?()
+    return @options[:update_if_missing]
+  end
+
+  def updating?()
+    return update? || update_if_missing?
+  end
+
+  private
+
+  def strip_shell_command(argv)
+    argv.each_with_index do |arg, i|
+      if arg == '--'
+        @shell_command = argv[(i+1)..-1]
+        argv.slice!(i..-1)
+        break
       end
+    end
+
+    return
+  end
+
+  def new_parser
+    return OptionParser.new do |parser|
+      set_up_queries(parser)
+      set_up_commands(parser)
+      set_up_package_configuration_source(parser)
+      set_up_package_statements(parser)
+      set_up_remote_repository_access(parser)
+      set_up_program_configuration(parser)
+    end
+  end
+
+  def set_up_queries(parser)
+    parser.banner = USAGE
+    parser.on('-?', '-h','--help','display this help text') do
+      help(parser)
+    end
 
-      level_list = LOG_LEVELS.join(', ')
-      opts.on(
-        '--log-level LEVEL',
-        LOG_LEVELS,
-        LOG_ALIASES,
-        'set logging level to LEVEL',
-        "  (#{level_list})"
-      ) do |log_level|
-        options[:log_level] = log_level
+    parser.on('-v', '--version', 'Print fig version') do
+      version()
+    end
+
+    parser.on(
+      '-g',
+      '--get VARIABLE',
+      'print value of environment variable VARIABLE'
+    ) do |get|
+      @options[:get] = get
+    end
+
+    set_up_listings(parser)
+
+    return
+  end
+
+  def set_up_listings(parser)
+    option_mapping = {
+      :local_packages =>
+        [ '--list-local', '--list', 'list packages in $FIG_HOME' ],
+
+      :configs =>
+        ['--list-configs', 'list configurations'],
+
+      :dependencies =>
+        ['--list-dependencies', 'list package dependencies, recursively'],
+
+      :variables =>
+        [
+          '--list-variables',
+          'list all variables defined/used by package and its dependencies'
+        ],
+
+      :remote_packages =>
+        ['--list-remote', 'list packages in remote repo']
+    }
+
+    option_mapping.each_pair do
+      | type, specification |
+
+      parser.on(*specification) do
+        @options[:listing] = type
       end
+    end
+
+    parser.on('--list-tree', 'for listings, output a tree instead of a list') do
+      @options[:list_tree] = true
+    end
+
+    parser.on('--list-all-configs', 'for listings, follow all configurations of the base package') do
+      @options[:list_all_configs] = true
+    end
+
+    return
+  end
+
+  def set_up_commands(parser)
+    parser.on('--clean', 'remove package from $FIG_HOME') do
+      @options[:clean] = true
+    end
+
+    parser.on(
+      '--publish', 'install package in $FIG_HOME and in remote repo'
+    ) do |publish|
+      @options[:publish] = true
+    end
+
+    parser.on(
+      '--publish-local', 'install package only in $FIG_HOME'
+    ) do |publish_local|
+      @options[:publish_local] = true
+    end
+
+    return
+  end
+
+  def set_up_package_configuration_source(parser)
+    parser.on(
+      '-c',
+      '--config CONFIG',
+      %q<apply configuration CONFIG, default is "default">
+    ) do |config|
+      @options[:config] = config
+    end
+
+    @options[:package_config_file] = nil
+    parser.on(
+      '--file FILE',
+      %q<read fig file FILE. Use '-' for stdin. See also --no-file>
+    ) do |path|
+      @options[:package_config_file] = path
+    end
+
+    parser.on(
+      '--no-file', 'ignore package.fig file in current directory'
+    ) do |path|
+      @options[:package_config_file] = :none
+    end
+
+    return
+  end
+
+  def set_up_package_statements(parser)
+    @options[:non_command_package_statements] = []
+    parser.on(
+      '-p',
+      '--append VARIABLE=VALUE',
+      'append (actually, prepend) VALUE to environment variable VARIABLE, delimited by separator'
+    ) do |var_val|
+      var, val = var_val.split('=')
+      @options[:non_command_package_statements] << Fig::Statement::Path.new(var, val)
+    end
+
+    parser.on(
+      '-i',
+      '--include DESCRIPTOR',
+      'include package/version:config specified in DESCRIPTOR (with any variable prepends) in environment'
+    ) do |descriptor|
+      @options[:non_command_package_statements] <<
+        Fig::Statement::Include.new(Fig::PackageDescriptor.parse(descriptor), {})
+    end
 
-      options[:home] = ENV['FIG_HOME'] || File.expand_path('~/.fighome')
+    parser.on(
+      '-s', '--set VARIABLE=VALUE', 'set environment variable VARIABLE to VALUE'
+    ) do |var_val|
+      var, val = var_val.split('=')
+      @options[:non_command_package_statements] << Fig::Statement::Set.new(var, val)
     end
 
-    # Need to catch the exception thrown from parser and retranslate into a fig exception
+    @options[:archives] = []
+    parser.on(
+      '--archive PATH',
+      'include PATH archive in package (when using --publish)'
+    ) do |path|
+      @options[:archives] << Fig::Statement::Archive.new(path)
+    end
+
+    @options[:resources] =[]
+    parser.on(
+      '--resource PATH',
+      'include PATH resource in package (when using --publish)'
+    ) do |path|
+      @options[:resources] << Fig::Statement::Resource.new(path)
+    end
+
+    return
+  end
+
+  def set_up_remote_repository_access(parser)
+    parser.on(
+      '-u',
+      '--update',
+      'check remote repo for updates and download to $FIG_HOME as necessary'
+    ) do
+      @options[:update] = true
+    end
+
+    parser.on(
+      '-m',
+      '--update-if-missing',
+      'check remote repo for updates only if package missing from $FIG_HOME'
+    ) do
+      @options[:update_if_missing] = true
+    end
+
+    parser.on(
+      '-l', '--login', 'login to remote repo as a non-anonymous user'
+    ) do
+      @options[:login] = true
+    end
+
+    @options[:force] = nil
+    parser.on(
+      '--force',
+      'force-overwrite existing version of a package to the remote repo'
+    ) do |force|
+      @options[:force] = force
+    end
+
+    return
+  end
+
+  def set_up_program_configuration(parser)
+    parser.on(
+      '--figrc PATH', 'add PATH to configuration used for Fig'
+    ) do |path|
+      @options[:figrc] = path
+    end
+
+    parser.on('--no-figrc', 'ignore ~/.figrc') { @options[:no_figrc] = true }
+
+    parser.on(
+      '--log-config PATH', 'use PATH file as configuration for Log4r'
+    ) do |path|
+      @options[:log_config] = path
+    end
+
+    level_list = LOG_LEVELS.join(', ')
+    parser.on(
+      '--log-level LEVEL',
+      LOG_LEVELS,
+      LOG_ALIASES,
+      'set logging level to LEVEL',
+      "  (#{level_list})"
+    ) do |log_level|
+      @options[:log_level] = log_level
+    end
+
+    return
+  end
+
+  def help(parser)
+    puts parser.help
+    puts "        --                           end of fig options; anything after this is used as a command to run\n\n"
+
+    @exit_code = 0
+
+    return
+  end
+
+  def version()
+    line = nil
+
     begin
-      parser.parse!(argv)
-    rescue OptionParser::MissingArgument => error
-      $stderr.puts "Please provide the #{error}."
-      return nil, nil, 1
+      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.'
+
+      @exit_code = 1
+      return
     end
 
-    return options, argv, nil
+    if line !~ /\d+\.\d+\.\d+/
+      $stderr.puts %Q<"#{line}" does not look like a version number. Something has mucked with your fig install.>
+
+      @exit_code = 1
+      return
+    end
+
+    puts File.basename($0) + ' v' + line
+
+    @exit_code = 0
+    return
   end
 end