Adds a reader/writer method for the give option name

 @return [undefined]

 @api private
437131
def define_option_method(option)
      class_eval <<-RUBY, __FILE__, __LINE__ + 1
        def self.#{option}(value = Undefined)           # def self.primitive(value = Undefined)
          @#{option} = nil unless defined?(@#{option})  #   @primitive = nil unless defined?(@primitive)
          return @#{option} if value.equal?(Undefined)  #   return @primitive if value.equal?(Undefined)
          @#{option} = value                            #   @primitive = value
          self                                          #   self
        end                                             # end
      RUBY
    end
1116646
private static ImmutableSet<OpenOption> addWrite(Collection<? extends OpenOption> options) {
    return options.contains(WRITE)
        ? ImmutableSet.copyOf(options)
        : ImmutableSet.<OpenOption>builder().add(WRITE).addAll(options).build();
  }
643214
def _add_choice_getter(self):
        
        property_ = property(self._choice_getter, None, None)
        # assign unconditionally to overwrite element name definition
        setattr(self._element_cls, self._prop_name, property_)
676448
def method_missing name, *args, **options
      Vips::Operation.call name.to_s, [self, *args], options
    end
355460
def add(name, options)
      @properties[name.to_sym] = Property.new(name.to_sym, options[:type], options[:default])
    end
138964
def instance_readers
      _attrs.map { |k, v| [:attr_writer].any? { |t| v[:type] == t } ? nil : k }.compact
    end
893793
def add_hook(name = nil, cascade = false, &hook)
    if name == nil or name == true or name == false
      cascade = name
      assign_self_hook(cascade, &hook)
    else
      assign_hook(name_to_a(name), cascade, &hook)
    end
  end
897553
def create_option(flag, argument = nil)
      return '' unless flag
      flag = flag.to_s
      return " #{argument}" if flag == 'extra'
      set_pandoc_ruby_options(flag, argument)
      if !argument.nil?
        "#{format_flag(flag)} #{argument}"
      else
        format_flag(flag)
      end
    end
534403
def add_param(name, text, scope=nil)
      scope or scope = 'Parameters'
      @params[scope] ||= {}
      @params[scope][name] = text
    end
615471
function addOption( combo, optionText, optionValue, documentObject, index )
	{
		combo = getSelect( combo );
		var oOption;
		if ( documentObject )
			oOption = documentObject.createElement( "OPTION" );
		else
			oOption = document.createElement( "OPTION" );

		if ( combo && oOption && oOption.getName() == 'option' )
		{
			if ( CKEDITOR.env.ie ) {
				if ( !isNaN( parseInt( index, 10) ) )
					combo.$.options.add( oOption.$, index );
				else
					combo.$.options.add( oOption.$ );

				oOption.$.innerHTML = optionText.length > 0 ? optionText : '';
				oOption.$.value     = optionValue;
			}
			else
			{
				if ( index !== null && index < combo.getChildCount() )
					combo.getChild( index < 0 ? 0 : index ).insertBeforeMe( oOption );
				else
					combo.append( oOption );

				oOption.setText( optionText.length > 0 ? optionText : '' );
				oOption.setValue( optionValue );
			}
		}
		else
			return false;

		return oOption;
	}
43851
def options(name, *args, &block)
      NsOptions::RootMethods.new(self, name).define($stdout, caller)
      self.send(name, *args, &block)
    end
28900
def update_with(&blk)
      self.class.options.each do |name, config|
        value = yield(config)
        @values[name] = value unless value.nil?
      end
    end
1001005
def add_output_option(option_name, *args)
      (@output_options ||= []).push(option_name)
      args.each { |ea| @output_options.push(Shellwords.escape(ea.to_s)) }

      # if we're a resize call, let's give the -size render hint to gm, but only when it's safe:
      # * we don't have input options yet,
      # * we're not cropping (because the -size will prevent the crop from working),
      # * and we have dimensions in the form of NNNxNNN
      if %w{-geometry -resize -sample -scale}.include?(option_name) &&
        @input_options.empty? &&
        !@output_options.include?('-crop')
        dimensions = args.first
        if dimensions.to_s =~ /\A(\d+x\d+)\z/
          @input_options.push('-size', dimensions)
        end
      end
      # Support call chaining:
      self
    end
432480
function permittedOptions(methodName) {
        var options = ghostBookshelf.Model.permittedOptions.call(this, methodName),

            // whitelists for the `options` hash argument on methods, by method name.
            // these are the only options that can be passed to Bookshelf / Knex.
            validOptions = {
                findOne: ['withRelated']
            };

        if (validOptions[methodName]) {
            options = options.concat(validOptions[methodName]);
        }

        return options;
    }
1185396
def apply(values=nil)
      (values || {}).each do |name, value|
        if has_namespace?(name)
          # recursively apply namespace values if hash given; ignore otherwise.
          get_namespace(name).apply(value) if value.kind_of?(Hash)
        else
          # this is meant as a "value importer", so always apply distinct values
          # to prevent unintentional pass-by-ref shared objects.
          # be sure to use the namespace's writer to write the option value
          @ns.send("#{name}=", NsOptions.distinct_value(value))
        end
      end
    end
762246
def add_input_option(option_name, *args)
      (@input_options ||= []).push(option_name)
      args.each { |ea| @input_options.push(Shellwords.escape(ea.to_s)) }

      # Support call chaining:
      self
    end
1073245
def options
      VALID_OPTION_KEYS.inject({}) do |option, key|
        option.merge!(key => send(key))
      end
    end