/**
* {@inheritdoc}
*/
public function fill(Builder $builder)
{
if (Util::isUserClass($builder->getClass())) {
$refl = new \ReflectionClass($builder->getClass());
$filter = \ReflectionProperty::IS_PRIVATE | \ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED;
foreach ($refl->getProperties($filter) as $property) {
if ($this->isPropertyAccessible($property->getName(), $refl)) {
$this->makeField($property, $builder);
}
}
}
}
/**
* {@inheritdoc}
*/
public function fill(Builder $builder)
{
$class = $builder->getClass();
if (Util::isUserClass($class) && class_exists($class, true)) {
$refl = new \ReflectionClass($class);
/** @var Annotations\Dogma $annot */
$annot = $this->reader->getClassAnnotation($refl, 'Bravesheep\\Dogmatist\\Guesser\\Annotations\\Dogma');
if (null !== $annot) {
$builder->setStrict($annot->strict);
}
$this->processConstructor($refl, $builder);
$this->processFields($refl, $builder);
}
}
/**
* @param string $type
* @return array
*/
public static function resolve($type)
{
$name = Util::normalizeName($type);
if (isset(self::$mappings[$name])) {
return self::$mappings[$name];
} elseif (preg_match("/^(is|has)_/", $name) === 1) {
return [Field::TYPE_FAKE, false, ['boolean']];
} elseif (preg_match("/_at\$/", $name) === 1) {
return [Field::TYPE_FAKE, false, ['dateTime']];
} elseif (false !== strpos($name, '_')) {
$name = str_replace('_', '', $name);
return self::resolve($name);
} else {
return false;
}
}
public function fill(Builder $builder)
{
$manager = null;
if (Util::isUserClass($builder->getClass())) {
$manager = $this->registry->getManagerForClass($builder->getClass());
if (null !== $manager) {
try {
$metadata = $manager->getClassMetadata($builder->getClass());
if ($metadata instanceof ClassMetadata) {
$this->process($metadata, $builder);
}
} catch (MappingException $e) {
}
}
}
}
it("normalizes camelcased to underscored", function () {
expect(Util::normalizeName("someCamelCasedExample"))->toBe('some_camel_cased_example');
expect(Util::normalizeName("FirstLetterCamelCased"))->toBe('first_letter_camel_cased');
expect(Util::normalizeName("Mixed_styleCamelCase"))->toBe('mixed_style_camel_case');
});
it("does not change underscored names", function () {
expect(Util::normalizeName("test"))->toBe("test");
expect(Util::normalizeName("test_case"))->toBe("test_case");
});
});
describe("::isSystemClass", function () {
it("checks for the array and object system classes", function () {
expect(Util::isSystemClass('array'))->toBe(true);
expect(Util::isSystemClass('object'))->toBe(true);
expect(Util::isSystemClass('stdClass'))->toBe(true);
});
it("does not return true for user classes", function () {
expect(Util::isSystemClass('Bravesheep\\Dogmatist\\Dogmatist'))->toBe(false);
});
});
describe("::isUserClass", function () {
it("checks whether an identifier is not a system class", function () {
expect(Util::isUserClass('Bravesheep\\Dogmatist\\Dogmatist'))->toBe(true);
});
it("returns false for objects and arrays", function () {
expect(Util::isUserClass('array'))->toBe(false);
expect(Util::isUserClass('object'))->toBe(false);
expect(Util::isUserClass('stdClass'))->toBe(false);
});
});
});
