Introduction

Last week, we had begun looking at some of the different pre-processing steps before building an inverted index.
These include case normalization, acronym/abbreviation handling, number/date/time normalization, stemming, and stopping.
We then began talking about Object Oriented PHP so that we could use Yioop as an IR library.
We learned about classes in PHP, method, constructors/destructors.
We begin today, continuing this discussion, first by looking at static methods in PHP and class constants.

Static and Const

The static keyword creates one instance of the field or method for the class.
```
class Foo{ static $bob=1;} 
echo "bob: ".Foo::$bob;
```
Within the class use self:: to refer to static members.
The const keyword can be used to define constants for a class:
```
class Goo{ const BLOB=1;}
```
Notice no dollar sign. Can refer to this using
```
Goo::BLOB
```
Values of constants cannot be changed.
You can create constants outside of any class using the define keyword. For example,
```
define("PI", 22/7);
echo PI;
```

Cloning

PHP has a command clone for cloning objects:
```
$my_copy = clone $my_obj;
```
To specify how the copying is done you can write a __clone() method for your class.

Inheritance

So far we've described how to make a PHP class, constructors, destructors, and cloning.
We've said unlike the default copy-on-write semantics of array assignment, object assignment in PHP is by reference. Let's now turn to inheritance.
Inheritance in PHP is very similar to Java.
A PHP class can extend one other class.
```
class A{}
class B extends A {}
```

PHP also has a notion of interface:

interface MyInterface
{
    function method1($a, $b);
}

A PHP class can implement multiple interfaces:

class C implements MyInterfaceA, MyInterfaceB {}

If you want to have a class with some but not all of its methods defined. You can use the keyword abstract on those methods which will be overriden in subclasses.

Referring to Parents, Final

Consider:

class A {function foo(){} }
class B extends A {function foo(){} }

Within B, self::foo() refers to the redefinition of foo given in the second line above. (Instance methods can also be called using $this->method())
Within B, parent::foo() refers to class A's version of foo.
To prevent a function from being overridden in a subclass you can use the keyword final.
```
class A {final function foo() {} /* can't override*/ }
```

Namespaces

Like C++, PHP supports a notion of namespace. This is similar to the Java notion of package. It allows one to group together a collection of functions, constants, classes, interfaces under one name.
Namespaces must be declared at the start of the file they are in (only the declare command can occur earlier)
A namespace might be declared with a line like:
```
namespace TheNameOfMyNamespace;
// code for namespace
class A
{
  //code for class A
}
function foo()
{
}
```
This declaration with the same name can be at the top of multiple files if you would like to group the contents of these files into the same namespace.
A sub-namespace of a namespace can be declared using backslashes:
```
namespace TheNameOfMyNamespace\MySubNameSpace;
//code
```
Within one file you can switch what namespace you are defining, but it is not recommended:
```
namespace D {
  // code for D
}
namespace E {
  // code for E
}
```

Using Namespaces

Function or class names without qualifications are assumed to come from the current namespace:
```
namespace N;
function foo()
{
  //some code
}

foo(); //assume N namespace.
```

Before function, interface, class, or constant names we can also give the namespace path (either relative or absolute):

M\foo(); /*in context of above we are in N namespace already, 
          so M\foo() means the foo() in N\M namespace. */
\N\M\foo();
\time(); //time function in the global (default) namespace.

You can import a namespace using the use keyword:

use A\B\C;
//rather than typing A\B\C\foo(); could type foo();
use D\E\F as G;
//rather than typing D\E\F\goo(); could type G\goo();

Namespace Conventions

When you create a new project you don't want to pollute the global namespace with your variables, functions, and classes.
Doing so prevents your code from inter-operating with other PHP code.
The modern way to create PHP projects is to write your project within a namespace of the format: \some_vendor_name\some_project_name.
For example,
```
namespace seekquarry\yioop;
```
Following this convention, the above declaration should be at the top of a file with at most one file level comment at above it.
You can of course declare sub-namespaces of a project too such as:
```
namespace seekquarry\yioop\models;
```
After the declaration, you should have a blank line followed by any use declarations you need.

Autoloading

The require and require_once commands read in the file given as their argument regardless of whether the classes, functions, etc. are ever used.
In a web and interpreted environment this can result in slower performance, if there are a lot of files being included in this way.
On the other hand, a use declaration does not load anything into memory -- it is just declares a naming convention to be used for how to refer to classes and functions.
In PHP, we can use the spl_autoload_register($your_autoloader_function); command to register a PHP function to be called whenever someone tries to instantiate a class or call a function which is not currently in memory.
Using autoloading, allows us to minimize the number of files we read in before executing code.
The autoloader function typically makes use of the namespace info from use declarations to search the file system to find the definition of the class or function that is being instantiated or used.
The Composer Project makes extensive use of autoloading and is used to build projects using Yioop as a library.

More Autoloading

The Yioop search engine can either make use of the autoloader that it comes with or it can use Composer's autoloader.

The code to check which to use and the native autoloader are in YIOOP_FOLDER/src/configs/Config.php. and looks like:

