Automate PHP with Phake - Introduction

Core points

• Phake is a PHP automation tool that helps developers automate repetitive tasks such as updating database structures, database filling, writing CRUD code, running tests, and uploading files to the server.
• Using Phake requires creating and configuring tasks in a Phakefile, similar to Gruntfile. Tasks can be executed sequentially, have dependencies, and can be grouped.
• Phake allows describing tasks and facilitates understanding of the functions of specific tasks, especially when there are a large number of tasks in the Phakefile.
• By passing parameters, Phake tasks can be more flexible and customize specific tasks. This is done by declaring parameters in the function, and then using the parameters to access the individual parameters passed to the task.

As developers, we often need to perform repetitive tasks such as updating database structures, filling databases, writing CRUD code, running tests, and uploading files to the server. Wouldn't it be better if these daily tasks can be automated and focus on more important issues (such as improving the security or availability of your application)?

Phake is an automation tool written for PHP that can help you with these tasks. If you are familiar with Ruby, it is basically a clone of Rake. In this two-part series, I'll walk you through the integration of Phake into your workflow. I'll walk you through the installation process, introduce some basics of Phake, and finally some practical examples.

Installation

Install Phake globally through Composer:

composer global require 'jaz303/phake=*'

This allows Phake to be accessed from any folder without changing the project's composer.json file.

If you cannot access the "composer" command, please install Composer globally.

Basics

To perform a Phake task, you need to create a Phakefile. The Phakefile contains the configuration of the task to be executed. If you have used Grunt before, Phakefile is similar to Gruntfile.

An important note about Phakefile is that it is just a PHP file, so you can write it like you would with a PHP project.

Create a task

You can create tasks by calling the task() method. This method takes the task name as the first parameter and the function to be executed as the last parameter.

<?php task('task_a', function(){
  echo "Hi I'm task A!\n"; 
});

You can then execute it with the following command:

phake task_a

This will return the following output:

<code>Hi I'm task A!</code>

Dependencies

If a task depends on another task, you can provide the name of the task after the main task:

<?php task('task_a', function(){
  echo "Hi I'm task A!\n"; 
});

task('task_b', 'task_a', function(){
  echo "Hi I'm task B! I need task A to execute first before I can do my thing!\n";
});

To execute tasks in order, you just need to call the task with dependencies first. In this case, task_b depends on task_a, so we call it first:

phake task_b

Execution of it will return the following output:

<code>Hi I'm task A!
Hi I'm task B! I need task A to execute first before I can do my thing!</code>

You can continue to add dependencies:

composer global require 'jaz303/phake=*'

Execute them by calling the final tasks that require the last call. In this example, the last thing we want to execute is task_c, so we call it first:

<?php task('task_a', function(){
  echo "Hi I'm task A!\n"; 
});

It will return the following output:

phake task_a

Note that using this method that declares dependencies, calling task_b will cause task_a to be called first. If you don't want this to happen and still want to perform a specific task alone without executing its dependencies first, you can declare it using the following method:

<code>Hi I'm task A!</code>

In the example above, we set task_a and task_b as dependencies of task_c. Please note that the order here is important. Therefore, the task immediately following the main task (task_a) will be executed first, the task immediately following (task_b) will be the second, and the main task (task_c) will be executed finally.

In Phake, there is another way to define dependencies: after defining the main task, use the before or after block. In this case, our main task is to eat, so we define under its declaration the task to be performed before and after it:

<?php task('task_a', function(){
  echo "Hi I'm task A!\n"; 
});

task('task_b', 'task_a', function(){
  echo "Hi I'm task B! I need task A to execute first before I can do my thing!\n";
});

When you execute eat, you will get the following output:

phake task_b

Group Tasks

Using Phake, you can also combine related tasks:

<code>Hi I'm task A!
Hi I'm task B! I need task A to execute first before I can do my thing!</code>

The grouping task can be called using the group name you specified, followed by a colon, and then the name of the task you want to perform:

<?php task('task_a', function(){
  echo "I get to execute first!\n"; 
});


task('task_b', 'task_a', function(){
  echo "Second here!\n";
});

task('task_c', 'task_b', function(){
  echo "I'm the last one!\n";
});

If you want to perform all tasks in the group, you can make the final task depend on the first and second tasks. In the following example, the final task we want to perform is the mop_the_floor task, so we make it depend on the poison_furniture and wash_the_clothes tasks:

phake task_c

Then, we just call the mop_the_floor task from the terminal:

<code>I get to execute first!
Second here!
I'm the last one!</code>

This will call the tasks in the following order:

task('task_a', function(){
  echo "I get to execute first!\n"; 
});

task('task_b', function(){
  echo "Second here!\n";
});

task('task_c', 'task_a', 'task_b', function(){
  echo "I'm the last one!\n";
});

Description task

After using Phake for a while, you may accumulate a lot of tasks in your Phakefile, so it is better to have some documentation. Fortunately, Phake comes with a utility that allows us to describe the functionality of a specific Phake task. You can call the desc method before the task declaration to be described:

task('eat', function(){
  echo "Yum!";
});

before('eat', function(){
  echo "Wash your hands before you eat\n";
});

after('eat', function(){
  echo "Brushy brush! brush!\n";
});

You can then list the tasks available in the Phakefile using the following command:

<code>Wash your hands before you eat
Yum!
Brushy brush! brush!</code>

It will return an output similar to the following:

group('clean_the_house', function(){
  task('polish_furniture', function(){..});
  task('wash_the_clothes', function(){..});
  task('mop_the_floor', function(){..}); 
});

Pass parameters to the task

To make the task more flexible, we can also pass in parameters. This can be done by declaring parameters in the function. This can then be used to access the various parameters passed to the task:

phake clean_the_house:polish_furniture

The

parameter can be passed by including name-value pairs after the task name. If you want to pass multiple parameters in, you can separate them with a single space between the value of the first parameter and the name of the second parameter:

group('clean_the_house', function(){
  task('polish_furniture', function(){..});
  task('wash_the_clothes', function(){..});
  task('mop_the_floor', 'polish_furniture', 'wash_the_clothes', function(){..}); 
});

If you need to pass in parameters with spaces, you can simply enclose them in single or double quotes:

phake clean_the_house:mop_the_floor

Conclusion

Now that we understand what Phake is for and how to use it to perform tasks, we are ready for some of the practical applications in the second part. stay tuned!

Frequently Asked Questions about Automating PHP with Phak

(The FAQ part is omitted here because it is too long and does not match the pseudo-original goal. The FAQ part can be adjusted and simplified as needed, such as merging some issues, or only retaining core issues.)

The above is the detailed content of Automate PHP with Phake - Introduction. For more information, please follow other related articles on the PHP Chinese website!