Returns the options specifice to the add command only
974181
def options_for_add(opts, options)
      opts.on('-p', '--port PORT',
              'Specify a port') do |port|
        options.file_content.port_text = "  Port #{port}\n"
      end

      opts.on('-i', '--identity_file [key]',
              'Add identity') do |key_path|
        options.file_content.identity_file_text =
          "  IdentityFile #{key_path}\n"
      end

      opts.on('-b', '--batch_mode', 'Batch Mode') do
        options.file_content.batch_mode_text = "  BatchMode yes\n"
      end
    end
385524
def addOption(self, o):
    
    if self.hasOption(o.short):
      raise InterfaceException("Failed adding option - already have " + str(o))
    self.options.append(o)
571727
def add_command(self, cmd, name=None):
        
        name = name or cmd.name
        if name is None:
            raise TypeError('Command has no name.')
        _check_multicommand(self, name, cmd, register=True)
        self.commands[name] = cmd
20547
function getOptions(merge) {
	var options = {
		root: null,
		schemas: {},
		add: [],
		formats: {},
		fresh: false,
		multi: false,
		timeout: 5000,
		checkRecursive: false,
		banUnknownProperties: false,
		languages: {},
		language: null
	};
	return copyProps(options, merge);
}
572203
private function configureOptions()
    {
        $this->addOption(
            self::OPTIONS_KEY_IMAGES,
            'i',
            InputOption::VALUE_OPTIONAL,
            'The list of docker images to use (comma or space delimited).'
        );
        $this->addOption(
            self::OPTIONS_KEY_CONFIGFILE,
            'c',
            InputOption::VALUE_OPTIONAL,
            'The path to the configuration file.'
        );
        $this->addOption(
            self::OPTIONS_KEY_SYNTAX,
            's',
            InputOption::VALUE_OPTIONAL,
            'A flag indicating whether to run syntax checks.'
        );
        $this->addOption(
            self::OPTIONS_KEY_SYNTAXCOMMAND,
            'S',
            InputOption::VALUE_OPTIONAL,
            'The command to run syntax checks.'
        );
        $this->addOption(
            self::OPTIONS_KEY_UNITTESTS,
            'u',
            InputOption::VALUE_OPTIONAL,
            'A flag indicating whether to run the unit test suite.'
        );
        $this->addOption(
            self::OPTIONS_KEY_UNITTESTSCOMMAND,
            'U',
            InputOption::VALUE_OPTIONAL,
            'The command to run the unit tests.'
        );
        $this->addOption(
            self::OPTIONS_KEY_PULL,
            'p',
            InputOption::VALUE_NONE,
            'A flag indicating to pull new images instead of running the linter or unit tests.'
        );
    }
480123
function defaultOptions(options) {
	options = extend({}, pa11y.defaults, options);
	options.ignore = options.ignore.map(ignored => ignored.toLowerCase());
	if (!options.includeNotices) {
		options.ignore.push('notice');
	}
	if (!options.includeWarnings) {
		options.ignore.push('warning');
	}
	return options;
}
401691
public function addCmdValueOptions()
    {
        return array(
            self::GIT_REMOTE_ADD_OPTION_TRACK => self::GIT_REMOTE_ADD_OPTION_TRACK,
            self::GIT_REMOTE_ADD_OPTION_MIRROR => self::GIT_REMOTE_ADD_OPTION_MIRROR,
            self::GIT_REMOTE_ADD_OPTION_SETHEAD => self::GIT_REMOTE_ADD_OPTION_SETHEAD,
        );
    }
1144604
protected function specifyParameters()
    {
        // We will loop through all of the arguments and options for the command and
        // set them all on the base command instance. This specifies what can get
        // passed into these commands as "parameters" to control the execution.
        foreach ($this->getArguments() as $arguments)
        {
            call_user_func_array(array($this, 'addArgument'), $arguments);
        }

        // Options (Daemon + Custom)
        $options = $this->daemon ? $this->getDaemonOptions() : [];
        $options = array_merge([], $options, $this->getOptions());
        foreach ($options as $op_item)
        {
            call_user_func_array(array($this, 'addOption'), $op_item);
        }
    }
