Name parser: recursively extracting the people. Also extracting the parser disputes. Added test cases.

Author: fabiankessler

src/org/nameapi/client/services/parser/personnameparser/PersonNameParserService.php

@@ -56,47 +56,13 @@ public function parse(NaturalInputPerson $person) {
         try {
             $matches = array(); //ParsedPersonMatch
             foreach ($response->matches as $match) {
-                $gender = null;
-                if (isSet($match->parsedPerson->gender)) {
-                    $gender = new PersonGenderResult(
-                        new ComputedPersonGender($match->parsedPerson->gender->gender),
-                        (isset( $match->parsedPerson->gender->maleProportion) ?  $match->parsedPerson->gender->maleProportion : null),
-                        $match->parsedPerson->gender->confidence
-                    );
-                }
+                $pp = $match->parsedPerson;
 
-                $terms = array();
-                if (isSet($match->parsedPerson->outputPersonName->terms)) {
-                    foreach ($match->parsedPerson->outputPersonName->terms as $term) {
-                        array_push($terms, new Term($term->string, new OutputTermType($term->termType)));
-                    }
-                }
-                $outputPersonName = new OutputPersonName($terms);
-
-                $people = array();
-                if (isSet($match->parsedPerson->people)) {
-                    foreach ($match->parsedPerson->people as $onePerson) {
-                        $terms = array();
-                        foreach ($onePerson->terms as $term) {
-                            array_push($terms, new Term($term->string, new OutputTermType($term->termType)));
-                        }
-                        array_push($names, new OutputPersonName($terms));
-                    }
-                }
-
-                $parsedPerson = new ParsedPerson(
-                    new PersonType($match->parsedPerson->personType),
-                    new PersonRole($match->parsedPerson->personRole),
-                    $gender,
-                    (isSet($match->parsedPerson->addressingGivenName)) ? $match->parsedPerson->addressingGivenName : null,
-                    (isSet($match->parsedPerson->addressingSurname)) ? $match->parsedPerson->addressingSurname : null,
-                    $outputPersonName,
-                    $people
-                );
+                $parsedPerson = $this->extractPerson($pp);
 
                 $parserDisputes = array();
-                if (isSet($match->parsedPerson->parserDisputes)) {
-                    foreach ($match->parsedPerson->parserDisputes as $dispute) {
+                if (isSet($match->parserDisputes)) {
+                    foreach ($match->parserDisputes as $dispute) {
                         array_push($parserDisputes, new ParserDispute(new DisputeType($dispute->disputeType), $dispute->message));
                     }
                 }
@@ -115,4 +81,51 @@ public function parse(NaturalInputPerson $person) {
         }
     }
 
+    private function extractGender($parsedPerson) {
+        if (!isSet($parsedPerson->gender)) {
+            return null;
+        }
+        return new PersonGenderResult(
+            new ComputedPersonGender($parsedPerson->gender->gender),
+            (isset( $parsedPerson->gender->maleProportion) ?  $parsedPerson->gender->maleProportion : null),
+            $parsedPerson->gender->confidence
+        );
+    }
+
+    private function extractTerms($parsedPerson) {
+        $terms = array();
+        if (isSet($parsedPerson->outputPersonName) && isSet($parsedPerson->outputPersonName->terms)) {
+            foreach ($parsedPerson->outputPersonName->terms as $term) {
+                array_push($terms, new Term($term->string, new OutputTermType($term->termType)));
+            }
+        }
+        return new OutputPersonName($terms);
+    }
+
+    private function extractPeople($parsedPerson) {
+        $people = array();
+        if (isSet($parsedPerson->people)) {
+            foreach ($parsedPerson->people as $onePerson) {
+                $extractedPerson = $this->extractPerson($onePerson);
+                array_push($people, $extractedPerson);
+            }
+        }
+        return $people;
+    }
+
+    private function extractPerson($pp) {
+        $gender = $this->extractGender($pp);
+        $outputPersonName = $this->extractTerms($pp);
+        $people = $this->extractPeople($pp);
+        return new ParsedPerson(
+            new PersonType($pp->personType),
+            new PersonRole($pp->personRole),
+            $gender,
+            (isSet($pp->addressingGivenName)) ? $pp->addressingGivenName : null,
+            (isSet($pp->addressingSurname)) ? $pp->addressingSurname : null,
+            $outputPersonName,
+            $people
+        );
+    }
+
 }

tests/functional/PersonNameParserServiceTest.php

@@ -44,6 +44,43 @@ public function testParse() {
         $this->assertEquals('Doe', $bestMatch->getParsedPerson()->getAddressingSurname());
         $this->assertEquals('John', $bestMatch->getParsedPerson()->getOutputPersonName()->getFirst('GIVENNAME')->getString());
         $this->assertEquals('Doe', $bestMatch->getParsedPerson()->getOutputPersonName()->getFirst('SURNAME')->getString());
+
+        $this->assertEquals(1, sizeof($bestMatch->getParserDisputes()));
+        $this->assertEquals('GENDER', (string)$bestMatch->getParserDisputes()[0]->getDisputeType());
+    }
+
+    public function test_parseTwoPeople() {
+        //setup code:
+        $context = Context::builder()
+            ->priority(Priority::REALTIME())
+            ->build();
+        $myApiKey = 'test'; //grab one from nameapi.org
+        $serviceFactory = new ServiceFactory($myApiKey, $context, Host::http('rc50-api.nameapi.org'), '5.0');
+        $personNameParser = $serviceFactory->parserServices()->personNameParser();
+
+        //the call:
+        $inputPerson = NaturalInputPerson::builder()
+            ->name(InputPersonName::westernBuilder()
+                ->fullname( "Peter und Daniela Meyer" )
+                ->build())
+            ->build();
+        $parseResult = $personNameParser->parse($inputPerson);
+
+        //the assertions:
+        $bestMatch = $parseResult->getBestMatch();
+        $this->assertEquals('MULTIPLE', (string)$bestMatch->getParsedPerson()->getPersonType());
+        $people = $bestMatch->getParsedPerson()->getPeople();
+        $this->assertEquals(2, sizeof($people));
+
+        $firstPerson = $people[0];
+        $this->assertEquals('Peter', $firstPerson->getAddressingGivenName());
+        $this->assertEquals('Meyer', $firstPerson->getAddressingSurname());
+        $this->assertEquals('MALE', (string)$firstPerson->getGender()->getGender());
+
+        $secondPerson = $people[1];
+        $this->assertEquals('Daniela', $secondPerson->getAddressingGivenName());
+        $this->assertEquals('Meyer', $secondPerson->getAddressingSurname());
+        $this->assertEquals('FEMALE', (string)$secondPerson->getGender()->getGender());
     }
 
 }