6985375056

Committed 24 Nov 2023 10:53PM UTC coverage: 28.713% (+1.2%) from 27.5%

Build # 6985375056

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #152 from Yoast/JRF/ghactions-switch-to-coveralls-reporter

GH Actions: switch to Coveralls action runner to upload reports

Run Details

87 of 303 relevant lines covered (28.71%)

2.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.56

/src/Whip_RequirementsChecker.php

<?php
/**
 * WHIP libary file.
 *
 * @package Yoast\WHIP
 */

/**
 * Main controller class to require a certain version of software.
 */
class Whip_RequirementsChecker {

        /**
         * Requirements the environment should comply with.
         *
         * @var array
         */
        private $requirements;

        /**
         * The configuration to check.
         *
         * @var Whip_Configuration
         */
        private $configuration;

        /**
         * Message Manager.
         *
         * @var Whip_MessagesManager
         */
        private $messageManager;

        /**
         * The text domain to use for translations.
         *
         * @var string
         */
        private $textdomain;

        /**
         * Whip_RequirementsChecker constructor.
         *
         * @param array  $configuration The configuration to check.
         * @param string $textdomain    The text domain to use for translations.
         *
         * @throws Whip_InvalidType When the $configuration parameter is not of the expected type.
         */
        public function __construct( $configuration = array(), $textdomain = 'default' ) {
                $this->requirements   = array();
                $this->configuration  = new Whip_Configuration( $configuration );
                $this->messageManager = new Whip_MessagesManager();
                $this->textdomain     = $textdomain;
        }

        /**
         * Adds a requirement to the list of requirements if it doesn't already exist.
         *
         * @param Whip_Requirement $requirement The requirement to add.
         *
         * @return void
         */
        public function addRequirement( Whip_Requirement $requirement ) {
                // Only allow unique entries to ensure we're not checking specific combinations multiple times.
                if ( $this->requirementExistsForComponent( $requirement->component() ) ) {
                        return;
                }

                $this->requirements[] = $requirement;
        }

        /**
         * Determines whether or not there are requirements available.
         *
         * @return bool Whether or not there are requirements.
         */
        public function hasRequirements() {
                return $this->totalRequirements() > 0;
        }

        /**
         * Gets the total amount of requirements.
         *
         * @return int The total amount of requirements.
         */
        public function totalRequirements() {
                return count( $this->requirements );
        }

        /**
         * Determines whether or not a requirement exists for a particular component.
         *
         * @param string $component The component to check for.
         *
         * @return bool Whether or not the component has a requirement defined.
         */
        public function requirementExistsForComponent( $component ) {
                foreach ( $this->requirements as $requirement ) {
                        if ( $requirement->component() === $component ) {
                                return true;
                        }
                }

                return false;
        }

        /**
         * Determines whether a requirement has been fulfilled.
         *
         * @param Whip_Requirement $requirement The requirement to check.
         *
         * @return bool Whether or not the requirement is fulfilled.
         */
        private function requirementIsFulfilled( Whip_Requirement $requirement ) {
                $availableVersion = $this->configuration->configuredVersion( $requirement );
                $requiredVersion  = $requirement->version();

                if ( in_array( $requirement->operator(), array( '=', '==', '===' ), true ) ) {
                        return version_compare( $availableVersion, $requiredVersion, '>=' );
                }

                return version_compare( $availableVersion, $requiredVersion, $requirement->operator() );
        }

        /**
         * Checks if all requirements are fulfilled and adds a message to the message manager if necessary.
         *
         * @return void
         */
        public function check() {
                foreach ( $this->requirements as $requirement ) {
                        // Match against config.
                        $requirementFulfilled = $this->requirementIsFulfilled( $requirement );

                        if ( $requirementFulfilled ) {
                                continue;
                        }

                        $this->addMissingRequirementMessage( $requirement );
                }
        }

        /**
         * Adds a message to the message manager for requirements that cannot be fulfilled.
         *
         * @param Whip_Requirement $requirement The requirement that cannot be fulfilled.
         *
         * @return void
         */
        private function addMissingRequirementMessage( Whip_Requirement $requirement ) {
                switch ( $requirement->component() ) {
                        case 'php':
                                $this->messageManager->addMessage( new Whip_UpgradePhpMessage( $this->textdomain ) );
                                break;
                        default:
                                $this->messageManager->addMessage( new Whip_InvalidVersionRequirementMessage( $requirement, $this->configuration->configuredVersion( $requirement ) ) );
                                break;
                }
        }

        /**
         * Determines whether or not there are messages available.
         *
         * @return bool Whether or not there are messages to display.
         */
        public function hasMessages() {
                return $this->messageManager->hasMessages();
        }

        /**
         * Gets the most recent message from the message manager.
         *
         * @return Whip_Message The latest message.
         */
        public function getMostRecentMessage() {
                return $this->messageManager->getLatestMessage();
        }
}

