Outline

• Composer
• Traits
• Generators
• Post Redirect Get Pattern
• Let's Build Something

Composer

• On Monday, we were 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": ">=3.8.0"
      }
  }
  

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.

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.
• This completes our initial pass at describing the PHP language. Their are some additional new language features in PHP 7; however, as it has just been released we won't go into them. We'll mainly just pretend that PHP 7 is just a fast version of PHP 5.6.

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");
  

Our Website Design Paradigm So Far...

• Our basic set-up for website interaction so far is:
  1. User comes to initial page of web-site.
  2. A default web page (the landing page) for the site is served, either using a static HTML page or a with minimal PHP intervention.
  3. The user clicks links or enters form data to navigate around the site.
  4. No dynamic processing happens on the client.
  5. On the server, a controller processes the link or form data, uses session information, gets/sets database information using models, and chooses a new view to display.
• In choosing a form whether it should use method GET or POST, ask whether the result of processing the form data should be a bookmarkable location?
• If it can be, use GET; otherwise, POST.
• For forms that do things that we don't want to be repeatable with the same information, like purchasing items, posting comments or blog entries, etc., we should use POST.

POST REDIRECT GET

• When you click the reload button on a page that is the result of a POST'd form, or use the back button to cycle through pages where forms were POST'd, your browser will typically ask if you want to resubmit the form data.
• Not only is the back button somewhat broken by this, people have a nasty habit of clicking okay on any dialog box that pops up, which can result in a re-purchase, re-blog post, etc.
• To solve this problem, we use a web design pattern known as POST-REDIRECT-GET.
• The idea is when POST is used for the form:

  <form method="post">
  <!--... some form elements -->
  <input type="submit" name='submit button' value='submit' />
  </form>
  

  we process the data in the receiving controller. Rather than choose a view and display it, we instead, output a 301 redirect, location header to some safe page. In PHP, we could do this with a line like:

  <?php
  header("Location:http://somewhere.safe.com/");
  

• When the browser, goes to http://somewhere.safe.com/, it will use GET to request the page.
• Because the POST'd form data resulted in a redirect, the get location only is stored in the browser history. So now going back through the history using the back button will go through this same page and before this the page where the form was initially blank.

Let's Build Something

Consider the following three files worth of code:

<?php
// View.php
abstract class View
{
    public $layout;
    public function __construct(string $layout) 
    {
        $this->layout = new $layout($this);
    }
    public final function display($data = [])
    {
        $this->layout->renderHeader($data);
        $this->render($data);
        $this->layout->renderFooter($data);
    }
    public abstract function render($data = []);
}

<?php
//Layout.php
abstract class Layout
{
    public $view;
    public function __construct(View $view)
    //notice type hinting allowed for objects
    {
        $this->view = $view;
    }
    public abstract function renderHeader($data);
    public abstract function renderFooter($data);
}

<?php
//index.php
require_once "LetsBuildView.php";
require_once "WebLayout.php";

$data['title'] = "Let's Build Something";
$data['content'] = "Yippee! It works!";
$view = new LetsBuildView("WebLayout");
$view->display($data);

Assume the file index.php is the entry point into the above program. Create concrete implementations of the classes View and Layout called LetsBuildView and WebLayout such that the output of the above is an HTML 5 web page with title $data['title'], the body of the page has $data['title'] in an h1 tag, and has $data['content'] in a paragraph tag.

Post your solutions to the Oct. 19 Let's Build Something Thread