Exemplo n.º 1
0
 private function mapCollectionType($fieldName, Field $field, ClassMetadata $metadata)
 {
     $options = $field->getOptions();
     $collectionField = $this->fieldLoader->load($options['field_type'], FieldOptions::create($options['field_options']));
     // assume that other types are scalars...
     $this->__invoke($fieldName, $collectionField, $metadata, ['serialize_scalar' => true]);
 }
Exemplo n.º 2
0
 public function __construct($class, $name, $type, $role, $group, array $options)
 {
     parent::__construct($class, $name);
     $this->type = $type;
     $this->role = $role;
     $this->group = $group;
     $this->options = FieldOptions::create($options);
 }
 private function createProperty(string $propertyName, string $type, string $group = null, array $options)
 {
     $property = $this->prophesize(PropertyMetadata::class);
     $property->getType()->willReturn($type);
     $property->getGroup()->willReturn($group);
     $property->getOptions()->willReturn(FieldOptions::create($options));
     $property->getName()->willReturn($propertyName);
     return $property;
 }
Exemplo n.º 4
0
 public function createView(ViewFactory $factory, $data, array $options) : ViewInterface
 {
     if (!is_array($data) && !$data instanceof \Traversable) {
         throw new \InvalidArgumentException(sprintf('Data must be traversable or an array, got: "%s"', is_object($data) ? get_class($data) : gettype($data)));
     }
     if (is_array($data)) {
         $data = new \ArrayIterator($data);
     }
     $field = $this->fieldLoader->load($options['field_type'], FieldOptions::create($options['field_options']));
     return new CollectionView($factory, $data, $field->getViewType(), $field->getViewOptions());
 }
Exemplo n.º 5
0
 /**
  * It should cache fields.
  */
 public function testCache()
 {
     $this->fieldRegistry->get('foobar')->shouldBeCalledTimes(2)->willReturn($this->field1);
     $this->fieldRegistry->get('barfoo')->shouldBeCalledTimes(1)->willReturn($this->field1);
     $field1 = $this->loader->load('foobar', FieldOptions::create([]));
     $field2 = $this->loader->load('barfoo', FieldOptions::create([]));
     $field3 = $this->loader->load('foobar', FieldOptions::create([]));
     $field4 = $this->loader->load('foobar', FieldOptions::create(['shared' => ['fo' => 'ba']]));
     $this->assertSame($field1, $field3);
     $this->assertNotSame($field2, $field1);
     $this->assertNotSame($field4, $field3);
 }
 /**
  * It should create a collection view from an iterator.
  * It should create a collection view from an array.
  *
  * @dataProvider provideViewIterate
  */
 public function testViewIterate($data)
 {
     $fieldType = 'foo';
     $viewType = 'view_type';
     $viewOptions = ['foo' => 'bar'];
     $fieldOptions = ['view' => $viewOptions];
     $this->fieldLoader->load($fieldType, FieldOptions::create($fieldOptions))->willReturn($this->field->reveal());
     $this->field->getViewType()->willReturn($viewType);
     $this->field->getViewOptions()->willReturn($viewOptions);
     $view = $this->getType()->createView($this->factory->reveal(), $data, ['field_type' => $fieldType, 'field_options' => $fieldOptions]);
     $this->assertInstanceOf(CollectionView::class, $view);
 }
 private function doTestMapOptions($type)
 {
     $setMethod = 'set' . $type . 'Mapper';
     $resolveMethod = 'resolve' . $type . 'Options';
     $this->resolver->setDefault('foo', 'bar');
     $this->resolver->setDefault('bar', 'foo');
     $this->resolver->{$setMethod}(function (array $options, array $shared) {
         return ['baz' => $shared['bar'], 'ban' => 'bon'];
     });
     $options = $this->resolver->resolve([]);
     $this->assertEquals(['foo' => 'bar', 'bar' => 'foo'], $options);
     $this->assertEquals(['baz' => 'foo', 'ban' => 'bon'], $this->resolver->{$resolveMethod}(FieldOptions::create([])));
 }
