module MiGA::Cli::OptHelper

@package MiGA @license Artistic-2.0

Public Instance Methods

banner(opt) click to toggle source

Send MiGA's banner to OptionParser opt

opt_common(opt) click to toggle source

Common options at the end of most actions, passed to OptionParser opt No action is performed if +#opt_common = false+ is passed Executes only once, unless +#opt_common = true+ is passed between calls

# File lib/miga/cli/opt_helper.rb, line 20
def opt_common(opt)
  return unless @opt_common
  if interactive
    opt.on(
      '--auto',
      'Accept all defaults as answers'
    ) { |v| self[:auto] = v }
  end
  opt.on(
    '-v', '--verbose',
    'Print additional information to STDERR'
  ) { |v| self[:verbose] = v }
  opt.on(
    '-d', '--debug INT', Integer,
    'Print debugging information to STDERR (1: debug, 2: trace)'
  ) { |v| v > 1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON }
  opt.on(
    '-h', '--help',
    'Display this screen'
  ) do
    puts opt
    exit
  end
  opt.separator ''
  self.opt_common = false
end
opt_filter_datasets(opt, what = [:ref, :multi, :active, :taxonomy]) click to toggle source

Options to filter a list of datasets passed to OptionParser opt, as determined by what an Array with any combination of:

  • :ref To filter by reference (–ref) or query (–no-ref)

  • :multi To filter by multiple (–multi) or single (–no-multi) species

  • :active To filter by active (–active) or inactive (–no-active)

  • :taxonomy To filter by taxonomy (–taxonomy)

The “k-th” filter (–dataset-k) is always included

# File lib/miga/cli/opt_helper.rb, line 119
def opt_filter_datasets(opt, what = [:ref, :multi, :active, :taxonomy])
  what.each do |w|
    case w
    when :ref
      opt.on(
        '--[no-]ref',
        'Use only reference (or only non-reference) datasets'
      ) { |v| self[:ref] = v }
    when :multi
      opt.on(
        '--[no-]multi',
        'Use only multi-species (or only single-species) datasets'
      ) { |v| self[:multi] = v }
    when :active
      opt.on(
        '--[no-]active',
        'Use only active (or inactive) datasets'
      ) { |v| self[:active] = v }
    when :taxonomy
      opt.on(
        '-t', '--taxonomy RANK:TAXON',
        'Filter by taxonomy'
      ) { |v| self[:taxonomy] = MiGA::Taxonomy.new(v) }
    else
      raise "Internal error: Unrecognized option: #{w}"
    end
  end
  opt.on(
    '--dataset-k INTEGER', Integer,
    'Use only the k-th dataset in the list'
  ) { |v| self[:dataset_k] = v }
end
opt_flag(opt, flag, description, sym = nil) click to toggle source

Add a flag (true/false) to the OptionParser opt defined by flag (without –) and description, and save it in the CLI as sym. If sym is nil, flag is used as Symbol

# File lib/miga/cli/opt_helper.rb, line 156
def opt_flag(opt, flag, description, sym = nil)
  sym = flag.to_sym if sym.nil?
  opt.on("--#{flag}", description) { |v| self[sym] = v }
end
opt_object(opt, what = [:project, :dataset]) click to toggle source

Options to load an object passed to OptionParser opt, as determined by what an Array with any combination of:

  • :project To require a project

  • :dataset To require a dataset

  • :dataset_opt To allow (optionally) a dataset

  • :dataset_type To allow (optionally) a type of dataset

  • :dataset_type_req To require a type of dataset

  • :project_type To allow (optionally) a type of project

  • :project_type_req To require a type of project

  • :result To require a type of project or dataset result

  • :result_dataset To require a type of dataset result

  • :result_project To require a type of project result

The options :result, :result_dataset, and :result_project are mutually exclusive

# File lib/miga/cli/opt_helper.rb, line 62
def opt_object(opt, what = [:project, :dataset])
  what.each do |w|
    case w
    when :project
      opt.on(
        '-P', '--project PATH',
        '(Mandatory) Path to the project'
      ) { |v| self[:project] = v }
    when :dataset, :dataset_opt
      opt.on(
        '-D', '--dataset STRING',
        (w == :dataset ? '(Mandatory) ' : '') + 'Name of the dataset'
      ) { |v| self[:dataset] = v }
    when :dataset_type, :dataset_type_req, :project_type, :project_type_req
      obj = w.to_s.gsub(/_.*/, '')
      klass = Object.const_get("MiGA::#{obj.capitalize}")
      req = w.to_s =~ /_req$/ ? '(Mandatory) ' : ''
      opt.on(
        '-t', '--type STRING',
        "#{req}Type of #{obj}. Recognized types include:",
        *klass.KNOWN_TYPES.map { |k, v| "~ #{k}: #{v[:description]}" }
      ) { |v| self[:type] = v.downcase.to_sym }
    when :result
      opt.on(
        '-r', '--result STRING',
        '(Mandatory) Name of the result',
        'Recognized names for dataset-specific results include:',
        *MiGA::Dataset.RESULT_DIRS.keys.map { |n| " ~ #{n}" },
        'Recognized names for project-wide results include:',
        *MiGA::Project.RESULT_DIRS.keys.map { |n| " ~ #{n}" }
      ) { |v| self[:result] = v.downcase.to_sym }
    when :result_dataset
      opt.on(
        '-r', '--result STRING',
        '(Mandatory) Name of the result, one of:',
        *MiGA::Dataset.RESULT_DIRS.keys.map { |n| " ~ #{n}" }
      ) { |v| self[:result] = v.downcase.to_sym }
    when :result_project
      opt.on(
        '-r', '--result STRING',
        '(Mandatory) Name of the result, one of:',
        *MiGA::Project.RESULT_DIRS.keys.map { |n| " ~ #{n}" }
      ) { |v| self[:result] = v.downcase.to_sym }
    else
      raise "Internal error: Unrecognized option: #{w}"
    end
  end
end