if (file_exists(__DIR__."/../../vendor/autoload.php")) {
    require_once __DIR__."/../../vendor/autoload.php";
} else {
    spl_autoload_register(function ($class) {
        // project-specific namespace prefix
        $prefix = 'seekquarry\\yioop\\tests';
        // does the class use the namespace prefix?
        $len = strlen($prefix);
        if (strncmp($prefix, $class, $len) !== 0) {
            $prefix = 'seekquarry\\yioop';
            $len = strlen($prefix);
            // no, move to the next registered autoloader
            if (strncmp($prefix, $class, $len) !== 0) {
                return;
            } else {
                $check_dirs = [WORK_DIRECTORY . "/app", BASE_DIR];
            }
        } else {
            $check_dirs = [PARENT_DIR . "/tests"];
        }
        // get the relative class name
        $relative_class = substr($class, $len);
        // use forward-slashes, add ./php
        $unixify_class_name = "/".str_replace('\\', '/', $relative_class) .
            '.php';
        foreach($check_dirs as $dir) {
            $file = $dir . $unixify_class_name;
            if (file_exists($file)) {
                require $file;
                break;
            }
        }
    });
}

Comments on the Yioop Autoloader

Notice the native autoloader gets a string name of the form some_namespace\class. The above autoloader checks if the namespace begins with seekquarry\yioop. If it doesn't then it returns -- it doesn't know how to autoload it.
Otherwise, we take the portion of the name after the vendor\project, $relative_class. For example, \seekquarry\yioop\models\Model, has $relative_class as \models\Model. We convert backslashes into forward slashes and tack on .php. Then we look to see if either of the files BASE_DIR . $relative_class or WORK_DIRECTORY . /app$relative_class exist and if so load it. I.e., in our example, we check for BASE_DIR . /model/Model.php and WORK_DIRECTORY/app/model/Model.php
For us to find the class we want, we need to follow the convention that a class is always defined in a file with the same number and in the appropriate relative folder.
The Composer project also follows this convention.

Composer

Composer is a package management system for PHP. It is similar to npm for Javascript or pip for python. 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/.
Yioop is one such project.

Quiz

Which of the following is true?

Stemming tends to increase precision, but reduce recall.
Mean Average Precision is a score typically calculated over several topics.
Removing stopwords usually increases recall, but reduces precision.

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"
        }
    ],
    "config": {
        "secure-http": false
    },
    "require": {
        "seekquarry/yioop": "dev-master"
    }
}

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\Library;
use seekquarry\yioop\library\PhraseParser;

require_once "vendor/autoload.php";
/*
   Since a normal Yioop instance needs a Profile.php file to be generated,
   the following is used to set up Yioop in library mode so you don't need this.
   To enable debugging use Library::init(true);
 */
Library::init();
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.
Another 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.
We will continue our discussion of the organization of things in the Yioop project as the semester progresses. But now we return to talking about building inverted indexes, after this short break.

<?php
namespace cpollett\test_composer;

use seekquarry\yioop\library as L;
use seekquarry\yioop\library\Library;
use seekquarry\yioop\library\LinearAlgebra as LA;
use seekquarry\yioop\library\FetchUrl;
use seekquarry\yioop\library\PhraseParser;
use seekquarry\yioop\library\CrawlConstants;

require_once "vendor/autoload.php";

/*
   Since a normal Yioop instance needs a Profile.php file to be generated,
   the following is used to set up Yioop in library mode so you don't need this.
   To enable debugging use Library::init(true);
 */
Library::init();

// download a collection of web pages and then pretty print
$page_info = FetchUrl::getPages(
    [[CrawlConstants::URL => "https://www.yahoo.com/"]],
     // we could list more urls to download
);
print_r($page_info);

// stem word or phrases
print_r(PhraseParser::stemTerms("image", 'en-US'));
print_r(PhraseParser::stemTerms("I once knew a jumpy cat", 'en-US'));
print_r(PhraseParser::stemTerms("Allons enfants de la Patrie,
    Le jour de gloire est arrivé!", 'fr-FR'));

// segment strings into words
print_r(PhraseParser::segmentSegment("从前,在一块遥远的土地上", 'zh-CN'));

//detect language from text
$pinocchio = <<< EOD
Come andò che Maestro Ciliegia, falegname trovò un pezzo di legno che
piangeva e rideva come un bambino.

C'era una volta....

Un re! — diranno subito i miei piccoli lettori.

No, ragazzi, avete sbagliato. C'era una volta un pezzo di legno.

Non era un legno di lusso, ma un semplice pezzo da catasta, di quelli
che d'inverno si mettono nelle stufe e nei caminetti per accendere il
fuoco e per riscaldare le stanze.
EOD;

$lang = L\guessLocaleFromString($pinocchio);
echo $lang . "\n";

//make term frequency vector of stemmed terms
$vec = PhraseParser::extractPhrasesAndCount($pinocchio, $lang);
print_r($vec);

// Normalize this vector
$norm = LA::normalize($vec);
print_r($norm);

PHP Autoloading - Yioop as an IR Library

Outline

Introduction

Static and Const

Cloning

Inheritance

Referring to Parents, Final

Namespaces

Using Namespaces

Namespace Conventions

Autoloading

More Autoloading

Comments on the Yioop Autoloader

Composer

Quiz

Composer

Example Composer Project Using Yioop

Comments on the Example