Exemplo n.º 8
0
 private function mapCollectionType($fieldName, Field $field, ClassMetadata $metadata)
 {
     $options = $field->getOptions();
     $collectionField = $this->fieldLoader->load($options['field_type'], FieldOptions::create($options['field_options']));
     if ($collectionField->getStorageType() === Type\ObjectType::class) {
         $options = $collectionField->getStorageOptions();
         $this->unrestrictChildClass($options['class'], $metadata);
         $metadata->mapChildren(['fieldName' => $fieldName, 'fetchDepth' => 1, 'filter' => $this->encoder->encode($fieldName) . '-*', 'cascade' => ClassMetadata::CASCADE_ALL, 'nullable' => true]);
         return;
     }
     if ($collectionField->getStorageType() === Type\ReferenceType::class) {
         $metadata->mapManyToMany(['fieldName' => $fieldName, 'strategy' => 'hard', 'nullable' => true, 'cascade' => ClassMetadata::CASCADE_ALL]);
         return;
     }
     // assume that other types are scalars...
     $this->__invoke($fieldName, $collectionField, $metadata, ['multivalue' => true]);
 }
Exemplo n.º 9
0
 /**
  * If should create an object view.
  */
 public function testCreateView()
 {
     $content = new \stdClass();
     $value = 'value';
     $this->metadataFactory->getMetadataForClass('stdClass')->willReturn($this->classMetadata->reveal());
     $this->classMetadata->getPropertyMetadata()->willReturn([$this->propertyMetadata1->reveal()]);
     $viewOptions = ['foo' => 'bar'];
     $options = FieldOptions::create(['view' => $viewOptions]);
     $this->propertyMetadata1->getType()->willReturn('foobar');
     $this->propertyMetadata1->getName()->willReturn('prop1');
     $this->propertyMetadata1->getOptions()->willReturn($options);
     $this->propertyMetadata1->getValue($content)->willReturn($value);
     $this->factory->create('foobar', $value, $viewOptions)->willReturn($this->childView->reveal());
     $this->fieldLoader->load('foobar', $options)->willReturn($this->field->reveal());
     $this->field->getViewType()->willReturn('foobar');
     $this->field->getViewOptions()->willReturn($viewOptions);
     $view = $this->getType()->createView($this->factory->reveal(), $content, []);
     $this->assertInstanceOf(ObjectView::class, $view);
     $view = $view['prop1'];
     $this->assertSame($this->childView->reveal(), $view);
 }
Exemplo n.º 10
0
 public function configureOptions(FieldOptionsResolver $options)
 {
     $options->setRequired(['field_type']);
     $options->setDefault('field_options', []);
     $options->setFormMapper(function (array $options, array $shared) {
         // default to allowing add / delete (contrary to the form types
         // default behavior).
         $options = array_merge(['allow_add' => true, 'allow_delete' => true], $options);
         // resolve the form options for the colletion entry.
         $field = $this->registry->get($shared['field_type']);
         $resolver = new FieldOptionsResolver();
         $field->configureOptions($resolver);
         $entryOptions = $resolver->resolveFormOptions(FieldOptions::create($shared['field_options']));
         // do not allow entry_type or entry_options to be overridden.
         $options['entry_type'] = $field->getFormType();
         $options['entry_options'] = $entryOptions;
         return $options;
     });
     $options->setViewMapper(function ($options, $shared) {
         return array_merge($options, ['field_type' => $shared['field_type'], 'field_options' => $shared['field_options']]);
     });
 }
Exemplo n.º 11
0
 protected function getField(array $config)
 {
     return $this->fieldLoader->load($this->getFieldName(), FieldOptions::create($config));
 }
Exemplo n.º 12
0
 private function createField(array $options)
 {
     return new Field($this->innerField->reveal(), FieldOptions::create($options));
 }
 public function resolveStorageOptions(FieldOptions $options) : array
 {
     return $this->resolveOptions($this->storageMapper, $options->getSharedOptions(), $options->getViewOptions());
 }