Composer

We have been talking about Object Orientation in PHP: How to define classes, invoke methods, etc.
We also talked about PHP's namespace mechanism which is similar to Java packages, and how the use namespace; declaration can be used together with a registered autoload callback function (registered via spl_autoload_register) to autoload classes.
Today, we begin by looking at a package manager for PHP that makes use of this autoloading mechanism.
Composer is a package management system for PHP. It was initially developed in 2011.
It lets people combine various PHP projects, making sure that the dependencies between the current project and different versions of the projects it depends are maintained.
A large list of projects that can be used with Composer can be found on the site: https://packagist.org/.
The Yioop search engine used for this class' discussion board is one such project.

Composer

The Composer site has instruction for downloading and installing composer.
Once it is downloaded, you can run it from the command line with a line like:
```
composer some_directive_for_composer
  
```
A composer project has at a minimum a composer.json file, and a sub-folder labeled vendor.
The composer.json file is used to specify what version of which projects your project depends on.
The vendor folder is where Composer downloads and stores the correct versions of these projects.

An example composer.json file suitable for working with Yioop is:

{
    "name": "your_vendor_name/your_project",
    "description": "put what your project is about here",
    "authors": [
        {
            "name": "Your Full Name",
            "email": "Where@to_contact.you"
        }
    ],
    "require": {
        "seekquarry/yioop": "dev-master"
    }
}

If you follow a folder structure within your project's src subfolder which matches the namespace after the vendor\project part, (for example, if the namespace\class was my_company\my_project\models\Model, and the class was in the file src/models/Model) then you can use the following composer.json file to get your classes to auto load:

{
    "name": "your_vendor_name/your_project",
    "description": "put what your project is about here",
    "authors": [
        {
            "name": "Your Full Name",
            "email": "Where@to_contact.you"
        }
    ],
    "require": {
// whatever the requires your project needs
    },
    "autoload": {
        "psr-4": {
            "my_company\\my_project\\": ["src/"]
        }
    }
}

psr-4 just refers to the above namespace to file path convention.

Example Composer Project Using Yioop

Once you've created a composer.json file and a blank vendor directory, you can start coding your project.
Typically, if you are using a version control system you add the vendor folder to your ignore list for the system. For example, with git, you might add the vendor folder to the .gitignore file.
In a standard project organization, you might then have an index.php file in the root folder of your project, have a src folder with the src code of your project and have a tests folder with any unit tests.

To keep things simple for our first try, we just put the following in our index.php file:

namespace cpollett\test_composer;

use seekquarry\yioop\configs as SYC;
use seekquarry\yioop\library as SYL;
use seekquarry\yioop\library\PhraseParser;

require_once "vendor/autoload.php";
print_r(PhraseParser::stemTerms("jumping", 'en-US'));
echo SYL\crawlHash(SYC\NAME_SERVER . "1234");

Then to get Composer to install Yioop under the vendor folder and create an autoloader for the projects that were needed, we might type from the project directory:
```
composer install
```
If you want to update composer projects later you type:
```
composer update
```
After which, we can run our program with the command:
```
php index.php
```
to execute out project. It should output:
```
Array
(
    [0] => jump
)
joQWpC4Sdy4
```

Comments on the Example

The example above illustrates using Yioop's PhraseParser class to do stemming.
This class can be found in the file YIOOP_FOLDER/src/library/PhraseParser.php.
This file has other useful methods for doing char-gramming, segmenting, and primitive detection of bad words.
Other file in the library folder, Utility.php contains lots of useful functions such as the crawlHash function illustrated above. For example, this file is where the functions for compressing/decompressing postings in Yioop are located.

Quiz

Which of the following statements is true?

A popular naming convention for project namespaces is: vendor_name\project_name .
The syntax class A : B, C {} is how in PHP we could say class A is a subclass of class B and class C.
Regardless, of where you store classes in your file system as long as the class name is the same as the file name, php can find and load the class definition without a require statement.

Traits

Traits are a PHP language feature added in PHP 5.4, probably deriving from Python/Common Lisp mix-ins.

They allow one to define a collection of method implementations and then reuse them in several classes:

trait MyMethods 
{
    function getFoo() { /* code for getFoo */ }
    function getGoo() { /* code for getFoo */ }
}

