Ups\Entity\AddressValidationResponse

Complexity

Total Complexity

14

Size/Duplication

Total Lines	97
Duplicated Lines	14.43 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

94.29%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	noCandidates()	7	7	2
A	isValid()	0	7	2
A	isAmbiguous()	7	7	2
A	getAddressClassification()	0	7	2
A	getCandidateAddressList()	0	11	3
A	getValidatedAddress()	0	8	2

<?php namespace Ups\Entity;


use Ups\AddressValidation;
use Ups\Entity\AddressValidation\AVAddress;
use Ups\Entity\AddressValidation\AddressClassification;

class AddressValidationResponse
{
    protected $response;
    protected $requestAction;

    /**
     * AddressValidationResponse constructor.
     * @param \SimpleXMLElement $xmlDocument
     * @param $requestAction
     */
    public function __construct(\SimpleXMLElement $xmlDocument,$requestAction)

Expected 1 space between comma and argument "$requestAction"; 0 found

    {
        $this->response = $xmlDocument;
        $this->requestAction = $requestAction;
    }

    /**
     * Tells whether or not the NoCandidatesIndicator is present on the XML document.
     * This indicator is returned if the address is so badly formed that UPS is
     * unable to even offer any suggested alternatives
     *
     * @return bool
     */
    public function noCandidates()

This method seems to be duplicated in your project.

    {
        if(AddressValidation::REQUEST_OPTION_ADDRESS_CLASSIFICATION == $this->requestAction) {

Expected 1 space after IF keyword; 0 found

            throw new \BadMethodCallException(__METHOD__.' should not be called on Address Classification only requests.');
        }
        return isset($this->response->NoCandidatesIndicator);
    }

    /**
     * Tells whether or not the ValidAddressIndicator is present on the XML document.
     * This indicator is present if provided address is valid and represents a
     * single, unique address in the UPS Address Validation system.
     * @return bool
     */
    public function isValid()
    {
        if(AddressValidation::REQUEST_OPTION_ADDRESS_CLASSIFICATION == $this->requestAction) {

Expected 1 space after IF keyword; 0 found

            return $this->response->AddressClassification->Code > 0;
        }
        return isset($this->response->ValidAddressIndicator);
    }

    /**
     * Tells whether or not the AmbiguousAddressIndicator is present on the XML document.
     * This indicator is present when the address provided is not specific enough to
     * be unique to one physical location, but provides enough
     *
     * @throws \BadMethodCallException
     * @return bool
     */
    public function isAmbiguous()

This method seems to be duplicated in your project.

    {
        if(AddressValidation::REQUEST_OPTION_ADDRESS_CLASSIFICATION == $this->requestAction) {

Expected 1 space after IF keyword; 0 found

            throw new \BadMethodCallException(__METHOD__.' should not be called on Address Classification only requests.');
        }
        return isset($this->response->AmbiguousAddressIndicator);
    }

    /**
     * @throws \BadMethodCallException
     * @return AddressClassification
     */
    public function getAddressClassification()
    {
        if($this->requestAction < AddressValidation::REQUEST_OPTION_ADDRESS_CLASSIFICATION) {

Expected 1 space after IF keyword; 0 found

            throw new \BadMethodCallException('Address Classification was not requested.');
        }
        return new AddressClassification($this->response->AddressClassification);
    }

    /**
     * @return \Ups\Entity\AddressValidation\Address[]
     */
    public function getCandidateAddressList()
    {
        if(!isset($this->response->AddressKeyFormat)) {

Expected 1 space after IF keyword; 0 found

            return [];
        }
        $candidates = [];
        foreach($this->response->AddressKeyFormat as $address) {

Expected 1 space after FOREACH keyword; 0 found

            $candidates[] = new AVAddress($address);
        }
        return $candidates;
    }

    public function getValidatedAddress()
    {
        if($this->requestAction == AddressValidation::REQUEST_OPTION_ADDRESS_CLASSIFICATION) {

Expected 1 space after IF keyword; 0 found

            throw new \BadMethodCallException('Only Address Classification was requested. There is no address.');
        }

        return new AVAddress($this->response->AddressKeyFormat);
    }
}