///|
pub(all) enum Sex {
Female
Male
Generic
}
///|
pub fn Faker::person_sex_type(
self : Faker,
include_generic~ : Bool = false,
) -> Sex raise {
self.array_element(
if include_generic {
[Female, Male, Generic]
} else {
[Female, Male]
},
)
}
///|
fn Faker::optional_definition(self : Faker, path : String) -> Json? {
let parts = path.split(".").map(s => s.to_owned()).to_array()
let entry = parts[:parts.length().min(2)].to_owned().join(".")
let tail = parts[parts.length().min(2):].to_owned().join(".")
for locale in self.locales {
if locale.get(entry) is Some(value) {
if tail == "" {
return Some(value)
}
return Locale::from_json(value).get(tail)
}
}
None
}
///|
fn Faker::person_entry(
self : Faker,
path : String,
sex : Sex?,
) -> Array[Json] raise {
let sex = sex.unwrap_or_else(() => self.person_sex_type())
fn entries(key : String) -> Array[Json]? {
match self.optional_definition(path + "." + key) {
Some(Array(xs)) => Some(xs)
_ => None
}
}
let generic = entries("generic")
match sex {
Generic =>
generic.unwrap_or_else(() => {
self.array_element([entries("female"), entries("male")]).unwrap_or([])
})
Female | Male => {
let binary = entries(if sex is Female { "female" } else { "male" })
match (binary, generic) {
(Some(xs), Some(ys)) =>
self.weighted_array_element([
(3 * xs.length().to_double().sqrt(), xs),
(ys.length().to_double().sqrt(), ys),
])
(Some(xs), _) | (_, Some(xs)) => xs
_ => raise MissingDefinition(path)
}
}
}
}
///|
pub fn Faker::person_first_name(self : Faker, sex? : Sex) -> String raise {
json_string(self.array_element(self.person_entry("person.first_name", sex)))
}
///|
pub fn Faker::person_last_name(self : Faker, sex? : Sex) -> String raise {
if self.optional_definition("person.last_name_pattern") is Some(Object(_)) {
return self.fake(
self.weighted_pattern(self.person_entry("person.last_name_pattern", sex)),
)
}
json_string(self.array_element(self.person_entry("person.last_name", sex)))
}
///|
pub fn Faker::person_middle_name(self : Faker, sex? : Sex) -> String raise {
json_string(self.array_element(self.person_entry("person.middle_name", sex)))
}
///|
pub fn Faker::person_prefix(self : Faker, sex? : Sex) -> String raise {
json_string(self.array_element(self.person_entry("person.prefix", sex)))
}
///|
fn Faker::weighted_pattern(self : Faker, values : Array[Json]) -> String raise {
self.weighted_array_element(
values.map(value => {
let weight = match json_field(value, "weight") {
Number(n, ..) => n
_ => raise InvalidDefinition("weight")
}
(weight, json_string(json_field(value, "value")))
}),
)
}
///|
pub fn Faker::person_full_name(
self : Faker,
first_name? : String,
last_name? : String,
sex? : Sex,
) -> String raise {
let sex = sex.unwrap_or_else(() => self.person_sex_type())
let first_name = first_name.unwrap_or_else(() => self.person_first_name(sex~))
let last_name = last_name.unwrap_or_else(() => self.person_last_name(sex~))
guard self.definition("person.name") is Array(patterns) else {
raise InvalidDefinition("person.name")
}
let mut pattern = self.weighted_pattern(patterns)
// Preserve upstream evaluation order even if a locale rearranges these tokens.
for
(key, generate) in [
("person.prefix", () => self.person_prefix(sex~)),
("person.firstName", () => first_name),
("person.middleName", () => self.person_middle_name(sex~)),
("person.lastName", () => last_name),
("person.suffix", () => self.person_suffix()),
] {
pattern = replace_placeholder(pattern, key, generate)
}
pattern
}