class SomeClassA extends NeedsMethods 
{
    use MyMethods; //as if I had written the code in MyMethods here
    /* rest of SomeClassA code */
}

class SomeClassB extends NeedsMethods 
{
    use MyMethods;
    /* rest of SomeClassB code */
}

$a = new SomeClassA();
$a->getFoo();

You can import more that one trait by comma separating them:
```
class A  
{
   use MyMethodsA, MyMethodsB;
   // ...
}
```
Suppose both MyMethodsA and MyMethodsB define a function named foo and one named goo. This will result in a fatal error unless one explicitly resolves the conflict using the insteadof operation to say which to use, or uses the as operator to rename one:
```
use MyMethodsA, MyMethodsB {
    MyMethodsA::foo insteadof MyMethodsB;
    MyMethodsB::goo insteadof MyMethodsA;
    MyMethodsA::goo as gooey;
    MyMethodsB::foo as protected fooey; //notice can change visibility if want
}
```

Exceptions

PHP supports try catch blocks like Java.

try {} catch(MyException $e){} catch(Exception $ee){}

You can use the keyword throw to throw an exception

if($denom == 0){
    throw new Exception("divide by zero");
}

You can subclass Exception to create custom exceptions.

Generators

Generators are a PHP 5.5 feature that allow one to generate a sequence of values via function. They are similar to Python generators.
They are suitable for use in statements like foreach where the array argument might go.
Generator functions execute until a yield statement is reached.
This statement is like a return statement except that the context of the function is preserved. The next time the generator is called execution resumes in this context after where the yield statement was.

For example, in PHP, range(0, 10000) returns an array of elements 0 - 9999 which we could use in a foreach. A similar effect could be achieved with the code:

function my_gen($start, $end) {
    for ($i = $start; $i < $end; $i++) {
        // $i is preserved between yields.
        yield $i;
    }
}

$generator = my_gen(0, 10000);
foreach ($generator as $value) {
    echo "$value\n";
}

The advantage of the above code is that it uses less memory.
You can yield key value pairs with a syntax like:
```
yield $k => $v;
```
A yield statement without an argument returns a pair NUM_TIME_YIELD_CALLED => null.
As we can see above generator objects can be used within foreach loops. They also support the following methods which allows them to be used in while loops or for a stand alone sequence of calls: current, getReturn (get return value of generator when it has finished), key, next, rewind, send (pass a value into generator at $a = yield), throw, and valid (whether or not generator done).

Variable and Anonymous Functions

Variable functions are function calls using a variable. These are convenient to allow one to call methods based on parameters from a request. For example,

$action = $_REQUEST['a'];
$legal_actions = ['landing', 'write', 'read'];
if (in_array($action, $legal_actions)) {
    $action(); // here is the variable function
}

For methods you can use the syntax: $object->$method($arg);

PHP also supports anonymous functions and closures:

$salutation = function($name)
{
    echo "Hi there, " . $name;
}

$salutation('Chris');
$salutation('Bob');

/* To refer to values from the parent scope you can do:
   (i.e., this shows PHP has closures)
 */
$msg = 'there';

// Closures can also accept regular arguments
$example = function ($arg) use ($msg) {
    echo $arg . ' ' . $msg;
};
$example("hi");

PHP Fibers

Starting with PHP 8.1, PHP supports fibers, which are a little bit like supped up generators and also a little like Java threads.
Unlike generators but like a thread, each fiber has its own call stack and can be suspended in deeply nested code. (Generator/corouting yield has scope of the generator/coroutine, Fiber::suspend can be called in functions called from the Fiber's function).

Here is an example from the php.net web site:

<?php
$fiber = new Fiber(function() : void {
   $value = Fiber::suspend('fiber');
  echo "Value used to resume fiber: ", $value, PHP_EOL;
});

$value = $fiber->start();

echo "Value from fiber suspending: ", $value, PHP_EOL;

$fiber->resume('test');

This would output:

Value from fiber suspending: fiber
Value used to resume fiber: test

This completes our initial pass at describing the PHP language.

Composer, PHP Advanced Features

Outline

Composer

Composer

Example Composer Project Using Yioop

Comments on the Example

Quiz

Traits

Exceptions

Generators

Variable and Anonymous Functions

PHP Fibers