677301
def _options():
    """"""
    opts = sys.argv[1:]
    return [click.Option((v.split('=')[0],)) for v in opts
            if v[0] == '-' and v != '--help']
1268838
def add_options(self):
        
        super(RtorrentXmlRpc, self).add_options()

        # basic options
        self.add_bool_option("-r", "--repr", help="show Python pretty-printed response")
        self.add_bool_option("-x", "--xml", help="show XML response")
        self.add_bool_option("-i", "--as-import",
            help="execute each argument as a private command using 'import'")
        self.add_bool_option("--session", "--restore",
            help="restore session state from .rtorrent session file(s)")

        # TODO: Tempita with "result" object in namespace
        #self.add_value_option("-o", "--output-format", "FORMAT",
        #    help="pass result to a template for formatting")

        self.proxy = None
484883
function getOptions(opts) {
  var options = {};
  for (var opt in defaultOptions) {
    options[opt] = opts && _util.has(opts, opt) ? opts[opt] : defaultOptions[opt];
  }if (options.allowReserved == null) options.allowReserved = options.ecmaVersion < 5;

  if (_util.isArray(options.onToken)) {
    (function () {
      var tokens = options.onToken;
      options.onToken = function (token) {
        return tokens.push(token);
      };
    })();
  }
  if (_util.isArray(options.onComment)) options.onComment = pushComment(options, options.onComment);

  return options;
}
1331775
function(options) {
	options = options || {};
	var optionsArray = [];

	// Go through the available options,
	// set either the passed option
	// or the default
	for (var i in apt.options) {
		if (typeof options[i] !== 'undefined') {
			addOption(optionsArray, i, options[i]);
		} else {
			addOption(optionsArray, i, apt.options[i]);
		}
	}

	return optionsArray;
}
315464
def add_options(self):
        
        super(AdminTool, self).add_options()

        self.add_bool_option("--create-config",
            help="create default configuration")
        self.add_bool_option("--remove-all-rc-files",
            help="write new versions of BOTH .rc and .rc.default files, and remove stale ones")
        self.add_bool_option("--dump-config",
            help="pretty-print configuration including all defaults")
        self.add_value_option("--create-import", "GLOB-PATTERN",
            action="append", default=[],
            help="create import file for a '.d' directory")
        self.add_bool_option("--dump-rc",
            help="pretty-print dynamic commands defined in 'rtorrent.rc'")
        self.add_value_option("-o", "--output", "KEY,KEY1.KEY2=DEFAULT,...",
            action="append", default=[],
            help="select fields to print, output is separated by TABs;"
                 " default values can be provided after the key")
        self.add_bool_option("--reveal",
            help="show config internals and full announce URL including keys")
        self.add_bool_option("--screenlet",
            help="create screenlet stub")
225663
protected List<String> getOptionsByCommand(String command){
        String rawOption = commands.get(command);
        String[] options = rawOption.split(CoreConstants.COMMA);
        return Arrays.asList(options);
    }
1344818
def add_command_line_options(add_argument, use_short_options=True):
    
    logger_args = ("--enable-logger",)
    credentials_args = ("--credentials",)
    if use_short_options:
        logger_args += ('-l',)
        credentials_args += ('-c',)
    add_argument(*logger_args, dest='enabled_loggers',
                 action="append", default=[],
                 help="Enable the specified logger.")
    add_argument(*credentials_args, dest='credential_files',
                 action="append", default=[],
                 help="Use the specified credentials module to update "
                 "the values in okcupyd.settings.")
    add_argument('--echo', dest='echo', action='store_true', default=False,
                 help="Echo SQL.")
273922
def option(self, opt):
        '''
        
        '''
        if 'config.merge' in self.functions:
            return self.functions['config.merge'](opt, {}, omit_master=True)
        return self.opts.get(opt, {})
10854
def addopt ( opt )
      raise TypeError, 'Incorrectly types for option object.' unless
	opt.instance_of? Cmdlib::Option

      @options[opt.longname.to_sym] = opt
    end