1	<?php
2	/**
3	* WHIP libary file.
4	*
5	* @package Yoast\WHIP
6	*/
7
8	/**
9	* Main controller class to require a certain version of software.
10	*/
11	class Whip_RequirementsChecker {
12
13	/**
14	* Requirements the environment should comply with.
15	*
16	* @var array
17	*/
18	private $requirements;
19
20	/**
21	* The configuration to check.
22	*
23	* @var Whip_Configuration
24	*/
25	private $configuration;
26
27	/**
28	* Message Manager.
29	*
30	* @var Whip_MessagesManager
31	*/
32	private $messageManager;
33
34	/**
35	* The text domain to use for translations.
36	*
37	* @var string
38	*/
39	private $textdomain;
40
41	/**
42	* Whip_RequirementsChecker constructor.
43	*
44	* @param array $configuration The configuration to check.
45	* @param string $textdomain The text domain to use for translations.
46	*
47	* @throws Whip_InvalidType When the $configuration parameter is not of the expected type.
48	*/
49	public function __construct( $configuration = array(), $textdomain = 'default' ) {	×
50	$this->requirements = array();	×
51	$this->configuration = new Whip_Configuration( $configuration );	×
52	$this->messageManager = new Whip_MessagesManager();	×
53	$this->textdomain = $textdomain;	×
54	}
55
56	/**
57	* Adds a requirement to the list of requirements if it doesn't already exist.
58	*
59	* @param Whip_Requirement $requirement The requirement to add.
60	*
61	* @return void
62	*/
63	public function addRequirement( Whip_Requirement $requirement ) {	24✔
64	// Only allow unique entries to ensure we're not checking specific combinations multiple times.
65	if ( $this->requirementExistsForComponent( $requirement->component() ) ) {	24✔
66	return;	3✔
67	}
68
69	$this->requirements[] = $requirement;	24✔
70	}	16✔
71
72	/**
73	* Determines whether or not there are requirements available.
74	*
75	* @return bool Whether or not there are requirements.
76	*/
77	public function hasRequirements() {	×
78	return $this->totalRequirements() > 0;	×
79	}
80
81	/**
82	* Gets the total amount of requirements.
83	*
84	* @return int The total amount of requirements.
85	*/
86	public function totalRequirements() {	6✔
87	return count( $this->requirements );	6✔
88	}
89
90	/**
91	* Determines whether or not a requirement exists for a particular component.
92	*
93	* @param string $component The component to check for.
94	*
95	* @return bool Whether or not the component has a requirement defined.
96	*/
97	public function requirementExistsForComponent( $component ) {	3✔
98	foreach ( $this->requirements as $requirement ) {	3✔
99	if ( $requirement->component() === $component ) {	3✔
100	return true;	3✔
101	}
102	}	1✔
103
104	return false;	3✔
105	}
106
107	/**
108	* Determines whether a requirement has been fulfilled.
109	*
110	* @param Whip_Requirement $requirement The requirement to check.
111	*
112	* @return bool Whether or not the requirement is fulfilled.
113	*/
114	private function requirementIsFulfilled( Whip_Requirement $requirement ) {	×
115	$availableVersion = $this->configuration->configuredVersion( $requirement );	×
116	$requiredVersion = $requirement->version();	×
117
118	if ( in_array( $requirement->operator(), array( '=', '==', '===' ), true ) ) {	×
119	return version_compare( $availableVersion, $requiredVersion, '>=' );	×
120	}
121
122	return version_compare( $availableVersion, $requiredVersion, $requirement->operator() );	×
123	}
124
125	/**
126	* Checks if all requirements are fulfilled and adds a message to the message manager if necessary.
127	*
128	* @return void
129	*/
130	public function check() {	15✔
131	foreach ( $this->requirements as $requirement ) {	15✔
132	// Match against config.
133	$requirementFulfilled = $this->requirementIsFulfilled( $requirement );	15✔
134
135	if ( $requirementFulfilled ) {	15✔
136	continue;	6✔
137	}
138
139	$this->addMissingRequirementMessage( $requirement );	9✔
140	}	5✔
141	}	10✔
142
143	/**
144	* Adds a message to the message manager for requirements that cannot be fulfilled.
145	*
146	* @param Whip_Requirement $requirement The requirement that cannot be fulfilled.
147	*
148	* @return void
149	*/
150	private function addMissingRequirementMessage( Whip_Requirement $requirement ) {	×
151	switch ( $requirement->component() ) {	×
152	case 'php':	×
153	$this->messageManager->addMessage( new Whip_UpgradePhpMessage( $this->textdomain ) );	×
154	break;	×
155	default:
156	$this->messageManager->addMessage( new Whip_InvalidVersionRequirementMessage( $requirement, $this->configuration->configuredVersion( $requirement ) ) );	×
157	break;	×
158	}
159	}
160
161	/**
162	* Determines whether or not there are messages available.
163	*
164	* @return bool Whether or not there are messages to display.
165	*/
166	public function hasMessages() {	12✔
167	return $this->messageManager->hasMessages();	12✔
168	}
169
170	/**
171	* Gets the most recent message from the message manager.
172	*
173	* @return Whip_Message The latest message.
174	*/
175	public function getMostRecentMessage() {	9✔
176	return $this->messageManager->getLatestMessage();	9✔
177	}
178	}

Yoast / whip / 6985375056

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous