Create a gist now

Instantly share code, notes, and snippets.

@Shelob9 /1.php
Last active May 30, 2018

Embed
What would you like to do?
<?php
/**
* Whenever a post type is registered, ensure we're hooked into it's WP REST API response.
*
* @param string $post_type The newly registered post type.
* @return string That same post type.
*/
function gutenberg_register_post_prepare_functions( $post_type ) {
add_filter( "rest_prepare_{$post_type}", 'gutenberg_add_permalink_template_to_posts', 10, 3 );
add_filter( "rest_prepare_{$post_type}", 'gutenberg_add_block_format_to_post_content', 10, 3 );
add_filter( "rest_prepare_{$post_type}", 'gutenberg_add_target_schema_to_links', 10, 3 );
add_filter( "rest_{$post_type}_collection_params", 'gutenberg_filter_post_collection_parameters', 10, 2 );
add_filter( "rest_{$post_type}_query", 'gutenberg_filter_post_query_arguments', 10, 2 );
return $post_type;
}
add_filter( 'registered_post_type', 'gutenberg_register_post_prepare_functions' );
<?php
namespace CalderaLearn\RestSearch\Features;
use CalderaLearn\RestSearch\ModifyQueryArgsContract;
use CalderaLearn\RestSearch\ModifySchemaContract;
/**
* Class Search
* @package CalderaLearn\RestSearch\Features
*/
class Search
{
/**
* @var ModifyQueryArgsContract
*/
protected $argsModify;
/**
* @var ModifySchemaContract
*/
protected $schemaModify;
/**
* Search constructor.
* @param ModifyQueryArgsContract $argsModify
* @param ModifySchemaContract $schemaModify
*/
public function __construct(ModifyQueryArgsContract $argsModify, ModifySchemaContract $schemaModify){}
/**
* Get underlying ModifyQueryArgsContract
*
* @return ModifyQueryArgsContract
*/
public function getArgsModifier(){}
/**
* Get underlying ModifySchemaContract
*
* @return ModifySchemaContract
*/
public function getSchemaModifier(){}
}
<?php
namespace CalderaLearn\RestSearch\Features;
class Factory
{
/**
* Create Search system
*
* @param array $argumentsToAdd
* @param array $postTypesToSupport
* @return Search
*/
public static function search(array $argumentsToAdd, array $postTypesToSupport){}
}
<?php
namespace CalderaLearn\RestSearch\Tests\Unit;
use CalderaLearn\RestSearch\Features\Factory;
class FeatureFactoryTest extends TestCase
{
/**
* Test setting up system using factory
*
* @covers \CalderaLearn\RestSearch\Features\Factory::search()
*/
public function testArgs()
{
$schema = [
'default' => 'post',
'description' => __('Post type(s) for search query'),
'type' => 'array',
//Limit to public post types and allow query by rest base
'items' =>
[
'enum' => [
'posts',
'pages'
],
'type' => 'string',
],
];
$args = [
'post_type' => [
'schema' => $schema,
'default' => 'post',
]
];
$search = Factory::search($args, [ 'post' ]);
$this->assertSame(
[
'post_type' => $schema
],
$search->getSchemaModifier()->getAdditionalSchemaArguments()
);
$this->assertSame(
[ 'post_type' => 'post' ],
$search->getArgsModifier()->getAdditionalQueryArguments()
);
}
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Interface DoesFilterContract
*
* Interfaces for classes that add filters.
*/
interface DoesFilterContract
{
/**
* Add the filter
*/
public function addHook();
/**
* Remove the filter
*/
public function removeHook();
}
<?php
namespace CalderaLearn\RestSearch\Features;
use CalderaLearn\RestSearch\DoesFilterContract;
use CalderaLearn\RestSearch\ModifyQueryArgsContract;
use CalderaLearn\RestSearch\ModifySchemaContract;
/**
* Class Search
* @package CalderaLearn\RestSearch\Features
*/
class Search implements DoesFilterContract
{
/**
* @var ModifyQueryArgsContract
*/
protected $argsModify;
/**
* @var ModifySchemaContract
*/
protected $schemaModify;
/**
* Search constructor.
* @param ModifyQueryArgsContract $argsModify
* @param ModifySchemaContract $schemaModify
*/
public function __construct(ModifyQueryArgsContract $argsModify, ModifySchemaContract $schemaModify)
{}
/** @inheritdoc */
public function addHook()
{}
/** @inheritdoc */
public function removeHook()
{}
/**
* Get underlying ModifyQueryArgsContract
*
* @return ModifyQueryArgsContract
*/
public function getArgsModifier(){}
/**
* Get underlying ModifySchemaContract
*
* @return ModifySchemaContract
*/
public function getSchemaModifier(){}
/**
* Manages interaction of plugins API and system for post type route schema changes
*
* @param array $query_params
* @param \WP_Post_Type $post_type
* @return array
*/
public function filterSchema(array $query_params, \WP_Post_Type $post_type){}
/**
* Manages interaction of plugins API and system for post type route WP_Query arg whitelist changes
*
* @param array $args
* @param \WP_REST_Request $request
* @return array
*/
public function filterQueryArgs(array $args, \WP_REST_Request $request){}
}
<?php
namespace CalderaLearn\RestSearch\Tests\Unit;
use CalderaLearn\RestSearch\Features\Search;
use CalderaLearn\RestSearch\Tests\Mock\SchemaModifierImplementation;
class SearchFeatureGeneratorTest extends TestCase
{
/**
*
* @covers \CalderaLearn\RestSearch\Features\Search::__construct()
* @covers \CalderaLearn\RestSearch\Features\Search::getSchemaModifier()
* @covers \CalderaLearn\RestSearch\Features\Search::getArgsModifier()
*/
public function testSetModifiers()
{
$schemaModifer = new SchemaModifierImplementation();
$queryArgModifier = new QueryArgModifierImplementation();
$search = new Search($queryArgModifier, $schemaModifer);
$this->assertSame($schemaModifer, $search->getSchemaModifier());
$this->assertSame($queryArgModifier, $search->getArgsModifier());
}
}
<?php
/**
* Test that schema is filtered properly
*
* @covers \CalderaLearn\RestSearch\Features\Search::filterSchema()
* @covers \CalderaLearn\RestSearch\Features\Search::getSchemaModifier()
*/
public function testFilterSchema()
{
$schemaModifer = new SchemaModifierImplementation();
$queryArgModifier = new QueryArgModifierImplementation();
$search = new Search($queryArgModifier, $schemaModifer);
$schemaModifer->setShouldFilter(true);
$wpPostTypeMock = \Mockery::mock('WP_Post_Type');
$wpPostTypeMock->name = 'post';
$this->assertTrue($schemaModifer->shouldFilter($wpPostTypeMock));
$this->assertTrue($search->getSchemaModifier()->shouldFilter($wpPostTypeMock));
$otherArgs = [
'page' => [
'default' => 1,
'type' => 'integer'
]
];
$expectArgs = array_merge($otherArgs, $schemaModifer->getAdditionalSchemaArguments());
$args = $search->filterSchema($otherArgs, $wpPostTypeMock);
$this->assertEquals($expectArgs, $args);
}
/**
* Test that filter args are filtered correctly
*
* @since 1.7.0
*/
public function testFilterQueryArgs()
{
$schemaModifer = new SchemaModifierImplementation();
$queryArgModifier = new QueryArgModifierImplementation();
$search = new Search($queryArgModifier, $schemaModifer);
$queryArgModifier->setShouldFilter(true);
$wpPostTypeMock = \Mockery::mock('WP_Post_Type');
$wpPostTypeMock->name = 'post';
$this->assertTrue($queryArgModifier->shouldFilter($wpPostTypeMock));
$this->assertTrue($search->getArgsModifier()->shouldFilter($wpPostTypeMock));
$otherArgs = [
'page' => [
'default' => 1,
'type' => 'integer'
]
];
$expectArgs = array_merge($otherArgs, $queryArgModifier->getAdditionalQueryArguments());
$wpRestRequest = \Mockery::mock('WP_REST_Request');
$args = $search->filterQueryArgs($otherArgs, $wpRestRequest);
$this->assertEquals($expectArgs, $args);
}
<?php
namespace CalderaLearn\RestSearch;
abstract class FilterQueryArgs implements ModifyQueryArgsContract
{
use UsesPreparedPostTypes;
/**
* @var \WP_REST_Request
*/
private $request;
/**
* @return \WP_REST_Request
*/
protected function getRequest() : \WP_REST_Request
{
return $this->request;
}
/**
* @param \WP_REST_Request $request
* @return $this
*/
protected function setRequest(\WP_REST_Request $request)
{
$this->request = $request;
return $this;
}
}
<?php
namespace CalderaLearn\RestSearch;
abstract class FilterSchema implements ModifySchemaContract
{}
<?php
/**
* A WP_Query with overidden query method
*/
$query = new class ( $args ) extends WP_Query {
/** @inheritdoc */
public function query( $query )
{
//All your query are belong to us.
return [];
}
};
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifySchema
*
* Modifies the REST API route schema so it has an argument "post_type"
*
*
* @package ExamplePlugin
*/
class ModifySchema
{
use UsesPreparedPostTypes;
/**
* The name of the extra argument we are adding to post type routes
*/
const ARGNAME = 'post_type';
/**
* Add post_type to schema
*
* @uses ""rest_{$postType}_collection_params" action
*
* @param array $query_params JSON Schema-formatted collection parameters.
* @param \WP_Post_Type $post_type Post type object.
*
* @return array
*/
public function filterSchema($query_params, $post_type)
{
if ($this->shouldFilter($post_type)) {
$query_params[self::ARGNAME] = [
[
'default' => PostType::RESTBASE,
'description' => __('Post type(s) for search query'),
'type' => 'array',
//Limit to public post types and allow query by rest base
'items' =>
[
'enum' => $this->preparedPostTypes->getPostTypeRestBases(),
'type' => 'string',
],
]
];
}
return $query_params;
}
/**
* Check if this post type's schema should be filtered
*
* @param \WP_Post_Type $WP_Post_Type
* @return bool
*/
public function shouldFilter(\WP_Post_Type $WP_Post_Type): bool
{
return PostType::SLUG === $WP_Post_Type->name;
}
}
<?php
$schemaModify = new class( $postTypesToSupport ) extends FilterSchema {}
$queryModify = new class( $postTypesToSupport ) extends FilterQueryArgs {}
<?php
$schemaModify = new class( $postTypesToSupport ) extends FilterSchema {
/**
* @var array
*/
protected $postTypesToSupport = [];
public function __construct(array $postTypesToSupport)
{
$this->postTypesToSupport = $postTypesToSupport;
}
}
$queryModify = new class( $postTypesToSupport ) extends FilterQueryArgs {
/**
* @var array
*/
protected $postTypesToSupport = [];
public function __construct(array $postTypesToSupport)
{
$this->postTypesToSupport = $postTypesToSupport;
}
}
<?php
namespace CalderaLearn\RestSearch\Features;
use CalderaLearn\RestSearch\ContentGetter\ContentGetterContract;
use CalderaLearn\RestSearch\FilterQueryArgs;
use CalderaLearn\RestSearch\FilterSchema;
use CalderaLearn\RestSearch\ModifySchemaContract;
class Factory
{
/**
* Create Search system
*
* @param array $argumentsToAdd
* @param array $postTypesToSupport
* @return Search
*/
public static function search(array $argumentsToAdd, array $postTypesToSupport)
{
foreach ($argumentsToAdd as $argumentName => $argument) {
$schemaModify = new class( $postTypesToSupport ) extends FilterSchema {
/**
* @var array
*/
protected $arguments = [];
/**
* @var array
*/
protected $postTypesToSupport = [];
public function __construct(array $postTypesToSupport)
{
$this->postTypesToSupport = $postTypesToSupport;
}
public function addArgument(string $argumentName, array $argument = null)
{
$this->arguments[$argumentName] = $argument;
return $this;
}
public function getAdditionalSchemaArguments(): array
{
return $this->arguments;
}
public function shouldFilter(string $postTypeSlug): bool
{
return in_array($postTypeSlug, $this->postTypesToSupport);
}
};
$queryModify = new class( $postTypesToSupport ) extends FilterQueryArgs {
/**
* @var array
*/
protected $arguments = [];
/**
* @var array
*/
protected $postTypesToSupport = [];
public function __construct(array $postTypesToSupport)
{
$this->postTypesToSupport = $postTypesToSupport;
}
public function addArgument(string $argumentName, $default)
{
$this->arguments[$argumentName] = $default;
return $this;
}
public function getAdditionalQueryArguments(): array
{
return $this->arguments;
}
public function shouldFilter(string $postTypeSlug): bool
{
return in_array($postTypeSlug, $this->postTypesToSupport);
}
};
$schemaModify->addArgument($argumentName, $argument['schema']);
$queryModify->addArgument($argumentName, $argument['default']);
return new Search($queryModify, $schemaModify);
}
}
}
<?php
namespace CalderaLearn\RestSearch\Features;
use CalderaLearn\RestSearch\ModifyQueryArgsContract;
use CalderaLearn\RestSearch\ModifySchemaContract;
/**
* Class Search
* @package CalderaLearn\RestSearch\Features
*/
class Search
{
/**
* @var ModifyQueryArgsContract
*/
protected $argsModify;
/**
* @var ModifySchemaContract
*/
protected $schemaModify;
/**
* Search constructor.
* @param ModifyQueryArgsContract $argsModify
* @param ModifySchemaContract $schemaModify
*/
public function __construct(ModifyQueryArgsContract $argsModify, ModifySchemaContract $schemaModify)
{
$this->argsModify = $argsModify;
$this->schemaModify = $schemaModify;
}
/**
* Manages interaction of plugins API and system for post type route schema changes
*
* @param array $query_params
* @param \WP_Post_Type $post_type
* @return array
*/
public function filterSchema(array $query_params, \WP_Post_Type $post_type)
{
if ($this->schemaModify->shouldFilter($post_type)) {
$query_params = array_merge($query_params, $this->schemaModify->getAdditionalSchemaArguments());
}
return $query_params;
}
/**
* Manages interaction of plugins API and system for post type route WP_Query arg whitelist changes
*
* @param array $args
* @param \WP_REST_Request $request
* @return array
*/
public function filterQueryArgs(array $args, \WP_REST_Request $request)
{
if ($this->argsModify->shouldFilter($request)) {
$args = array_merge($args, $this->argsModify->getAdditionalQueryArguments());
}
return $args;
}
}
<?php
namespace CalderaLearn\RestSearch;
interface ModifyQueryArgsContract
{
/**
* Check if we should filter request args
*
* @param string $postTypeRestBase
* @return bool
*/
public function shouldFilter(string $postTypeRestBase): bool;
/**
* Return the additional query arguments that should be added
*
* @return array
*/
public function getAdditionalQueryArguments(): array;
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifySchema
*
* Modifies the REST API route schema so it has an argument "post_type"
*
*
* @package ExamplePlugin
*/
interface ModifySchemaContract
{
/**
* Check if this post type's schema should be filtered
*
* @param string $postTypeRestBase
* @return bool
*/
public function shouldFilter(string $postTypeRestBase): bool;
/**
* Return the additional schema arguments that should be added
*
* @return array
*/
public function getAdditionalSchemaArguments(): array;
}
<?php
namespace CalderaLearn\RestSearch;
use CalderaLearn\RestSearch\ContentGetter\ContentGetterContract;
use WP_Query;
/**
* Class FilterWPQuery
*
* Changes WP_Query object during REST API requests
*
* @package CalderaLearn\RestSearch
*/
class FilterWPQuery implements FiltersPreWPQuery
{
/**
* Content Getter Implementation.
*
* @var ContentGetterContract
*/
protected static $contentGetter;
/**
* Current REST request
*
* @var \WP_REST_Request
*/
protected static $request;
/**
* Priority for filter
*
* @var int
*/
protected static $filterPriority = 10;
/**
* Get or set search filter by binding a specific content getter implementation.
*
* @param ContentGetterContract $contentGetter Instance of the implementation.
*
* @return void
*/
public static function setContentGetter(ContentGetterContract $contentGetter)
{
static::$contentGetter = $contentGetter;
}
/**
* @return ContentGetterContract
*/
public static function getContentGetter()
{
return static::$contentGetter;
}
/**
* Filters the results of WP_Query objects.
*
* This callback demonstrates how to use a different way to set the posts that WP_Query returns.
*
* @uses "posts_pre_query"
*
* @param array|null $postsOrNull Array of posts or null.
* @param WP_Query $query Instance of the query.
*
* @return array Returns an array of WP_Post objects.
*/
public static function filterPreQuery($postsOrNull, WP_Query $query)
{
if (! static::shouldFilter($postsOrNull)) {
return $postsOrNull;
}
return static::getPosts($query);
}
/** @inheritdoc */
public static function shouldFilter($postsOrNull): bool
{
if (! is_null($postsOrNull)) {
return false;
}
return static::doingREST();
}
/**
* Checks if WordPress is doing a REST request.
*
* @return bool
*/
private static function doingREST(): bool
{
return did_action('rest_api_init');
}
/** @inheritdoc */
public static function addFilter(): bool
{
add_filter('rest_pre_serve_request', [FilterWPQuery::class, 'captureRequest' ]);
return add_filter('posts_pre_query', [FilterWPQuery::class, 'filterPreQuery'], static::$filterPriority, 2);
}
/** @inheritdoc */
public static function removeFilter(): bool
{
remove_filter('rest_pre_serve_request', [FilterWPQuery::class, 'captureRequest' ]);
return remove_filter('posts_pre_query', [FilterWPQuery::class, 'filterPreQuery'], static::$filterPriority);
}
/** @inheritdoc */
public static function getFilterPriority(): int
{
return static::$filterPriority;
}
/**
* At "rest_pre_serve_request" get request object and store for later
*
* @param null|\WP_REST_Response $return
* @param null|\WP_REST_Response$result
* @param \WP_REST_Request $request
* @return null|\WP_REST_Response
*/
public static function captureRequest($return, $result, $request)
{
static::$request = $request;
return $return;
}
/** @inheritdoc */
public static function getPosts(WP_Query $query): array
{
$request = is_object(static::$request) ? static::$request : new \WP_REST_Request();
return static::$contentGetter->getContent($query, $request);
}
}
<?php
public static function captureRequest( $return, $result, $request )
{
static::$request = $request;
return $return;
}
/** @inheritdoc */
public static function getPosts(WP_Query $query): array
{
$request = is_object( static::$request ) ? static::$request ? new \WP_REST_Request();
return static::$contentGetter->getContent($query,$request);
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifySchema
*
* Modifies the REST API route schema so it has an argument "post_type"
*
*
* @package ExamplePlugin
*/
interface ModifySchemaContract
{
/**
* Return the additional schema arguments that should be added
*
* @return array
*/
public function getAdditionalSchemaArguments(): array;
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifySchema
*
* Modifies the REST API route schema so it has an argument "post_type"
*
*
* @package ExamplePlugin
*/
class ModifySchema implements ModifySchemaContract
{
use UsesPreparedPostTypes;
/**
* The name of the extra argument we are adding to post type routes
*/
const ARGNAME = 'post_type';
/* @inheritdoc */
public function getAdditionalSchemaArguments(): array
{
return [
self::ARGNAME => [
[
'default' => PostType::RESTBASE,
'description' => __('Post type(s) for search query'),
'type' => 'array',
//Limit to public post types and allow query by rest base
'items' =>
[
'enum' => $this->preparedPostTypes->getPostTypeRestBases(),
'type' => 'string',
],
]
]
];
}
/* @inheritdoc */
public function filterSchema($query_params, $post_type)
{
if ($this->shouldFilter($post_type)) {
$query_params = array_merge($this->getArguments(), $query_params);
}
return $query_params;
}
/* @inheritdoc */
public function shouldFilter(\WP_Post_Type $WP_Post_Type): bool
{
return PostType::SLUG === $WP_Post_Type->name;
}
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifySchema
*
* Modifies the REST API route schema so it has an argument "post_type"
*
*
* @package ExamplePlugin
*/
interface ModifySchemaContract
{
/**
* Add post_type to schema
*
* @uses ""rest_{$postType}_collection_params" action
*
* @param array $query_params JSON Schema-formatted collection parameters.
* @param \WP_Post_Type $post_type Post type object.
*
* @return array
*/
public function filterSchema($query_params, $post_type);
/**
* Check if this post type's schema should be filtered
*
* @param \WP_Post_Type $WP_Post_Type
* @return bool
*/
public function shouldFilter(\WP_Post_Type $WP_Post_Type): bool;
/**
* Return the additional schema arguments that should be added
*
* @return array
*/
public function getAdditionalSchemaArguments(): array;
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifyQuery
*
* Modify WP_Query Args
*
* @package ExamplePlugin
*/
class ModifyQueryArgs
{
use UsesPreparedPostTypes;
/**
* Filter query args if needed
*
* @param array $args Key value array of query var to query value.
* @param \WP_REST_Request $request The request used.
*
* @return array
*/
public function filterQueryArgs($args, $request)
{
if ($this->shouldFilter($request)) {
add_filter('posts_pre_query', [FilterWPQuery::class, 'posts_pre_query'], 10, 2);
$args['post_type'] = $this->restBasesToPostTypeSlugs($request[ModifySchema::ARGNAME]);
}
return $args;
}
/**
* Check if we should filter request args
*
* @param \WP_REST_Request $request
* @return bool
*/
public function shouldFilter(\WP_REST_Request $request): bool
{
$attributes = $request->get_attributes();
if (isset($attributes['args'][ModifySchema::ARGNAME])) {
if ($request->get_param(ModifySchema::ARGNAME)) {
return true;
}
}
return false;
}
/**
* Convert an array of rest bases to post type slugs
*
* @param array $postTypes
* @return array
*/
public function restBasesToPostTypeSlugs(array $postTypes): array
{
$postTypeSlugs = [];
foreach ($postTypes as $postTypeRestBase) {
if ($this->preparedPostTypes->restBaseToSlug($postTypeRestBase)) {
$postTypeSlugs[] = $this->preparedPostTypes->restBaseToSlug($postTypeRestBase);
}
}
return $postTypeSlugs;
}
}
<?php
namespace CalderaLearn\RestSearch;
interface ModifyQueryArgsContract
{
/**
* Filter query args if needed
*
* @param array $args Key value array of query var to query value.
* @param \WP_REST_Request $request The request used.
*
* @return array
*/
public function filterQueryArgs($args, $request);
/**
* Check if we should filter request args
*
* @param \WP_REST_Request $request
* @return bool
*/
public function shouldFilter(\WP_REST_Request $request): bool;
/**
* Return the additional query arguments that should be added
*
* @return array
*/
public function getAdditionalQueryArguments(): array;
}
<?php
namespace CalderaLearn\RestSearch;
/**
* Class ModifyQuery
*
* Modify WP_Query Args
*
* @package ExamplePlugin
*/
class ModifyQueryArgs implements ModifyQueryArgsContract
{
use UsesPreparedPostTypes;
/**
* @var \WP_REST_Request
*/
protected $request;
/** @inheritdoc */
public function getAdditionalQueryArguments(): array
{
return [
'post_type' => $this->restBasesToPostTypeSlugs($this->request[ModifySchema::ARGNAME])
];
}
/** @inheritdoc */
public function filterQueryArgs($args, $request)
{
if ($this->shouldFilter($request)) {
$this->request = $request;
add_filter('posts_pre_query', [FilterWPQuery::class, 'posts_pre_query'], 10, 2);
$args = array_merge($this->getAdditionalQueryArguments(), $args);
}
return $args;
}
/** @inheritdoc */
public function shouldFilter(\WP_REST_Request $request): bool
{
$attributes = $request->get_attributes();
if (isset($attributes['args'][ModifySchema::ARGNAME])) {
if ($request->get_param(ModifySchema::ARGNAME)) {
return true;
}
}
return false;
}
/**
* Convert an array of rest bases to post type slugs
*
* @param array $postTypes
* @return array
*/
public function restBasesToPostTypeSlugs(array $postTypes): array
{
$postTypeSlugs = [];
foreach ($postTypes as $postTypeRestBase) {
if ($this->preparedPostTypes->restBaseToSlug($postTypeRestBase)) {
$postTypeSlugs[] = $this->preparedPostTypes->restBaseToSlug($postTypeRestBase);
}
}
return $postTypeSlugs;
}
}
<?php
namespace CalderaLearn\RestSearch\Tests\Unit;
use CalderaLearn\RestSearch\Features\Factory;
class FeatureFactoryTest extends TestCase
{
/**
* Test setting up system using factory
*
*/
public function testArgs()
{
$schema = [
'default' => 'post',
'description' => __('Post type(s) for search query'),
'type' => 'array',
//Limit to public post types and allow query by rest base
'items' =>
[
'enum' => [
'posts',
'pages'
],
'type' => 'string',
],
];
$args = [
'post_type' => [
'schema' => $schema,
'default' => 'post',
]
];
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment