<h2>File Contents: /home/planet5/public_html/wp-content/plugins/wp-mail-smtp/src/WPCLI/Options/copy_of_Writer.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/wp-mail-smtp/src/WPCLI/Options/copy_of_Writer.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

namespace WPMailSMTP\WPCLI\Options;

use WP_CLI;
use WPMailSMTP\Helpers\Data;
use WPMailSMTP\Options;

/**
 * Resolves passed CLI args to values, validates them against the
 * registry, and writes them through Options::set().
 *
 * @since 4.9.0
 */
class Writer {

	/**
	 * Registry of args this writer resolves against.
	 *
	 * @since 4.9.0
	 *
	 * @var Registry
	 */
	private $registry;

	/**
	 * Constructor.
	 *
	 * @since 4.9.0
	 *
	 * @param Registry|null $registry Optional injected registry; defaults to a fresh instance.
	 */
	public function __construct( Registry $registry = null ) {

		$this-&gt;registry = $registry !== null ? $registry : new Registry();
	}

	/**
	 * Resolve every registry arg against the assoc args passed on the CLI.
	 *
	 * Precedence per arg: literal flag value &gt; --&lt;flag&gt;-file=&lt;path&gt; &gt; env var.
	 * Returns a map of flag =&gt; value for flags that resolved to something.
	 *
	 * @since 4.9.0
	 *
	 * @param array $assoc_args WP-CLI assoc args.
	 *
	 * @return array
	 */
	public function resolve( array $assoc_args ) {

		$resolved = [];

		foreach ( $this-&gt;registry-&gt;get_args() as $arg ) {
			$value = $this-&gt;resolve_one_arg( $arg, $assoc_args );

			if ( $value !== null ) {
				$resolved[ $arg[&#039;flag&#039;] ] = $this-&gt;coerce( $arg, $value );
			}
		}

		return $resolved;
	}

	/**
	 * Resolve a single flag by name.
	 *
	 * @since 4.9.0
	 *
	 * @param string $flag       Dotted flag (e.g. `smtp.host`).
	 * @param array  $assoc_args WP-CLI assoc args.
	 *
	 * @return mixed|null Coerced value, or null if not resolved.
	 */
	public function resolve_single( $flag, array $assoc_args ) {

		$arg = $this-&gt;registry-&gt;find( $flag );

		if ( $arg === null ) {
			WP_CLI::error(
				sprintf(
					/* translators: %s is the unknown dotted CLI flag (e.g. smtp.host). The flag itself is not translated. */
					__( &#039;Unknown flag: %s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag
				)
			);
		}

		$value = $this-&gt;resolve_one_arg( $arg, $assoc_args );

		return $value === null ? null : $this-&gt;coerce( $arg, $value );
	}

	/**
	 * Validate the resolved map. Enforces required, required_if, type, enum.
	 * Accumulates ALL errors and reports them in one WP_CLI::error call.
	 *
	 * @since 4.9.0
	 *
	 * @param array $resolved Map of flag =&gt; coerced value.
	 *
	 * @return void
	 */
	public function validate( array $resolved ) { // phpcs:ignore Generic.Metrics.CyclomaticComplexity.MaxExceeded, Generic.Metrics.NestingLevel.MaxExceeded

		$errors         = [];
		$reported_gates = []; // De-dup partial-chain &quot;missing gate&quot; messages across all rules.

		foreach ( $this-&gt;registry-&gt;get_args() as $arg ) {
			$flag    = $arg[&#039;flag&#039;];
			$present = array_key_exists( $flag, $resolved );

			// Required.
			if ( ! empty( $arg[&#039;required&#039;] ) &amp;&amp; ! $present ) {
				$errors[] = sprintf(
					/* translators: %s is the dotted CLI flag (e.g. mail.from_email). The flag itself is not translated. */
					__( &#039;Missing required flag: --%s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag
				);

				continue;
			}

			// Required-if.
			if ( ! empty( $arg[&#039;required_if&#039;] ) ) {
				$rule_match = $this-&gt;required_if_evaluate( $arg[&#039;required_if&#039;], $resolved );

				if ( $rule_match[&#039;all_match&#039;] &amp;&amp; ! $present ) {
					$errors[] = sprintf(
						/* translators: %1$s is the dotted CLI flag that is missing (e.g. smtp.host). %2$s is a human-readable condition (e.g. &quot;--mail.mailer=smtp&quot;). Flags and values are not translated. */
						__( &#039;Missing required flag: --%1$s (required when %2$s)&#039;, &#039;wp-mail-smtp&#039; ),
						$flag,
						$this-&gt;required_if_human( $arg[&#039;required_if&#039;] )
					);

					continue;
				}

				// Partial-chain match: at least one gating flag matched but others are missing; report each missing gate once.
				if ( $rule_match[&#039;any_match&#039;] &amp;&amp; ! empty( $rule_match[&#039;missing&#039;] ) ) {
					foreach ( $rule_match[&#039;missing&#039;] as $missing_gate ) {
						if ( isset( $reported_gates[ $missing_gate ] ) ) {
							continue;
						}

						$reported_gates[ $missing_gate ] = true;

						$errors[] = sprintf(
							/* translators: %s is the dotted CLI flag that is missing (e.g. smtp.auth). The flag itself is not translated. */
							__( &#039;Missing required flag: --%s (needed to fully specify the configuration when other gating flags are set)&#039;, &#039;wp-mail-smtp&#039; ),
							$missing_gate
						);
					}
				}
			}

			if ( ! $present ) {
				continue;
			}

			// Enum.
			if ( ( $arg[&#039;type&#039;] ?? null ) === &#039;enum&#039; &amp;&amp; ! in_array( $resolved[ $flag ], $arg[&#039;enum&#039;], true ) ) {
				$errors[] = sprintf(
					/* translators: %1$s is the dotted CLI flag (e.g. mail.mailer). %2$s is the value the operator provided. %3$s is a comma-separated list of allowed values. Flags and values are not translated. */
					__( &#039;Invalid value for --%1$s: %2$s (allowed: %3$s)&#039;, &#039;wp-mail-smtp&#039; ),
					$flag,
					$resolved[ $flag ],
					implode( &#039;, &#039;, $arg[&#039;enum&#039;] )
				);
			}

			// Email type sanity check.
			if ( ( $arg[&#039;type&#039;] ?? null ) === &#039;email&#039; &amp;&amp; ! is_email( $resolved[ $flag ] ) ) {
				$errors[] = sprintf(
					/* translators: %1$s is the dotted CLI flag (e.g. mail.from_email). %2$s is the value the operator provided. The flag is not translated. */
					__( &#039;Invalid email for --%1$s: %2$s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag,
					$resolved[ $flag ]
				);
			}

			// Int type sanity check. coerce() leaves non-numeric strings unmodified so they surface here instead of a silent 0.
			if ( ( $arg[&#039;type&#039;] ?? null ) === &#039;int&#039; &amp;&amp; ! is_numeric( $resolved[ $flag ] ) ) {
				$errors[] = sprintf(
					/* translators: %1$s is the dotted CLI flag (e.g. smtp.port). %2$s is the value the operator provided. The flag is not translated. */
					__( &#039;Invalid integer for --%1$s: %2$s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag,
					$resolved[ $flag ]
				);
			}
		}

		if ( ! empty( $errors ) ) {
			WP_CLI::error( __( &#039;Configuration errors:&#039;, &#039;wp-mail-smtp&#039; ) . &quot;\n  - &quot; . implode( &quot;\n  - &quot;, $errors ) );
		}
	}

	/**
	 * Validate a single resolved flag/value pair without applying required/required_if.
	 * Used by `option set` where the operator is updating one key in isolation.
	 *
	 * @since 4.9.0
	 *
	 * @param string $flag  Dotted flag.
	 * @param mixed  $value Coerced value.
	 *
	 * @return void
	 */
	public function validate_single( $flag, $value ) {

		$arg = $this-&gt;registry-&gt;find( $flag );

		if ( $arg === null ) {
			WP_CLI::error(
				sprintf(
					/* translators: %s is the unknown dotted CLI flag (e.g. smtp.host). The flag itself is not translated. */
					__( &#039;Unknown flag: %s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag
				)
			);
		}

		if ( ( $arg[&#039;type&#039;] ?? null ) === &#039;enum&#039; &amp;&amp; ! in_array( $value, $arg[&#039;enum&#039;], true ) ) {
			WP_CLI::error(
				sprintf(
					/* translators: %1$s is the dotted CLI flag (e.g. mail.mailer). %2$s is the value the operator provided. %3$s is a comma-separated list of allowed values. Flags and values are not translated. */
					__( &#039;Invalid value for --%1$s: %2$s (allowed: %3$s)&#039;, &#039;wp-mail-smtp&#039; ),
					$flag,
					$value,
					implode( &#039;, &#039;, $arg[&#039;enum&#039;] )
				)
			);
		}

		if ( ( $arg[&#039;type&#039;] ?? null ) === &#039;email&#039; &amp;&amp; ! is_email( $value ) ) {
			WP_CLI::error(
				sprintf(
					/* translators: %1$s is the dotted CLI flag (e.g. mail.from_email). %2$s is the value the operator provided. The flag is not translated. */
					__( &#039;Invalid email for --%1$s: %2$s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag,
					$value
				)
			);
		}

		if ( ( $arg[&#039;type&#039;] ?? null ) === &#039;int&#039; &amp;&amp; ! is_numeric( $value ) ) {
			WP_CLI::error(
				sprintf(
					/* translators: %1$s is the dotted CLI flag (e.g. smtp.port). %2$s is the value the operator provided. The flag is not translated. */
					__( &#039;Invalid integer for --%1$s: %2$s&#039;, &#039;wp-mail-smtp&#039; ),
					$flag,
					$value
				)
			);
		}
	}

	/**
	 * Write the resolved map through Options::set().
	 *
	 * Each flag is written to its `storage_path` (see ::storage_path()). Keys
	 * shadowed by a wp-config constant are skipped and warned about: Options::set()
	 * forces the stored value to &#039;&#039; whenever the constant is defined, which would
	 * silently wipe the value.
	 *
	 * @since 4.9.0
	 *
	 * @param array $resolved Map of flag =&gt; coerced value.
	 *
	 * @return array Map with two keys: &#039;written&#039; (flags actually stored) and
	 *               &#039;shadowed&#039; (flags skipped because a wp-config constant is set).
	 */
	public function write( array $resolved ) { // phpcs:ignore Generic.Metrics.CyclomaticComplexity.TooHigh

		$result = [
			&#039;written&#039;  =&gt; [],
			&#039;shadowed&#039; =&gt; [],
		];

		if ( empty( $resolved ) ) {
			return $result;
		}

		$options = Options::init();

		$writable = [];

		foreach ( $resolved as $flag =&gt; $value ) {
			$arg  = $this-&gt;registry-&gt;find( $flag );
			$path = $this-&gt;storage_path( $arg !== null ? $arg : [ &#039;flag&#039; =&gt; $flag ] );

			// Translate operator-facing enum values to storage values before the shadow check, so it operates on storage values.
			if ( $arg !== null &amp;&amp; ! empty( $arg[&#039;enum_storage_map&#039;] ) &amp;&amp; is_array( $arg[&#039;enum_storage_map&#039;] ) &amp;&amp; array_key_exists( $value, $arg[&#039;enum_storage_map&#039;] ) ) {
				$value = $arg[&#039;enum_storage_map&#039;][ $value ];
			}

			// Shadow check is limited to the top-level group/key pair, matching WPMS&#039;s shallow WPMS_&lt;GROUP&gt;_&lt;KEY&gt; constants.
			$segments = explode( Data::KEY_SEPARATOR, $path, 3 );

			if ( isset( $segments[0], $segments[1] ) &amp;&amp; $options-&gt;is_const_defined( $segments[0], $segments[1] ) ) {
				$result[&#039;shadowed&#039;][] = $flag;
			} else {
				$writable[ $flag ] = [
					&#039;value&#039; =&gt; $value,
					&#039;path&#039;  =&gt; $path,
				];
			}
		}

		foreach ( $result[&#039;shadowed&#039;] as $flag ) {
			WP_CLI::warning(
				sprintf(
					/* translators: %s is the dotted CLI flag whose underlying option is overridden by a wp-config constant (e.g. smtp.host). The flag itself is not translated. */
					__( &#039;A wp-config constant is defined for %s. The value was not stored. Remove the constant first, then re-run this command.&#039;, &#039;wp-mail-smtp&#039; ),
					$flag
				)
			);
		}

		if ( empty( $writable ) ) {
			return $result;
		}

		$new = $options-&gt;get_all_raw();

		foreach ( $writable as $entry ) {
			Data::set( $new, $entry[&#039;path&#039;], $entry[&#039;value&#039;] );
		}

		$options-&gt;set( $new );

		$result[&#039;written&#039;] = array_keys( $writable );

		return $result;
	}

	/**
	 * Write a single key (used by `option set`).
	 *
	 * @since 4.9.0
	 *
	 * @param string $flag  Dotted flag.
	 * @param mixed  $value Coerced value.
	 *
	 * @return array See ::write().
	 */
	public function write_single( $flag, $value ) {

		return $this-&gt;write( [ $flag =&gt; $value ] );
	}

	/**
	 * Resolve the storage path for an arg.
	 *
	 * Uses `storage_path` if set on the arg, otherwise falls back to the flag itself.
	 *
	 * @since 4.9.0
	 *
	 * @param array $arg Registry arg shape.
	 *
	 * @return string Dotted storage path, e.g. `alert_slack_webhook.connections.0.webhook_url`.
	 */
	private function storage_path( array $arg ) {

		return ! empty( $arg[&#039;storage_path&#039;] ) ? $arg[&#039;storage_path&#039;] : $arg[&#039;flag&#039;];
	}

	/**
	 * Resolve a single arg&#039;s value from assoc args using
	 * literal &gt; --&lt;flag&gt;-file &gt; env var precedence.
	 *
	 * @since 4.9.0
	 *
	 * @param array $arg        Registry arg.
	 * @param array $assoc_args WP-CLI assoc args.
	 *
	 * @return string|null Raw string value, or null if not resolved.
	 */
	private function resolve_one_arg( array $arg, array $assoc_args ) {

		$flag      = $arg[&#039;flag&#039;];
		$file_flag = $flag . &#039;-file&#039;;

		if ( array_key_exists( $flag, $assoc_args ) ) {
			return (string) $assoc_args[ $flag ];
		}

		if ( array_key_exists( $file_flag, $assoc_args ) ) {
			$path = $assoc_args[ $file_flag ];

			if ( ! is_readable( $path ) ) {
				WP_CLI::error(
					sprintf(
						/* translators: %1$s is the dotted CLI flag with a -file suffix (e.g. smtp.pass-file). %2$s is the absolute file path that could not be read. */
						__( &#039;Cannot read --%1$s file: %2$s&#039;, &#039;wp-mail-smtp&#039; ),
						$file_flag,
						$path
					)
				);
			}

			return rtrim( (string) file_get_contents( $path ) );
		}

		$env_var = $arg[&#039;env_var&#039;] ?? ( &#039;WPMS_&#039; . strtoupper( str_replace( &#039;.&#039;, &#039;_&#039;, $flag ) ) );
		$env     = getenv( $env_var );

		if ( $env !== false &amp;&amp; $env !== &#039;&#039; ) {
			return $env;
		}

		return null;
	}

	/**
	 * Coerce a raw string value to the type declared by the arg.
	 *
	 * @since 4.9.0
	 *
	 * @param array $arg   Registry arg.
	 * @param mixed $value Raw value.
	 *
	 * @return mixed Coerced value.
	 */
	private function coerce( array $arg, $value ) { // phpcs:ignore Generic.Metrics.CyclomaticComplexity.TooHigh

		$type = $arg[&#039;type&#039;] ?? &#039;string&#039;;

		if ( $type === &#039;bool&#039; ) {
			return in_array( strtolower( (string) $value ), [ &#039;1&#039;, &#039;true&#039;, &#039;yes&#039;, &#039;on&#039; ], true );
		}

		if ( $type === &#039;int&#039; ) {
			// Non-numeric values returned as-is so validate() can report them instead of silently casting to 0.
			return is_numeric( $value ) ? (int) $value : (string) $value;
		}

		return (string) $value;
	}

	/**
	 * Evaluate a required_if rule set against the resolved map.
	 *
	 * Returns:
	 *   - all_match: every gating flag is present AND equals its expected value.
	 *   - any_match: at least one gating flag is present AND equals its expected value.
	 *   - missing:   gating flags that aren&#039;t present in the resolved map.
	 *
	 * Callers use any_match + missing to detect a partial-chain match (a likely forgotten gating flag).
	 *
	 * @since 4.9.0
	 *
	 * @param array $rules    Map of flag =&gt; expected value.
	 * @param array $resolved Map of flag =&gt; resolved value.
	 *
	 * @return array
	 */
	private function required_if_evaluate( array $rules, array $resolved ) {

		$any_match = false;
		$all_match = true;
		$missing   = [];

		foreach ( $rules as $flag =&gt; $expected ) {
			if ( ! array_key_exists( $flag, $resolved ) ) {
				$missing[] = $flag;
				$all_match = false;

				continue;
			}

			if ( $resolved[ $flag ] === $expected ) {
				$any_match = true;
			} else {
				$all_match = false;
			}
		}

		return [
			&#039;all_match&#039; =&gt; $all_match,
			&#039;any_match&#039; =&gt; $any_match,
			&#039;missing&#039;   =&gt; $missing,
		];
	}

	/**
	 * Render a required_if rule set as a human-readable &quot;--flag=value and ...&quot; string.
	 *
	 * @since 4.9.0
	 *
	 * @param array $rules Map of flag =&gt; expected value.
	 *
	 * @return string
	 */
	private function required_if_human( array $rules ) {

		$parts = [];

		foreach ( $rules as $flag =&gt; $expected ) {
			$rendered = is_bool( $expected ) ? ( $expected ? &#039;true&#039; : &#039;false&#039; ) : (string) $expected;
			$parts[]  = sprintf( &#039;--%s=%s&#039;, $flag, $rendered );
		}

		return implode( &#039; and &#039;, $parts );
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fwp-mail-smtp%2Fsrc%2FWPCLI%2FOptions'>⬅ Back to Directory</a>