Warning: $options are being destructively updated!
421104
public static function cloudinary_url($source, &$options = array())
    {
        $source = self::check_cloudinary_field($source, $options);
        self::patch_fetch_format($options);
        $type = Cloudinary::option_consume($options, "type", "upload");
        $transformation = Cloudinary::generate_transformation_string($options);

        $resource_type = Cloudinary::option_consume($options, "resource_type", "image");
        $version = Cloudinary::option_consume($options, "version");
        $force_version = Cloudinary::option_consume(
            $options,
            "force_version",
            Cloudinary::config_get("force_version", true)
        );
        $format = Cloudinary::option_consume($options, "format");

        $cloud_name = Cloudinary::option_consume($options, "cloud_name", Cloudinary::config_get("cloud_name"));
        if (!$cloud_name) {
            throw new InvalidArgumentException("Must supply cloud_name in tag or in configuration");
        }
        $secure = Cloudinary::option_consume($options, "secure", Cloudinary::config_get("secure"));
        $private_cdn = Cloudinary::option_consume($options, "private_cdn", Cloudinary::config_get("private_cdn"));
        $secure_distribution = Cloudinary::option_consume(
            $options,
            "secure_distribution",
            Cloudinary::config_get("secure_distribution")
        );
        $cdn_subdomain = Cloudinary::option_consume(
            $options,
            "cdn_subdomain",
            Cloudinary::config_get("cdn_subdomain")
        );
        $secure_cdn_subdomain = Cloudinary::option_consume(
            $options,
            "secure_cdn_subdomain",
            Cloudinary::config_get("secure_cdn_subdomain")
        );
        $cname = Cloudinary::option_consume($options, "cname", Cloudinary::config_get("cname"));
        $shorten = Cloudinary::option_consume($options, "shorten", Cloudinary::config_get("shorten"));
        $sign_url = Cloudinary::option_consume($options, "sign_url", Cloudinary::config_get("sign_url"));
        $api_secret = Cloudinary::option_consume($options, "api_secret", Cloudinary::config_get("api_secret"));
        $url_suffix = Cloudinary::option_consume($options, "url_suffix", Cloudinary::config_get("url_suffix"));
        $use_root_path = Cloudinary::option_consume($options, "use_root_path", Cloudinary::config_get("use_root_path"));
        $auth_token = Cloudinary::option_consume($options, "auth_token");
        if (is_array($auth_token)) {
            $auth_token = array_merge(self::config_get("auth_token", array()), $auth_token);
        } elseif (is_null($auth_token)) {
            $auth_token = self::config_get("auth_token");
        }

        if (!$source) {
            return $source;
        }

        if (preg_match("/^https?:\//i", $source)) {
            if ($type == "upload") {
                return $source;
            }
        }

        $resource_type_and_type = Cloudinary::finalize_resource_type(
            $resource_type,
            $type,
            $url_suffix,
            $use_root_path,
            $shorten
        );
        $sources = Cloudinary::finalize_source($source, $format, $url_suffix);
        $source = $sources["source"];
        $source_to_sign = $sources["source_to_sign"];

        if (empty($version) && $force_version && strpos($source_to_sign, "/") &&
            !preg_match("/^https?:\//", $source_to_sign) && !preg_match("/^v[0-9]+/", $source_to_sign)) {
            $version = "1";
        }
        $version = $version ? "v" . $version : null;

        $signature = null;
        if ($sign_url && !$auth_token) {
            $to_sign = implode("/", array_filter(array($transformation, $source_to_sign)));
            $signature = self::base64url_encode(sha1($to_sign . $api_secret, true));
            $signature = 's--' . substr($signature, 0, 8) . '--';
        }

        $prefix = Cloudinary::unsigned_download_url_prefix(
            $source,
            $cloud_name,
            $private_cdn,
            $cdn_subdomain,
            $secure_cdn_subdomain,
            $cname,
            $secure,
            $secure_distribution
        );

        $source = preg_replace(
            "/([^:])\/+/",
            "$1/",
            implode(
                "/",
                array_filter(
                    array(
                        $prefix,
                        $resource_type_and_type,
                        $signature,
                        $transformation,
                        $version,
                        $source,
                    )
                )
            )
        );

        if ($sign_url && $auth_token) {
            $path = parse_url($source, PHP_URL_PATH);
            $token = \Cloudinary\AuthToken::generate(array_merge($auth_token, array("url" => $path)));
            $source = $source . "?" . $token;
        }

        return $source;
    }
