Carbon_Fields\Container\Fulfillable\Translator\Array_Translator

Complexity

Total Complexity

24

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

40%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	condition_to_foreign()	0	7	1
C	fulfillable_collection_to_foreign()	0	36	7
A	foreign_to_fulfillable()	0	11	3
A	foreign_to_native_condition()	0	10	3
A	foreign_to_native_fulfillable_collection()	0	11	4
B	foreign_to_json()	0	27	5

<?php

namespace Carbon_Fields\Container\Fulfillable\Translator;

use Carbon_Fields\App;
use Carbon_Fields\Container\Condition\Factory;
use Carbon_Fields\Container\Fulfillable\Fulfillable;
use Carbon_Fields\Container\Fulfillable\Fulfillable_Collection;
use Carbon_Fields\Container\Condition\Condition;
use Carbon_Fields\Exception\Incorrect_Syntax_Exception;

class Array_Translator extends Translator {

	/**
	 * Condition factory used to translated condition types
	 *
	 * @var Factory
	 */
	protected $condition_factory;

	/**
	 * Constructor
	 *
	 * @param Factory $condition_factory
	 */
	public function __construct( Factory $condition_factory ) {
		$this->condition_factory = $condition_factory;
	}

	/**
	 * Translate a Condition
	 *
	 * @param  Condition $condition
	 * @return mixed
	 */
	protected function condition_to_foreign( Condition $condition ) {
		return array(
			'type' => $this->condition_factory->get_type( get_class( $condition ) ),
			'compare' => $condition->get_comparison_operator(),
			'value' => $condition->get_value(),
		);
	}

	/**
	 * Translate a Fulfillable_Collection
	 *
	 * @param  Fulfillable_Collection $fulfillable_collection
	 * @return mixed
	 */
	protected function fulfillable_collection_to_foreign( Fulfillable_Collection $fulfillable_collection ) {
		$fulfillables = $fulfillable_collection->get_fulfillables();
		if ( empty( $fulfillables ) ) {
			return array();
		}

		$collection = array(
			'relation' => 'AND',
		);

		$relations = array();
		foreach ( $fulfillables as $fulfillable_tuple ) {
			$comparison = $fulfillable_tuple['fulfillable_comparison'];
			$fulfillable = $fulfillable_tuple['fulfillable'];

			if ( ! isset( $relations[ $comparison ] ) ) {
				$relations[ $comparison ] = array();
			}

			$relations[ $comparison ][] = $this->fulfillable_to_foreign( $fulfillable );
		}

		if ( ! empty( $relations['OR'] ) ) {
			$collection['relation'] = 'OR';
		}
		foreach ( $relations as $relation => $fulfillables ) {
			$collection[] = array( 'relation' => $relation ) + $fulfillables;
		}

		if ( count( $relations ) === 1 ) {
			// we only have one relation group so we simplify the fulfillables with 1 level
			$collection = $collection[0];
		}

		return array_filter( $collection );
	}

	/**
	 * Translate foreign data to a Fulfillable
	 *
	 * @param  mixed       $foreign
	 * @return Fulfillable
	 */
	public function foreign_to_fulfillable( $foreign ) {
		if ( ! is_array( $foreign ) ) {
			Incorrect_Syntax_Exception::raise( 'Invalid data passed to array condition translator: ' . print_r( $foreign, true ) );
		}

		if ( isset( $foreign['type'] ) ) {
			return $this->foreign_to_native_condition( $foreign );
		}

		return $this->foreign_to_native_fulfillable_collection( $foreign );
	}

	/**
	 * Translate a Condition
	 *
	 * @param  array     $foreign
	 * @return Condition
	 */
	protected function foreign_to_native_condition( $foreign ) {
		$condition_type = $foreign['type'];
		$comparison_operator = isset( $foreign['compare'] ) ? $foreign['compare'] : '=';
		$value = isset( $foreign['value'] ) ? $foreign['value'] : '';

		$condition = $this->condition_factory->make( $condition_type );
		$condition->set_comparison_operator( $comparison_operator );
		$condition->set_value( $value );
		return $condition;
	}

	/**
	 * Translate a Fulfillable_Collection
	 *
	 * @param  array                  $foreign
	 * @return Fulfillable_Collection
	 */
	protected function foreign_to_native_fulfillable_collection( $foreign ) {
		$fulfillable_comparison = isset( $foreign['relation'] ) ? $foreign['relation'] : 'AND';
		$collection = App::resolve( 'container_condition_fulfillable_collection' );
		foreach ( $foreign as $key => $value ) {
			if ( $key === 'relation' ) {
				continue; // ignore the relation key - we are only interested in condition definitions
			}
			$collection->add_fulfillable( $this->foreign_to_fulfillable( $value ), $fulfillable_comparison );
		}
		return $collection;
	}

	/**
	 * Make conditions friendly for frontend.
	 *
	 * @param  array $foreign
	 * @return array
	 */
	public function foreign_to_json( $foreign ) {
		if ( empty( $foreign ) ) {
			return array(
				'relation' => 'AND',
				'conditions' => array(),
			);
		}

		$conditions = array();

		foreach ( $foreign as $key => $value ) {
			if ( $key === 'relation' ) {
				continue;
			}

			if ( isset( $value['relation'] ) ) {
				$conditions[] = $this->foreign_to_json( $value );
			} else {
				$conditions[] = $value;
			}
		}

		return array(
			'relation' => $foreign['relation'],
			'conditions' => $conditions,
		);
	}
}