Assemble Your Code in Stages: Leveling Up With Pipelines

Assemble Your Code in Stages:
Leveling Up With Pipelines

Steven Wade - @stevenwadejrhttps://joind.in/talk/4c853
About me
Steven Wade

• Husband, father

• Founder/Organizer of UpstatePHP

Twitter: @stevenwadejr

Email: stevenwadejr@gmail.com

Problem

Problem
class OrderProcessController
{
public function processOrder(Request $request)
{
$order = new Order;
$order->billing = $request->get('billing');
$order->shipping = $request->get('shipping');
$order->products = $request->get('products');
$order->save();
return response(null);
}
}

Problem
{
{
$order = new Order;
// Calculate sub-total
$productsTotal = 0;
foreach ($request->get('products', []) as $product) {
$productsTotal += ($product['price'] * $product['quantity']);
}
$order->order_total += round($productsTotal, 2);
$order->save();
}
}

Problem
{
{
$order = new Order;
$productsTotal = 0;
}
// Process payment
$receipt = $this->paymentGateway->process($order);
$order->confirmation = $receipt->transaction_id;
event(new OrderProcessed($order));
$order->save();
}
}

Problem
{
{
$order = new Order;
$productsTotal = 0;
}
// Add tax
$taxRate = TaxFactory::getRate($order->billing['state']);
$tax = $order->order_total * $taxRate;
$tax = round($tax, 2);
$order->order_total += $tax;
$order->tax = $tax;
// Process payment
$order->save();
}
}

Problem
{
{
$order = new Order;
$productsTotal = 0;
}
// Add tax
$order->tax = $tax;
// Calculate shipping
// Free shipping on orders $100+
if ($order->order_total < 100) {
$calculator = new ShippingCalculator;
$shipping = $calculator->calculate($order->shipping);
$order->order_total += $shipping;
}
// Process payment
$order->save();
}
}

Problem
{
{
$order = new Order;
$productsTotal = 0;
}
// Add coupons
$couponCode = $request->get('coupon');
if ($couponCode) {
$couponRepo = app(CouponRepository::class);
$coupon = $couponRepo->findByCode($couponCode);
$discount = $coupon->isPercentage()
? round($coupon->amount / $order->order_total * 100, 2)
: $coupon->amount;
$order->order_total -= $discount;
}
// Add tax
$order->tax = $tax;
}
// Process payment
$order->save();
}
}

Pipelines!*(possibly)

Goals
• Understand what a pipeline is, and what stages are

• Learn to recognize a pipeline in our code

• Refactor code to stages

• See how stages make testing easier

• Understand when a pipeline is not the appropriate option

What is a pipeline?

|

cat logs.txt | grep "ERROR" | wc -l

So, what is a pipeline?

Pipeline
A series of processes chained together to where
the output of each is the input of the next

Stages
cat logs.txt | grep "ERROR" | wc -l

Real World Example

Bedtime
<?php
$bedtime = (new Pipeline)
->pipe(new Bath)
->pipe(new Diaper)
->pipe(new Pajamas)
->pipe(new BrushTeeth)
->pipe(new Book('Catalina Magdalena...'))
->pipe(new Song('Radio Gaga'));
$bedtime->process($penny);

Gulp
gulp.task('css', function(){
return gulp.src('client/templates/*.less')
.pipe(less())
.pipe(minifyCSS())
.pipe(gulp.dest('build/css'))
});

PHP Land

Nested Function Calls
function timesTwo($payload) {
return $payload * 2;
}
function addOne($payload) {
return $payload + 1;
}
// outputs 21
echo addOne(
timesTwo(10)
);

Nested Mess
$slug = strtolower(
preg_replace(
'~-+~',
'-',
trim(
preg_replace(
'~[^-w]+~',
'',
preg_replace(
'~[^pLd]+~u',
'-',
'My Awesome Blog Post!'
)
),
'-'
)
)
);
echo $slug;

Looping Through Stages
$stages = ['timesTwo', 'addOne'];
$payload = 10;
foreach ($stages as $stage) {
$payload = call_user_func($stage, $payload);
}
// outputs 21
echo $payload;

–Martin Fowler
“Any fool can write code that a computer can
understand. Good programmers write code that
humans can understand.”

LeaguePipeline

LeaguePipeline
Frank de Jonge 
@frankdejonge
Woody Gilk 
@shadowhand

LeaguePipeline - Functional
$pipeline = (new Pipeline)
->pipe('timesTwo')
->pipe('addOne');
// Returns 21
$pipeline->process(10);

LeaguePipeline - Class Based
$pipeline = (new Pipeline)
->pipe(new TimeTwoStage)
->pipe(new AddOneStage);
// Returns 21
$pipeline->process(10);

Putting it into practice

eCommerce
• Create the order

• Calculate the total

• Process the payment

• Subtract coupons from total

• Add appropriate taxes

• Calculate and add shipping costs

eCommerce
• Create the order

• Calculate the sub-total

• Subtract coupons from total

• Add appropriate taxes

• Calculate and add shipping costs

• Process the payment