402678
@Override
	public void optionsUpdated(IOptions options, long sequence) {
		Context cx = Context.enter();
		try {
			Scriptable jsOptions = cx.newObject(sharedScope);
			Map<String, String> optionsMap = options.getOptionsMap();
			for (Map.Entry<String, String> entry : optionsMap.entrySet()) {
				Object value = Context.javaToJS(entry.getValue(), sharedScope);
				ScriptableObject.putProperty(jsOptions, entry.getKey(), value);
			}
			ScriptableObject.putProperty(sharedScope, "options", jsOptions); //$NON-NLS-1$
		} finally {
			Context.exit();
		}
	}
682767
public static <T> void verifyDeprecatedOption(String deprecatedOption, T value, String option) {
        if (value != null) {
            LOGGER.warn("The option '" + deprecatedOption + "' is deprecated, use '" + option + "' instead.");
        }
    }
433864
def bump_option_validator(ctx, param, value):
    

    if value:
        try:
            value = Version(value)
        except ValueError:
            ctx.fail(f"{x_mark} {value} is not a valid version string")

    return value
707541
function warnAboutDeprecatedProp(propValue, oldPropName, newPropName) {
  if (propValue !== undefined) {
    console.warn(`[DEPRECATED] the property "${oldPropName}" has been deprecated, use "${newPropName}" instead`);
  }
}
189129
def remove_global_options(options, args)
      # TODO: refactor with flipflop, please TJ ! have time to refactor me !
      options.each do |option|
        switches = option[:switches].dup
        next if switches.empty?

        if (switch_has_arg = switches.any? { |s| s =~ /[ =]/ })
          switches.map! { |s| s[0, s.index('=') || s.index(' ') || s.length] }
        end

        switches = expand_optionally_negative_switches(switches)

        past_switch, arg_removed = false, false
        args.delete_if do |arg|
          if switches.any? { |s| s[0, arg.length] == arg }
            arg_removed = !switch_has_arg
            past_switch = true
          elsif past_switch && !arg_removed && arg !~ /^-/
            arg_removed = true
          else
            arg_removed = true
            false
          end
        end
      end
    end
1190738
private function sanitizeOptions(array $options)
    {
        $booleanOptions = [
            Option::TRANSACTIONAL,
            Option::OPEN_TRACKING,
            Option::CLICK_TRACKING,
            Option::SANDBOX,
            Option::SKIP_SUPPRESSION,
            Option::INLINE_CSS,
        ];
        $stringOptions  = [
            Option::IP_POOL,
        ];

        $sanitized = [];

        foreach ($options as $option => $value) {
            if (in_array($option, $stringOptions, true)) {
                if ($value) {
                    $sanitized[$option] = (string) $value;
                }
                continue;
            }

            if (in_array($option, $booleanOptions, true)) {
                $sanitized[$option] = (bool) $value;
                continue;
            }

            throw new Exception(sprintf('Unknown SparkPost option "%s"', $option));
        }

        return $sanitized;
    }
1075717
function (opts) {
        var target   = opts.target,
            priority = opts.priority,
            paused   = opts.paused

        var i, len
        var entry = {target: target, priority: priority, paused: paused}
        var added = false

        if (priority === 0) {
            this.updates0.push(entry)
        } else if (priority < 0) {
            for (i = 0, len = this.updatesNeg.length; i < len; i++) {
                if (priority < this.updatesNeg[i].priority) {
                    this.updatesNeg.splice(i, 0, entry)
                    added = true
                    break
                }
            }

            if (!added) {
                this.updatesNeg.push(entry)
            }
        } else /* priority > 0 */{
            for (i = 0, len = this.updatesPos.length; i < len; i++) {
                if (priority < this.updatesPos[i].priority) {
                    this.updatesPos.splice(i, 0, entry)
                    added = true
                    break
                }
            }

            if (!added) {
                this.updatesPos.push(entry)
            }
        }

        this.hashForUpdates[target.id] = entry
    }
1028018
def handle_update(self, options):  # pylint: disable=no-self-use
        
        username = options["username"]
        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            raise CommandError("User %s does not exist" % username)
        if options["email"]:
            user.email = options["email"]
        # False is an allowed value, but not None.
        if options["active"] in [True, False]:
            user.is_active = options["active"]
        if options["staff"] in [True, False]:
            user.is_staff = options["staff"]
        if options["superuser"] in [True, False]:
            user.is_superuser = options["superuser"]
        user.save()
704731
function shouldUpdateValue (elm, checkVal) {
  return (!elm.composing && (
    elm.tagName === 'OPTION' ||
        isDirty(elm, checkVal) ||
        isInputChanged(elm, checkVal)
  ))
}
1133240
function shouldUpdateValue (
  elm,
  vnode,
  checkVal
) {
  return (!elm.composing && (
    vnode.tag === 'option' ||
    isDirty(elm, checkVal) ||
    isInputChanged(elm, checkVal)
  ))
}
82902
function S3Mock(options) {
	if (!_.isUndefined(options) && !_.isUndefined(options.params)) {
		this.defaultOptions = _.extend({}, applyBasePath(options.params));
	}

	this.config = {
		update: function() {}
	};
}
755618
def _warn_unsafe_options(cls, args):
        '''
        '''
        enabled_options = []

        for option_name in cls.UNSAFE_OPTIONS:
            if getattr(args, option_name):
                enabled_options.append(option_name)

        if enabled_options:
            _logger.warning(__(
                _('The following unsafe options are enabled: {list}.'),
                list=enabled_options
            ))
            _logger.warning(
                _('The use of unsafe options may lead to unexpected behavior '
                  'or file corruption.'))

        if not args.retr_symlinks:
            _logger.warning(
                _('The --retr-symlinks=off option is a security risk.')
            )
1162386
@Override
	public synchronized void optionsUpdated(IOptions options, long sequence) {
		String previousCacheBust = cacheBust;
		cacheBust = options.getCacheBust();
		if (sequence > 1 && cacheBust != null && !cacheBust.equals(previousCacheBust) && rawConfig != null) {
			// Cache bust property has been updated subsequent to server startup
			processDeps(false, false, sequence);
		}
	}
1370448
function handleSuccess() {
  clearOutdatedErrors();

  var isHotUpdate = !isFirstCompilation;
  isFirstCompilation = false;
  hasCompileErrors = false;

  // Attempt to apply hot updates or reload.
  if (isHotUpdate) {
    tryApplyUpdates(function onHotUpdateSuccess() {
      // Only dismiss it when we're sure it's a hot update.
      // Otherwise it would flicker right before the reload.
      tryDismissErrorOverlay();
    });
  }
}
348102
function shouldUpdateValue (elm, checkVal) {
  return (!elm.composing && (
    elm.tagName === 'OPTION' ||
    isNotInFocusAndDirty(elm, checkVal) ||
    isDirtyWithModifiers(elm, checkVal)
  ))
}
482154
function optionExists($value) {
        foreach ($this->_options as $option) {
            if (isset($option['attr']['value']) && ($option['attr']['value'] == $value)) {
                return true;
            }
        }
        return false;
    }