An acronym that defines bad practices used by programmers good and bad that promotes technical debt.
An acronym that defines 5 principles that promote cleaner, more reusable code and generally lowers technical debt.
<?php
class TemperatureCalculator
{
public static function getTemp() {
global $sunnyDays, $snowyDays;
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
$avg = 0;
$cnt = 0;
foreach($t as $temp) {
switch($temp->condition){
case 'snowy':
$avg += $temp->getTemp();
$cnt++;
$snowyDays++;
break;
case 'sunny':
$avg += $temp->getTemp();
$cnt++;
$sunnyDays++;
break;
}
}
return $avg / $cnt;
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
public static function getTemp() {
return parent::getTemp() * (9 / 5) + 32 ;
}
}
//Declared globals are affected by tempCalculator cause i'm using the temp calculator a lot
//and i don't want to change the signature
$sunnyDays = 0;
$snowyDays = 0;
if($userOptions['scale'] == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp();
} else {
$avgTemp = TemperatureCalculator::getTemp();
}
echo 'The average temperature between december 2014 and march 2015 is '.$avgTemp.$userOptions['scale'].'<br/>';
echo 'There has been '.$sunnyDays.' days of sun and '.$snowyDays.' days of snow.';
Original code
<?php
class TemperatureCalculator
{
public static function getTemp() {
global $sunnyDays, $snowyDays;
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
$avg = 0;
$cnt = 0;
foreach($t as $temp) {
switch($temp->condition){
case 'snowy':
$avg += $temp->getTemp();
$cnt++;
$snowyDays++;
break;
case 'sunny':
$avg += $temp->getTemp();
$cnt++;
$sunnyDays++;
break;
}
}
return $avg / $cnt;
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
public static function getTemp() {
return parent::getTemp() * (9 / 5) + 32 ;
}
}
//Declared globals are affected by tempCalculator cause i'm using the temp calculator a lot
//and i don't want to change the signature
$sunnyDays = 0;
$snowyDays = 0;
if($userOptions['scale'] == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp();
} else {
$avgTemp = TemperatureCalculator::getTemp();
}
echo 'The average temperature between december 2014 and march 2015 is '.$avgTemp.$userOptions['scale'].'<br/>';
echo 'There has been '.$sunnyDays.' days of sun and '.$snowyDays.' days of snow.';
Previous code
<?php
class TemperatureCalculator
{
public static function getTemp() {
global $sunnyDays, $snowyDays;
//Get the temperature logs to work with
$thermometherLog = new thermometerLog('south-side');
$records = $thermometherLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
$avg = 0;
$cnt = 0;
foreach($records as $temp) {
switch($temp->condition){
case 'snowy':
$avg += $temp->getTemp();
$cnt++;
$snowyDays++;
break;
case 'sunny':
$avg += $temp->getTemp();
$cnt++;
$sunnyDays++;
break;
}
}
return $avg / $cnt;
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
public static function getTemp() {
return parent::getTemp() * (9 / 5) + 32 ;
}
}
//Declared globals are affected by tempCalculator cause i'm using the temp calculator a lot
//and i don't want to change the signature
$sunnyDays = 0;
$snowyDays = 0;
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp();
} else {
$avgTemp = TemperatureCalculator::getTemp();
}
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
New code
<?php
class TemperatureCalculator
{
public static function getTemp() {
global $sunnyDays, $snowyDays;
//Get the temperature logs to work with
$thermometherLog = new thermometerLog('south-side');
$records = $thermometherLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
$avg = 0;
$cnt = 0;
foreach($records as $temp) {
switch($temp->condition){
case 'snowy':
$avg += $temp->getTemp();
$cnt++;
$snowyDays++;
break;
case 'sunny':
$avg += $temp->getTemp();
$cnt++;
$sunnyDays++;
break;
}
}
return $avg / $cnt;
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
public static function getTemp() {
return parent::getTemp() * (9 / 5) + 32 ;
}
}
//Declared globals are affected by tempCalculator cause i'm using the temp calculator a lot
//and i don't want to change the signature
$sunnyDays = 0;
$snowyDays = 0;
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp();
} else {
$avgTemp = TemperatureCalculator::getTemp();
}
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
Previous code
<?php
class TemperatureCalculator
{
/**
* @param TemperatureLogRecords[] $temperatureLogRecords
*/
public static function getTemp(array $temperatureLogRecords) {
global $sunnyDays, $snowyDays;
$avg = 0;
$cnt = 0;
foreach($temperatureLogRecords as $temp) {
switch($temp->condition){
case 'snowy':
$avg += $temp->getTemp();
$cnt++;
$snowyDays++;
break;
case 'sunny':
$avg += $temp->getTemp();
$cnt++;
$sunnyDays++;
break;
}
}
return $avg / $cnt;
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
/**
* @param TemperatureLogRecords[] $temperatureLogRecords
*/
public static function getTemp(array $temperatureLogRecords) {
return parent::getTemp($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
//Get the temperature logs to work with
$thermometherLog = new thermometherLog('south-side');
$t = $thermometherLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Declared globals are affected by tempCalculator cause i'm using the temp calculator a lot
//and i don't want to change the signature
$sunnyDays = 0;
$snowyDays = 0;
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp($t);
} else {
$avgTemp = TemperatureCalculator::getTemp($t);
}
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
New code
<?php
class TemperatureCalculator
{
/**
* @param TemperatureLogRecords[] $temperatureLogRecords
*/
public static function getTemp(array $temperatureLogRecords) {
global $sunnyDays, $snowyDays;
$avg = 0;
$cnt = 0;
foreach($temperatureLogRecords as $temp) {
switch($temp->condition){
case 'snowy':
$avg += $temp->getTemp();
$cnt++;
$snowyDays++;
break;
case 'sunny':
$avg += $temp->getTemp();
$cnt++;
$sunnyDays++;
break;
}
}
return $avg / $cnt;
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
/**
* @param TemperatureLogRecords[] $temperatureLogRecords
*/
public static function getTemp(array $temperatureLogRecords) {
return parent::getTemp($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$thermometherLog = new thermometherLog('south-side');
$t = $thermometherLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Declared globals are affected by tempCalculator cause i'm using the temp
//calculator a lot and i don't want to change the signature
$sunnyDays = 0;
$snowyDays = 0;
global $sunnyDays, $snowyDays;
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp($t);
} else {
$avgTemp = TemperatureCalculator::getTemp($t);
}
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
New code
<?php
class TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public static function getTemp(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemp();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public static function getSunnyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'sunny';
}
)
);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public static function getSnowyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'snowy';
}
)
);
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getTemp(array $temperatureLogRecords) {
return parent::getTemp($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$thermometherLog = new thermometherLog('south-side');
$t = $thermometherLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp($t);
$sunnyDays = TemperatureCalculatorFarenheit::getSunnyDays($t);
$snowyDays = TemperatureCalculatorFarenheit::getSnowyDays($t);
} else {
$avgTemp = TemperatureCalculator::getTemp($t);
$sunnyDays = TemperatureCalculator::getSunnyDays($t);
$snowyDays = TemperatureCalculator::getSnowyDays($t);
}
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
New code
or difficult to test code?
<?php
class TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public static function getTemp(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemp();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public static function getSunnyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'sunny';
}
)
);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public static function getSnowyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'snowy';
}
)
);
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getTemp(array $temperatureLogRecords) {
return parent::getTemp($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$thermometherLog = new thermometherLog('south-side');
$t = $thermometherLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$avgTemp = TemperatureCalculatorFarenheit::getTemp($t);
$sunnyDays = TemperatureCalculatorFarenheit::getSunnyDays($t);
$snowyDays = TemperatureCalculatorFarenheit::getSnowyDays($t);
} else {
$avgTemp = TemperatureCalculator::getTemp($t);
$sunnyDays = TemperatureCalculator::getSunnyDays($t);
$snowyDays = TemperatureCalculator::getSnowyDays($t);
}
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
Previous code
<?php
class TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getTemp(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemp();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'sunny';
}
)
);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'snowy';
}
)
);
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getTemp(array $temperatureLogRecords) {
return parent::getTemp($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$temperatureCalculator = new TemperatureCalculatorFarenheit();
} else {
$temperatureCalculator = new TemperatureCalculator();
}
$avgTemp = $temperatureCalculator->getTemp($t);
$sunnyDays = $temperatureCalculator->getSunnyDays($t);
$snowyDays = $temperatureCalculator->getSnowyDays($t);
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
New code
<?php
class TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getTemp(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemp();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'sunny';
}
)
);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDays(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'snowy';
}
)
);
}
}
class TemperatureCalculatorFarenheit extends TemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getTemp(array $temperatureLogRecords) {
return parent::getTemp($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$temperatureCalculator = new TemperatureCalculatorFarenheit();
} else {
$temperatureCalculator = new TemperatureCalculator();
}
$avgTemp = $temperatureCalculator->getTemp($t);
$sunnyDays = $temperatureCalculator->getSunnyDays($t);
$snowyDays = $temperatureCalculator->getSnowyDays($t);
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
Previous code
<?php
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDayCount(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'sunny';
}
)
);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDayCount(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'snowy';
}
)
);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalculator->getAverageTemperature($t);
$sunnyDays = $temperatureCalculator->getSunnyDayCount($t);
$snowyDays = $temperatureCalculator->getSnowyDayCount($t);
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
New code
<?php
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDayCount(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'sunny';
}
)
);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDayCount(array $temperatureLogRecords) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item){
return $item->condition == 'snowy';
}
)
);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalculator->getAverageTemperature($t);
$sunnyDays = $temperatureCalculator->getSunnyDayCount($t);
$snowyDays = $temperatureCalculator->getSnowyDayCount($t);
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
Previous code
<?php
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'sunny');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'snowy');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
* @param string $condition
*/
private function countDaysBasedOnCondition(array $temperatureLogRecords, $condition) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item)use($condition){
return $item->condition == $condition;
}
)
);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalculator->getAverageTemperature($t);
$sunnyDays = $temperatureCalculator->getSunnyDayCount($t);
$snowyDays = $temperatureCalculator->getSnowyDayCount($t);
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
New code
<?php
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'sunny');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'snowy');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
* @param string $condition
*/
private function countDaysBasedOnCondition(array $temperatureLogRecords, $condition) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item)use($condition){
return $item->condition == $condition;
}
)
);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the items based on the scale
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalculator->getAverageTemperature($t);
$sunnyDays = $temperatureCalculator->getSunnyDayCount($t);
$snowyDays = $temperatureCalculator->getSnowyDayCount($t);
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
Previous code
<?php
class TemperatureConditionCounter
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'sunny');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'snowy');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
* @param string $condition
*/
private function countDaysBasedOnCondition(array $temperatureLogRecords, $condition) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item)use($condition){
return $item->condition == $condition;
}
)
);
}
}
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalulator->getAverageTemperature($t);
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$sunnyDays = $temperatureConditionCounter->getSunnyDayCount($t);
$snowyDays = $temperatureConditionCounter->getSnowyDayCount($t);
//Output
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
New code
<?php
class TemperatureConditionCounter
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSunnyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'sunny');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getSnowyDayCount(array $temperatureLogRecords) {
return $this->countDaysBasedOnCondition($temperatureLogRecords, 'snowy');
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
* @param string $condition
*/
private function countDaysBasedOnCondition(array $temperatureLogRecords, $condition) {
return count(
array_filter(
$temperatureLogRecords,
function(TemperatureLogRecord $item)use($condition){
return $item->condition == $condition;
}
)
);
}
}
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalulator->getAverageTemperature($t);
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$sunnyDays = $temperatureConditionCounter->getSunnyDayCount($t);
$snowyDays = $temperatureConditionCounter->getSnowyDayCount($t);
//Output
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$sunnyDays.' sunny days and '.$snowyDays.' snowy days.';
}
}
Previous code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureCondition[]
*/
protected $supportedConditions;
/**
* @return TemperatureCondition[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureCondition $condition
*/
public function addSupportedCondition(TemperatureCondition $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalulator->getAverageTemperature($t);
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('sunny'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('snowy'));
$conditions = $temperatureConditionCounter->countDaysByCondition($t);
//Output
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$conditions['sunny'].' sunny days and '.$conditions['snowy'].' snowy days.';
}
}
New code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureCondition[]
*/
protected $supportedConditions;
/**
* @return TemperatureCondition[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureCondition $condition
*/
public function addSupportedCondition(TemperatureCondition $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class AverageTemperatureCalculatorInFarenheit extends AverageTemperatureCalculatorInCelcius
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
return parent::getAverageTemperature($temperatureLogRecords) * (9 / 5) + 32 ;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$temperatureCalculator = new AverageTemperatureCalculatorInFarenheit();
} else {
$temperatureCalculator = new AverageTemperatureCalculatorInCelcius();
}
$avgTemp = $temperatureCalulator->getAverageTemperature($t);
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('sunny'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('snowy'));
$conditions = $temperatureConditionCounter->countDaysByCondition($t);
//Output
echo 'The temp between Dec. 2014 and Mar. 2015 is '.$avgTemp.$scale.'<br/>';
echo 'There has been '.$conditions['sunny'].' sunny days and '.$conditions['snowy'].' snowy days.';
}
}
Previous code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureCondition[]
*/
protected $supportedConditions;
/**
* @return TemperatureCondition[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureCondition $condition
*/
public function addSupportedCondition(TemperatureCondition $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class FarenheitTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature * (9 / 5) + 32;
}
}
class CelsiusTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$converter = new FarenheitTemperatureConverter();
} else {
$converter = new CelsiusTemperatureConverter();
}
$averageTemperatureCalculator = new AverageTemperatureCalculator();
$averageTemperature = $averageTemperatureCalculator->getAverageTemperature($t);
echo 'The average temperature is '.$converter->convert($averageTemperature).$scale.'<br />';
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('sunny'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('snowy'));
$conditions = $temperatureConditionCounter->countDaysByCondition($t);
echo 'There has been '.$conditions['sunny'].' sunny days and '.$conditions['snowy'].' snowy days.';
}
}
New code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureCondition[]
*/
protected $supportedConditions;
/**
* @return TemperatureCondition[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureCondition $condition
*/
public function addSupportedCondition(TemperatureCondition $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class FarenheitTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature * (9 / 5) + 32;
}
}
class CelsiusTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$converter = new FarenheitTemperatureConverter();
} else {
$converter = new CelsiusTemperatureConverter();
}
$averageTemperatureCalculator = new AverageTemperatureCalculator();
$averageTemperature = $averageTemperatureCalculator->getAverageTemperature($t);
echo 'The average temperature is '.$converter->convert($averageTemperature).$scale.'<br />';
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('sunny'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition('snowy'));
$conditions = $temperatureConditionCounter->countDaysByCondition($t);
echo 'There has been '.$conditions['sunny'].' sunny days and '.$conditions['snowy'].' snowy days.';
}
}
Previous code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureConditionInterface[]
*/
protected $supportedConditions;
/**
* @return TemperatureConditionInterface[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureConditionInterface $condition
*/
public function addSupportedCondition(TemperatureConditionInterface $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class FarenheitTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature * (9 / 5) + 32;
}
}
class CelsiusTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$converter = new FarenheitTemperatureConverter();
} else {
$converter = new CelsiusTemperatureConverter();
}
$averageTemperatureCalculator = new AverageTemperatureCalculator();
$averageTemperature = $averageTemperatureCalculator->getAverageTemperature($t);
echo 'The average temperature is '.$converter->convert($averageTemperature).$scale.'<br />';
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition2('sunny', 'sun'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition2('snowy', 'snow'));
$conditions = $temperatureConditionCounter->countDaysByCondition($t);
echo 'There has been '.$conditions['sunny'].' sunny days and '.$conditions['snowy'].' snowy days.';
}
}
New code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureConditionInterface[]
*/
protected $supportedConditions;
/**
* @return TemperatureConditionInterface[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureConditionInterface $condition
*/
public function addSupportedCondition(TemperatureConditionInterface $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class FarenheitTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature * (9 / 5) + 32;
}
}
class CelsiusTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature;
}
}
class TemperatureController
{
public function index() {
//Get the temperature logs to work with
$t = thermometerLog::get('south-side')->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = Session::getUser()->getOption('scale');
if($scale == 'f') {
$converter = new FarenheitTemperatureConverter();
} else {
$converter = new CelsiusTemperatureConverter();
}
$averageTemperatureCalculator = new AverageTemperatureCalculator();
$averageTemperature = $averageTemperatureCalculator->getAverageTemperature($t);
echo 'The average temperature is '.$converter->convert($averageTemperature).$scale.'<br />';
//Get the condition counts
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition2('sunny', 'sun'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition2('snowy', 'snow'));
$conditions = $temperatureConditionCounter->countDaysByCondition($t);
echo 'There has been '.$conditions['sunny'].' sunny days and '.$conditions['snowy'].' snowy days.';
}
}
Previous code
<?php
class TemperatureConditionCounter
{
/**
* @var TemperatureConditionInterface[]
*/
protected $supportedConditions;
/**
* @return TemperatureConditionInterface[]
*/
public function getSupportedConditions() {
return $this->supportedConditions;
}
/**
* @param TemperatureConditionInterface $condition
*/
public function addSupportedCondition(TemperatureConditionInterface $condition) {
$this->supportedConditions[$condition->getCondition()] = $condition;
}
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function countDaysByCondition(array $temperatureLogRecords) {
$results = [];
foreach($this->getSupportedConditions() as $supportedCondition) {
$results[$supportedCondition->getCondition()] = 0;
}
foreach ($temperatureLogRecords as $temperatureLogRecord) {
if (isset($this->supportedConditions[$temperatureLogRecord->getCondition()]) {
$results[$temperatureLogRecord->getCondition()]++;
}
}
return $results;
}
}
class AverageTemperatureCalculator
{
/**
* @param TemperatureLogRecord[] $temperatureLogRecords
*/
public function getAverageTemperature(array $temperatureLogRecords) {
//Calculate the sum
$sum = array_sum(
array_map(
function(TemperatureLogRecord $item){
return $item->getTemperatureReading();
},
$temperatureLogRecords
)
);
$cnt = count($temperatureLogRecords);
return ($sum / $cnt);
}
}
class FarenheitTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature * (9 / 5) + 32;
}
}
class CelsiusTemperatureConverter implements CelsiusBasedTemperatureConverterInterface
{
/**
* @param double $temperature
*/
public function convert($temperature) {
return $temperature;
}
}
class TemperatureController
{
public function __construct(
ThermometerLog $thermometerLog,
SessionManagerInterface $sessionManager,
TemperatureConversionManagerInterface $temperatureConversionManager,
AverageTemperatureCalculatorInterface $averageTemperatureCalculator,
TemperatureConditionCounterInterface $temperatureConditionCounter
) {
$this->thermometerLog = $thermometerLog;
$this->sessionManager = $sessionManager;
$this->temperatureConversionManager = $temperatureConversionManager;
$this->averageTemperatureCalculator = $averageTemperatureCalculator;
$this->temperatureConditionCounter = $temperatureConditionCounter;
}
public function index() {
//Get the temperature logs to work with
$t = $this->thermometerLog->find([
'after' => '2014-12-21',
'before' => '2015-03-21'
]);
//Get the temperature average
$scale = $this->sessionManager->getUser()->getOption('scale');
$converter = $this->temperatureConversionManager->getConverter($scale);
$averageTemperature = $this->averageTemperatureCalculator->getAverageTemperature($t);
echo 'The average temperature is '.$converter->convert($averageTemperature).$scale.'<br />';
//Get all the different conditions instead of just sun and snow
foreach($this->temperatureConditionCounter->getSupportedConditions() as $condition) {
$count = $this->temperatureConditionCounter->countDaysBasedOnCondition($t, $condition);
echo 'There has been '.$count.' days of '.$condition->label.'<br />';
}
}
}
New code
(Laravel)
<?php
$temperatureConversionManager = new TemperatureConversionManager();
$temperatureConversionManager->addSupportedConverter('c', new FarenheitTemperatureConverter());
$temperatureConversionManager->addSupportedConverter('f', new CelsiusTemperatureConverter());
$temperatureConditionCounter = new TemperatureConditionCounter();
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition2('sunny', 'sun'));
$temperatureConditionCounter->addSupportedCondition(new TemperatureCondition2('snowy', 'snow'));
$controller = new Controller(
ThermometerLog::get('south-side'),
new SessionManager(),
$temperatureConversionManager,
new AverageTemperatureCalculator(),
$temperatureConditionCounter
);
$controller->index();
<?php
//Bindings file
$ioc = new Illuminate\Container\Container();
$ioc->bind('ThermometerLog', function() { return ThermometerLog::get('south-side'); });
$ioc->bind('SessionManagerInterface', 'SessionManager');
$ioc->bind('TemperatureConversionManagerInterface', 'TemperatureConversionManager');
$ioc->bind('AverageTemperatureCalculatorInterface', 'AverageTemperatureCalculator');
$ioc->bind('TemperatureConditionCounterInterface', 'TemperatureConditionCounter');
$ioc->resolving('TemperatureConversionManagerInterface', function($object, $ioc) {
$object->addSupportedConverter('c', new FarenheitTemperatureConverter());
$object->addSupportedConverter('f', new CelsiusTemperatureConverter());
});
$ioc->resolving('TemperatureConditionCounterInterface', function($object, $ioc) {
$object->addSupportedCondition(new TemperatureCondition2('sunny', 'sun'));
$object->addSupportedCondition(new TemperatureCondition2('snowy', 'snow'));
});
//Front controller file
$controller = $ioc->make('TemperatureController');
$controller->index();
<?php
//Bindings file
$ioc = new Illuminate\Container\Container();
$ioc->bind('ThermometerLog', function() { return new ThermometerLog('south-side'); });
$ioc->bind('SessionManagerInterface', 'SessionManager');
$ioc->bind('TemperatureConversionManagerInterface', 'TemperatureConversionManager');
$ioc->bind('AverageTemperatureCalculatorInterface', 'AverageTemperatureCalculator');
$ioc->bind('TemperatureConditionCounterInterface', 'TemperatureConditionCounter');
$ioc->tag('FarenheitTemperatureConverter', ['TemperatureConverters']);
$ioc->tag('CelsiusTemperatureConverter', ['TemperatureConverters']);
$ioc->resolving('TemperatureConversionManagerInterface', function($object, $ioc) {
foreach($ioc->tagged('TemperatureConverters') as $converter){
$object->addSupportedConverter($converter->getScale(), $converter);
}
});
$ioc->resolving('TemperatureConditionCounterInterface', function($object, $ioc) {
$object->addSupportedCondition(new TemperatureCondition2('sunny', 'sun'));
$object->addSupportedCondition(new TemperatureCondition2('snowy', 'snow'));
});
//Front controller file
$controller = $ioc->make('TemperatureController');
$controller->index();