eCommerce
{
{
$order = new Order;
$productsTotal = 0;
}
// Add coupons
if ($couponCode) {
: $coupon->amount;
}
}
}

eCommerce
{
{
$order = new Order;
$productsTotal = 0;
}
// Add coupons
if ($couponCode) {
: $coupon->amount;
}
// Add tax
$order->tax = $tax;
}
// Process payment
$order->save();
}
}

eCommerce - testing
{
{
$order = new Order;
$productsTotal = 0;
}
// Add tax
$order->tax = $tax;
}
}

eCommerce
{
{
$order = new Order;
$productsTotal = 0;
}
// Add coupons
if ($couponCode) {
: $coupon->amount;
}
}
}
Create order
Sub-total
Subtract coupons

eCommerce
{
$order = $this->createOrder($request);
$this->calculateSubTotal($order);
$this->applyCoupon($request, $order);
$this->applyTaxes($order);
$this->calculateShipping($order);
$this->processPayment($order);
$order->save();
}

eCommerce - Testing
protected function applyCoupon(Request $request, Order $order):
void
{
if ($couponCode) {
$couponRepo = new CouponRepository;
: $coupon->amount;
}
}

eCommerce - Testing
protected function applyCoupon(Request $request, Order $order):
void
{
if ($couponCode) {
: $coupon->amount;
}
}

eCommerce - Testing
public function __construct(CouponRepository $couponRepository)
{
$this->couponRepository = $couponRepository;
}

eCommerce - Testing
public function __construct(
CouponRepository $couponRepository,
ShippingCalculator $shippingCalculator,
PaymentGateway $paymentGateway
) {
$this->couponRepository = $couponRepository;
$this->shippingCalculator = $shippingCalculator;
$this->paymentGateway = $paymentGateway;
}

Stages!

eCommerce - Refactored
{
protected $stages = [
CalculateSubTotal::class,
ApplyCoupon::class,
ApplyTaxes::class,
CalculateShipping::class,
ProcessPayment::class,
];
{
$order = OrderFactory::fromRequest($request);
$pipeline = new LeaguePipelinePipeline;
foreach ($this->stages as $stage) {
$stage = app($stage, ['request' => $request]);
$pipeline->pipe($stage);
}
$pipeline->process($order);
$order->save();
}
}

Testing Stages
class OrderProcessTest
{
public function test_sales_tax()
{
$subTotal = 100.00;
$taxRate = 0.06;
$expected = 106.00;
$order = new Order;
$order->order_total = $subTotal;
$order->billing['state'] = 'SC';
$stage = new ApplyTaxes;
$stage($order);
$this->assertEquals($expected, $order->order_total);
}
}

Recap
• Pipeline: a series of processes (stages) chained together to
where the output of each is the input of the next.

• Stages create readability, reusability, and testability

Don't

Choose wisely

Encore!

Fun Stuff - Variable Pipeline
class RelatedData
{
protected $stages = [
LatestActivityPipeline::class,
ListMembershipsStage::class,
WorkflowMembershipsStage::class,
DealsStage::class,
];
public function process()
{
$pipeline = new Pipeline;
foreach ($this->stages as $stage) {
if ($this->stageIsEnabled()) {
$pipeline->pipe(new $stage);
}
}
return $pipeline->process([]);
}
}

Fun Stuff - Async Stages
class DealsStage
{
public function __invoke(array $payload)
{
if ($cache = $this->cache->get('deals')) {
$promise = new FulfilledPromise($cache);
} else {
$promise = $this->api->getDeals();
$promise = $promise->then(function ($deals) {
$this->cache->set('deals', $deals);
return $deals;
});
}
$payload['deals'] = $promise;
return $payload;
}
}

Fun Stuff - Async Stages
class RelatedData
{
public function process()
{
$promises = $this->pipeline->process([]);
return GuzzleHttpPromiseunwrap($promises);
}
}

LeaguePipeline - Added Beneﬁts
Processors
• FingersCrossedProcessor
• InterruptibleProcessor
• ProcessorInterface

LeaguePipeline - InterruptibleProcessor
$processor = new InterruptibleProcessor(function($payload) {
return $payload < 10;
});
$pipeline = new Pipeline(
$processor,
function ($payload) { return $payload + 2; }, // 7
function ($payload) { return $payload * 10; }, // 70
function ($payload) { return $payload * 10; } // 700
);
// outputs 70
echo $pipeline->process(5);

Laravel's Pipeline
$stages = [
StageOne::class,
StageTwo::class
];
$result = app(Pipeline::class)
->send($payload)
->through($stages)
->then(function($payload) {
return $payload;
});

Thank you!
Questions / Feedback?
Email: stevenwadejr@gmail.com
Twitter: @stevenwadejr

Suggested Questions
• Is it better to have dynamic stages (e.g. - conditions are run in advance
to determine the steps) or pass all the steps and let the stage contain
it's own condition?

• When should one stage be broken into 2?

Assemble Your Code in Stages: Leveling Up With Pipelines

More Related Content

What's hot

Similar to Assemble Your Code in Stages: Leveling Up With Pipelines

Recently uploaded

Assemble Your Code in Stages: Leveling Up With Pipelines