Phiber Framework - Documentation

Getting Started

Welcome

Tired of plain PHP or from using your old bloated and messy framework?

Look no more, Phiber is what you're after

Shopping for a good framework might prove to be a tedious task not only because of the amount of available PHP frameworks. But mostly because learning a new framework just so you can test it properly, even if it might sound like the only right way to it, is not really an option for the majority of us. Not that learning a new framework is an easy thing to do any way. One might spend a "career" time just learning the quircks of his favourit framework. The strategy most developers use when looking for a framework to adopt is to look for how many people were actually sold to a given framework (community that is). You know, the herd mentality.
Having a community is certainly a great point in favour of any framework but it should not be decisive to say the least because YOUR NEEDS are specific to you and to your project they are NOT and will never be the community's point of focus.

Why?
You need a framework that enables you as a developer with a set of tools, components and concepts to help you cut through the boring routines and repetitive tasks so you can focus on your solution.
Phiber does not attempt to do your job or outsmart you. Other frameworks will tell that all you need is to define a class to be able to do CRUD (Create, Read, Update, Delete) operations on a table, or create class so the DDL is generated for you in an unnatural way only to discover later that your dear framework is killing your DB server by issuing queries that you never asked for. Soon enough you'll be asking what the PH is going on? The most automagic you'll see is due to PHP's autoloading capability and a set of conventions as to where files should be located. Phiber Framework is only ~2500 lines of code long ;)

Features

Very easy to learn (probably why you picked PHP in the first place)
Very easy to develope and deploy with Myo and Composer
Lightweight and very fast (150k uncompressed)
One-file easy configuration
Painless Routing (simple and RegEx/named params)
Drop-in architecture for plugins, modules and even controllers
True MVC (Models CAN communicate with views directly)
eventful (trigger and listen to events if you want to)
OOSQL ORM and Query builder (Zero configuration)
Entity generator (Design your DB like a DBA)
Use any library out there within your plugins, models or controllers
Myo command line tool to speed up development and prototyping

License

Phiber Framework is free for personal and commercial projects. Phiber Framework is released under the terms of the MIT license.

Working with Phiber

Install

1. Using composer

  composer create-project phiber/sample-app your-project-name

2. Using Myo
Refer to Myo section in this doc.

Permissions
On linux, make sure your webserver has enough permissions for phiber to create/write files in the application folder.
Requirements

PHP >=5.3
Webserver (Apache, Nginx, IIS)

Front controller server config
To be able to use Phiber you'll need to configure your server to route all requests through index.php. There are multiple ways to make this happen, for example:

Apache .htaccess example

  
		  RewriteEngine On
		  RewriteCond %{REQUEST_FILENAME} -s [OR]
		  RewriteCond %{REQUEST_FILENAME} -l [OR]
		  RewriteCond %{REQUEST_FILENAME} -d
		  RewriteRule ^.*$ - [NC,L]
		  RewriteRule ^.*$ /index.php [NC,L]

		  # if installed in a subfolder
		  #RewriteRule ^.*$ /subfolder/index.php [NC,L]

Nginx example config

		   try_files   $uri $uri/ /index.php?$args;

Configuration

 
  $phiber = new Phiber\wire('../application/config.php');

Timezone and Mode

date_default_timezone_set()

  public $PHIBER_TIMEZONE = 'Africa/Algiers';

  protected $PHIBER_MODE = 'dev';

Database configuration


  public $PHIBER_DB_DSN = 'mysql:host=127.0.0.1;dbname=databaseName';
  
  public $PHIBER_DB_USER = "root";

  public $PHIBER_DB_PASS = "password";

Myo

 myo app myapp

 Would you like to configure myapp [yes]? (yes/no)

Log configuration

 /**
   * Enable/Disable logging
   * @var boolean
   */
  public $PHIBER_LOG = true;
  /**
   * Default logging handler
   * @var string
   */
  public $PHIBER_LOG_DEFAULT_HANDLER = 'file';
  /**
   * Log filename
   * @var string A valid filename
   */
  public $PHIBER_LOG_DEFAULT_FILE = 'logfile.log'; 
   /**
   * Directory of the logs please set an absolute path. Must be writable by the server
   * @var string A Valid absolute path (directories will not be created for you)
   */
  public $logDir = null;

  /**
   * Sets log level inclusive to previous levels i.e setting it to 'alert'
   * will log 'alert' and 'emergency' level events and 'debug' will log everything
   *
   * 'emergency';
   * 'alert';
   * 'critical';
   * 'error';
   * 'warning';
   * 'notice';
   * 'info';
   * 'debug';
   */
  public $logLevel = 'debug';
  /**
   * Stop execution on warnings
   */ 
  public $STOP_ON_WARNINGS = true;
   /**
   * Stop execution on user triggered warnings
   */ 
  public $STOP_ON_USER_WARNINGS = true;

Session configuration

  /**
   * Session will be destroyed after 1800 seconds (30
   * minutes) of inactivity Alternatively set the value that you like in seconds
   */
  public $PHIBER_SESSION_INACTIVE = 1800;
  /**
   * The session id will be reginerated after 1800 seconds (30
   * minutes). Alternatively set the value that you like in seconds
   */
  public $PHIBER_SESSION_REGENERATE = 1800;

Path configuration

   /**
    * The absolute path to phiber library
    */
   protected $library = '/path/to/vendor/phiber/phiber/library';
   /**
    * The absolute path to the application folder
    */
   protected $application = '/path/to/application';

Controller defaults

  /**
   * The action method that should be called from your controller in case a
   * none-existant action is called (or none specified)
   */
  public $PHIBER_CONTROLLER_DEFAULT_METHOD = 'main';
  /**
   * The default controller to use if non is specified or not found
   */
  public $PHIBER_CONTROLLER_DEFAULT = 'index';

Bootstrap

bootstrap\start is not really a configuration file but because it is executed first it is a good place to put bootstrap code, add external libraries, register for events, start session or whatever checks and initialization tasks.

Routes

Phiber does NOT require any routes pre-configured to work. Instead the router uses convention to locate the target resources. Out of the box Phiber will route the following ugly URL:

http://yoursite.com/<module>/<controller>/<action>/var1/val1?var2=val2/?var3/val3

Array
(
    [module] => dev
    [controller] => index
    [action] => action
    [vars] => Array
        (
            [var1] => val1
            [var2] => val2
            [var3] => val3
        )

)

modules/<module>/<controller>.php

http://yoursite.com/<module>/<controller>/<action>/var1/val1/var2/val2/var3/val3

Simple routes (aliases):

  
 include "../vendor/phiber/phiber/library/phiber.php";

 $phiber = new Phiber\wire('../application/config.php');

 $phiber->addRoute(array('/info'=>'/module/controller/action/var1/val1');
 $phiber->addRoute(array('/about'=>'/module/controller/action/var1/val1'); 

 $phiber->boot();

RegEx and parameterized rules:

$phiber->addRoute(array('~/info/(\d+)/(\d+)~'=>'/module/controller/action/:cat/:id'));

/info/14/32

/module/controller/action/cat/14/id/32


$phiber->addRoute(

 array('/info'=>  

   function($phiberInstance) // an instance of Phiber is passed to your function automatically
    {
    // DB interactions
      $data = entity\myTable::getInstance()->select()->fetch();

    //Listen to an event

    Phiber\Event\eventful::attach(

        function($event)
         { 

            var_dump($event);

         }, 
  
        Phiber\phiber::EVENT_SHUTDOWN
 
     );

      echo "some text"; // print something directly
      $phiberInstance->view->setLayout('path/to/layout.php');
      $phiberInstance->view->setView('path/to/view.php');
      $phiberInstance->view->variable = 'assigned text';
      
     //Do a rewrite by setting a route and returning true

     $phiberInstance->currentRoute = array('module'=>'mod',
                                           'controller'=>'myController',
                                            'action' => 'myAction');
    
  //return (bool) true will tell Phiber to resume dispatching to a configured (or default) route
     
    return true; 

    }
  );

Route Files

//routes.php
return array(
    array('~/info/(\d+)/(\d+)~'=>'/modeule/controller/action/:param1/:param2'),
    array('~/infos~'=>'/module/controller'),
    array('~/عربي/(\d+)/(\d+)~'=>'/myo/index/main/:cat/:id'),
    ...
    ...
    //Other routes
);

$phiber->addRoutesFile('/path/to/routes.php');

Install to a subfolder

//file: index.php

//Make sure to update the include path for wire.php and config.php in this file

//change <subfolder> to your folder name

$phiber->baseUrl('<subfolder>');

$phiber->boot()

//file: .htaccess 

//change <subfolder> to your folder name
RewriteRule ^.*$ /<subfolder>/index.php [NC,L]

http://www.yoursite.com/<subfolder>/

OOSQL

The Object Oriented SQL interface is a lightweight Query Builder providing a fluent interface with ORM functionality.

OOSQL's power stems from its use of the entity files created by the OOGen utility. This utility ships with the framework and can be used as a CLI script or using Myo through the entity command.

Entity classes reflect the data model found in your database, capturing essential parts of your DDL to map the tables correctly. The entity class will hold the column names as properties. It also captures the primary key if there is any and in this regard it doesn't rely on any convention what so ever. Meaning, you could name your primary key whatever you like and not just id or user_id... etc.

Entity classes will also understand your composite keys and give you ways to find records using all your key members or by one or more of them.

Relationships (innoDB required) will be discovered and available to query against.

Note: MySQL /MariaDB and PostegreSQL are the only databases supported up untill now.

Step one

Design your database like a DBA and make sure that your model is strong enough, use your favourite designer like MySQL Workbench then go ahead and create the physical database using a great DDL like this one:

 CREATE TABLE IF NOT EXISTS `employees` (
  `emp_no` int(11) NOT NULL,
  `birth_date` date NOT NULL,
  `first_name` varchar(14) NOT NULL,
  `last_name` varchar(16) NOT NULL,
  `gender` enum('M','F') NOT NULL,
  `hire_date` date NOT NULL,
  PRIMARY KEY (`emp_no`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
 CREATE TABLE IF NOT EXISTS `salaries` (
  `emp_no` int(11) NOT NULL,
  `salary` int(11) NOT NULL,
  `from_date` date NOT NULL,
  `to_date` date NOT NULL,
  PRIMARY KEY (`emp_no`,`from_date`),
  KEY `emp_no` (`emp_no`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Contraintes 
--
 ALTER TABLE `salaries`
  ADD CONSTRAINT `salaries_ibfk_1` FOREIGN KEY (`emp_no`) REFERENCES `employees` (`emp_no`) ON DELETE CASCADE;

Step two

Myo

The hard way

generate.php

<?php
/**
 * Example entities generation script
 */

// include 'pgsql.php';

 include 'mysql.php';
 
 //$gen = new Phiber\oosql\pgsql('pgsql:host=127.0.0.1;dbname=phiber', 'root', 'password');

 $gen = new Phiber\oosql\mysql('mysql:host=127.0.0.1;dbname=phiber', 'root', 'password');
   
 $gen->path = '/path/to/entityfolder';

 $gen->generate();

?>

php generate.php

The easy way

Myo

-g

myo entity -g


Attempting tables discovery...
Analyzing employees physical columns ...
Analyzing employees DDL ...
Analyzing salaries physical columns ...
Analyzing salaries DDL ...
Found constraint salaries_ibfk_1 ...
Generating class employees ... Done
Generating class salaries ... Done
Generated 2 classes in 0.0717 ms | Memory: 19.5859kb

Myo

/******************************
 * salaries.php */

namespace entity;
use Phiber;
class salaries extends Phiber\entity\entity  
{
  public $emp_no;
  public $salary;
  public $from_date;
  public $to_date;

  public function getPrimary()
  {
    return array("emp_no","from_date");
  }
  public function getPrimaryValue($key = null)
  {
    if(null === $key){
      return $this->getCompositeValue();
    }
    $pri = $this->getPrimary();
    if(in_array($key,$pri)){
      return $this->{$key};
    }
  }
  public function getCompositeValue()
  {
    return array(
            "emp_no" => $this->emp_no,
            "from_date" => $this->from_date,
        );
  }
  public function getRelations()
  {
    return array('emp_no'=>'employees.emp_no',);
  }
  public function belongsTo()
  {
    return array("employees");
  }
}


/**********************************************************************
 * employees.php */

namespace entity;
use Phiber;
class employees extends Phiber\entity\entity  
{
  public $emp_no;
  public $birth_date;
  public $first_name;
  public $last_name;
  public $gender;
  public $hire_date;

  public function getPrimary()
  {
    return array("emp_no");
  }
  public function getPrimaryValue($key=null)
  {
    if(null === $key){
      return array("emp_no" => $this->emp_no);
    }
    $pri = $this->getPrimary();
    if(in_array($key,$pri)){
      return $this->{$key};
    }
  }
  public function hasMany()
  {
    return array("emp_no.salaries.emp_no");
  }
}

What Entity classes are good for?

oosql\oosql

<?php
namespace model;
use Phiber;

class myModel extends Phiber\model
{
  public function getEmployees()
  {
      return \entity\employees::getInstance()->select()->fetch();
      //Query: SELECT * FROM employees
      //Return: A collection of hiderated objects of the type entity\employees
  }
}

 //Call our model
 $employees = model\myModel::getInstance()->getEmployees();
 
 //Search within the collection
 $oneEmployee = $employees->findOne('emp_no','10254');

 //Correct his name
 $oneEmployee->last_name = 'Doe'
 $oneEmployee->save(); // Will issue an update query with only the changed column

 //More search
 $femaleEmployees = $employess->findAll('gender','F'); 
 $countSmith = $employees->countWhere('last_name','smith');
 
 //We don't need male employees
 $employees->removeWhere('gender','M');
 
 
 //Lets iterate
 foreach($employees as $femaleEmployee){
   print $femaleEmployee->last_name. ' '. $femaleEmployee->first_name;
 } 
 
 //Do we still have results?
 $empty = $employees->isEmpty();

 //Yes, how many?
 $num = $employees->count()

 //Lets sort'em
 $employees->sortByProperty('last_name');
 
 //Oh wait something happened we need our males back
 $employees->restoreWhere('geneder','M');

 //Last one
 $last = $employees->getLast();

 //Remove from the end
 $last = $employees->pop();

 //Free memory
 $employees->destroy();

oosql\oosql

oosql\oosql .

Lazy or Eager?

The eager way

 $salaries = entity\salaries::getInstance()->select()
              ->where('salary > ?',4400)                   
              // not specifying any columns will select employees.*
              ->with(array('employees' => array('last_name','first_name','gender'))) 
                 
              ->limit(0,20)->fetch();

 $salaries->sortByProperty('salary','n'); //Numeric DESC
 $salary = $salaries->getLast()

 //Employees table related columns are immediately available
 $leastPaid = $salary->last_name .' '.$salary->first_name;

The lazy way

 //Same query without a join
 $salaries = entity\salaries::getInstance()->select()
                   ->where('salary > ?',4400)
                   ->limit(0,20)->fetch();


 $salaries->sortByProperty('salary','n'); //Numeric DESC
 $salary = $salaries->getLast()

 //Employees table related columns are located upon request 
 //by calling the related table as a method on the result object (Not the collection)

 $employee = $salary->employee();

 //Then loaded and made available (see why bellow)
 $employee->load()
 
 $leastPaid = $employee->last_name .' '.$employee->first_name;

A little more

$employee = $salary->employee();
$employee->last_name = 'Doe';
$employee->save();

//Zero SELECTs

Primary ID injection

 $users = entity\users::getInstance();

 //Save new 
 $users->first_name = 'Mohammed';
 $users->last_name = 'Al Kacem';
 $user = $users->save();
 
 //Update newly saved record
 $user->last_name='Taha';
 $user->save();

  // Zero SELECTs

Models

This is an important concept of the MVC pattern. Your model holds your domain logic, your data structure and manipulation routines. It doesn't have to do a database related task for your model to provide data and domain logic for your application. That's why the model class in Phiber will not inherit any database related routines to give you a lightweight sane launch pad. Database mapping is not done in your models but in your entity files instead allowing you to split the fat and keep your models as clean as possible.
Create models manually in the model directory or by using Myo. An example model file would look like this:


namespace model;

use Phiber\model;

class mymodel extends model
{
  public function getData()
  {
     /* Your code here */
  }
}

To use this model just call an instance of it.

$data = model\mymodel::getInstance()->getData();

The V in the middle

Can models talk to views?
Yes, they can. The MVC term is used so much all over the web and is implemented as a pattern by different frameworks. The original architecture however, is not being respected by all frameworks. Instead, variants of this architechture are in use and even Phiber does not follow the orginal MVC architecture to the letter.
But Phiber does respect one of the features of the MVC architecture which is the ability for models to communicate with views. Models in a Phiber application can create view variables that can be rendred directly by the view.

class mymodel extends model
{
  public function getData()
  {
     $this->view->someVar = "from model";
  }
}

// In your view file

echo $this->someVar;

Plugins

/path/to/myapp/application/plugins/auth/auth.php


class auth extends \Phiber\plugin
{

  private $user = null;
  private $resource = null;

  public function __construct()
  {
    //Get the requested module
    $this->resource = $this->route['module'];

  }
  public function run ()
  {
   
    //What modules that don't need authentication
    $allowed = array("default","auth","about");

    //Get user info from the session (guest user is there by default)
    $this->user = $this->session->get('user');

    if(($this->user['name'] === 'guest') && !in_array($this->resource,$allowed)){

      $this->_redirect('/auth/login');

      return;

    }else{
      //If we're here
     //This is a logged in user or a publically accessible resource

      if($this->user['name'] != 'guest'){

        /* User is logged in */

      }
    }
  }

}

Phiber\plugin

Modules

/path/to/myapp/application/modules/books/catalog.php

class catalog extends Phiber\controller

{

  public function main()

  {

    $this->view->books = model\books::getInstance()->list();

  }

}

/path/to/myapp/application/modules/books/views/catalog/main.php

 <?php
 foreach($this->books as $book){
   echo $book->title;
 }

Myo

Events

eventful

session

//You don't have to prefix event constants with the word 'EVENT' 
//Pick a name that you like (you'll use it later for getEvents())
 
 const EVENT_REGEN = 'session.regenerate'; 

 const EVENT_DESTR = 'session.destroy';

    $authority = __METHOD__;

    $event = new Phiber\Event\event(self::EVENT_DESTR,  $authority);

 eventful

public static function attach($observer, $event, $hash = null, $m = null)

attach()

session

Phiber\Event\eventful::attach($observer, Phiber\Session\session::EVENT_DESTR);

Phiber\Event\event::attach($observer, 'session');

public static function detach($observer = null, $event,$hash = null)

detach()

Phiber\Event\eventful::detach($observer, Phiber\Session\session::EVENT_DESTR);

session

Phiber\Event\eventful::detach($observer, 'session');

session

public static function getEvents(){}

eventful::attach()

eventful::detach()

array

session

public static function getEvents()
  {
    return array(self::EVENT_DESTR,self::EVENT_REGEN);
  }

Fire an event

notify()

Phiber\Event\eventful::notify($event);

update()

phiberEventObserver

Phiber\Events\listener

not

public function update(Phiber\Event\event $event){}

An Example

// application/lib/event/listen.php

<?php
namespace event;
use Phiber\Event;

class listen extends Event\listener
{
  public function update(Event\event $event)
  {
    var_dump($event);
  }
}

<?php
use Phiber\Session\session;

class examplePlugin extends Phiber\plugin
{
  public function run()
  {
    //Register our dummy library (see External Libraries in this doc)
    
    $this->addLib('event');

   //Attach our listener to the session
  
    Phiber\Event\eventful::attach('event\listen', session::EVENT_REGEN);
  
  }


}

event\listen::update()

bootstrap\start

Attach a closure

 Phiber\Event\eventful::attach(  function($event)
                                  { 
                                       var_dump($event);

                                  }, Phiber\phiber::EVENT_SHUTDOWN
 
                               );

  $hash = sha1('myshutdownclosureIdStr')
 
  Phiber\Event\eventful::attach(

        function($event)
         { 

            var_dump($event);

         }, 
  
        Phiber\phiber::EVENT_SHUTDOWN, $hash
 
     );

 // You can use the same hash later to detach this listener
 Phiber\Event\eventful::detach(null, Phiber\phiber::EVENT_SHUTDOWN, $hash);

Custom method

The default method called on listener objects is update() but you can easily overide this behaviour by providing your own method name to the attach() method.

Phiber\Event\eventful::attach($observer, Phiber\phiber::EVENT_SHUTDOWN, null, 'myMethod');

This way everytime 'phiber.shutdown' is fired

$observer->myMethod(event
              $event)

will execute.
Syntactic sugar
Controllers, Models and Plugins provide easier ways to register for events through the attach() builtin method. This method is different than the one provided by eventful.

 protected function attach($event, $observer = null, $hash = null, $runMethod = null)

 //Plugin, Model or Controller
 $this->attach(Phiber\phiber::EVENT_SHUTDOWN);

 //this will hold a copy of this object and execute update() on it when event is fired

To register a different method to execute on event pass its name as the fourth param.

//Plugin, Model or Controller
 $this->attach(Phiber\phiber::EVENT_SHUTDOWN, null, null, 'myMethod');

To pass in a different object instead of the current Plugin, Model or Controller

 $observer = new library\myClass();
 //or
 $observer = 'library\\myclass'; //It'll be instanciated on event

 $this->attach(Phiber\phiber::EVENT_SHUTDOWN, $observer, null, 'myMethod');

 $this->attach('phiber.shutdown');
 //same as 
 $this->attach(Phiber\phiber::EVENT_SHUTDOWN);

$event = new Phiber\Event\event('mypackage.myevent',__class__);

$this->notify($event);

Layout & views

external libraries

layout.php

  /**
   * Layout file
   */
  public  $PHIBER_LAYOUT_FILE = 'layout.php';

render()

$this->render();

T_()

T_($this->var);
// a wrapper for 
echo htmlentities($this->var);

//Controllers, Plugins or Models

$this->view->variable = 'value';
//or array
$this->view->array = array('someValue');
//or object
$this->view->obj = new stdClass;

<h3><?php T_($this->variable) ?></h3>

<table id="cart">
<?php
foreach($this->array as $columns){
  echo '<tr><td>'
  echo implode('</td><td>',$columns);
  echo '</td></tr>';
}
?>

</table>

<span id="total"><?= $this->obj->total ?></span>

/path/to/myapp/application/modules/<module>/views/<controller>/<action>.php

Cache

external libraries


 $driver = new Phiber\Cache\file;

 $cache = new Phiber\Cache\cachepool($driver);

 $key = sha1('employees');

 $data = $cache->getItem($key);

 if($cache->isHit()){ // Do we have a valid cahced version

    $employees = $data; // use it

 }else{

    // No cache was found lets hit the DB    

    $employees = entity\employees::getInstance()->select()->fetch(1000);

    $cache->save($key,$employees,60); //Cache data for one minute

 }

Phiber\Cache\cachepool

Phiber\Interfaces\cacheDriver

namespace Phiber\Interfaces;

interface cacheDriver
{
  public function set($key,$value,$ttl = null);
  public function getKey();
  public function get($key);
  public function getBag();
  public function getMulti($keys);
  public function deleteAll();
  public function delete($key);
  public function isHit();
  public function exists($key);
  public function setExpiration($ttl = null);
  public function getExpiration();
}

Bag items

namespace Phiber\cache;

class item
{
  public $data,
         $ttl,
         $timestamp;

  public function setTtl($ttl)
  {
    $this->ttl = (int) $ttl;
    $this->timestamp = microtime(true);
  }

}

  $this->bag = new Phiber\Cache\item();
  $this->bag->data = $object; // The object to cache
  $this->bag->setTtl($ttl); // ttl in seconds

Log

"Programming
              is the art of creating errors"

~~ A wise man said once

Exception

Fatal Errors

debug

Notice

warning

error

critical

alert

emergency

    // Fatal Error [emergency]
    E_ERROR
    E_COMPILE_ERROR
    E_CORE_ERROR
    E_PARSE
    E_USER_ERROR

    // Uknown error [alert]

    // Warning [critical]
    E_COMPILE_WARNING
    E_CORE_WARNING
    E_WARNING

    // Catchable [error]
    E_RECOVERABLE_ERROR

   
    // User Warning [warning]
    E_USER_WARNING
   
    // Notice [notice]
    E_USER_NOTICE
    E_NOTICE
    E_STRICT

    // Deprecated [info]
    E_DEPRECATED
    E_USER_DEPRECATED

E_USER_WARNING

 try {
      trigger_error('Something bad happened!',E_USER_ERROR)
  }catch(\Exception $e){
      echo $e->getMessage();
  }
  
  //Without a try catch you'll never get here
  echo 'This part will be printed just fine Now.';

configuration

Log handlers

wire::setLog()

public function setLog($logger = null,$params = null,$name = null)


$this->setLog(null, 'secondlog','mylog'); // since 'file' is default null is enough

$this->setLog('file', 'anotherlog'); // log index name will be used as filename

//Suppose that you created an email based log handler
$this->setLog('email', 'myemail@domain.com','myemail');

//Use them

$this->logger()->info('Log an info event')// log to default logfile

$this->logger('mylog')->notice('Log a notice event');// log to logs/secondlog.log

$this->logger('anotherlog')->error('Log an error event');// log to logs/anotherlog.log

$this->logger('myemail')->alert('Log an alert event'); // sends and email

WTF

blog

Phiber\tools

Phiber\tools::wtf($object);

External libraries

//require "../vendor/autoload.php";

//file: /path/to/myapp/application/bootstrap/start.php

    $loader = new \Twig_Loader_Filesystem($wire->config->application.'/templates/');

    $twig = new \Twig_Environment($loader,array(
         'cache' => $wire->config->application.'/data/cache',
    ));
    
    // pass it to the rest of the framework
    $wire->twig = $twig;

//file: /path/to/myapp/application/templates/mytemplate.tpl

{{name}} {{type}}

//file: /path/to/myapp/application/modules/<module>/<controller>.php

$this->view->name = 'Phiber';
$this->view->type = 'Framework';
$this->view->template = $this->twig->loadTemplate('mytemplate.tpl');

//file: /path/to/myapp/application/modules/<module>/views/<controller>/<action>.php

echo $this->template->render(array('name' =>  $this->name, 'type' => $this->type));

bootstrap\start

//file: /path/to/myapp/application/bootstrap/start.php

    $wire->view->disableLayout(); // not needed if disabled in configuration
    $wire->view->disableView();

What if I don't use composer?

lib

bootstrap\start

addLib()

Browser\Browser

 $this->addLib('Browser','gabrielbull/browser/src/Browser');

$browser = new Browser\Browser;

Myo

FEW

Requirements

How to use Myo?

github

myo.bat

myo

>cd /path/to/myapp/application

>myo <command> --conf-path /path/to/myapp/application/config.php

A Phiber Application

Create an application

>myo app myapp

The current version is: t548c6cb28911d7dce5d96e645c856a7b35dabf

Do you want to check the HEAD revision on Github [no]?(yes/no)

Your github username:<type your username>

Fetching revision: g5475ff2f44a9102d8b78639bfcc221c110390b3

Done!

Deploying g5475ff2f44a9102d8b78639bfcc221c110390b3 ...

To: /path/to/myapp

Unpacking ...

Would you like to configure myapp [yes]? (yes/no)

You seem to have the latest version!

Deploying g5475ff2f44a9102d8b78639bfcc221c110390b3 ...

To: /path/to/myapp

Unpacking ...

Would you like to configure myapp [yes]? (yes/no)

Host [mysql]: localhost

DB Name [mysql]: myapp_db

DB User [mysql]: db_user

DB Passwrod [mysql]:

cd myapp
composer self-update
composer install

/path/to/myapp/public_html

Create a module

mvc

//Don't forget to cd to the application folder

>myo mvc --module books

/path/to/myapp/application/modules/books/views/<default controller>

/path/to/myapp/application/modules/books/views/<default controller>/<default action>.php

/path/to/myapp/application/modules/books/views/index/main.php

Create controllers

>myo mvc --module books --controller catalog

/path/to/myapp/application/modules/books/catalog.php

/path/to/myapp/application/modules/books/views/catalog/main.php

Create actions

>myo mvc --module books --controller catalog --action show

class catalog extends Phiber\controller
{
  public function main()
  {
    /* Default action */
  }
  public function show()
  {
    /* Action code here */
  }
 }

/path/to/myapp/application/modules/books/views/catalog/show.php

Create models

>myo mvc --model mymodel

/**
* /path/to/myapp/application/model/mymodel.php
*/
<?php
namespace model;

use Phiber\model;

class mymodel extends model
{
}

Create entity

Generate entity files

OOSQL

 	
  _ __ ___  _   _  ___
 | \'_` _ \| | | |/ _ \
 | | | | | | |_| | (_) |
 |_| |_| |_|\__, |\___/
             __/ |
            |___/    Phiber's Command Line Tool <version>
                   Author: Housseyn Guettaf <ghoucine@gmail.com>

       Usage:

 	myo <comand> <flag> [[--option1 value][--option2 = value]...] -- arg1 arg2 ...


 Flags:

 	-i		Preserve case otherwise files will always be created in lowercase
 	-g		Generate entity files when used with myo entity

 Commands:

 	app		Creates a new Phiber application
        
		 Usage:
		 
		 myo app <appname>
		 
		 Options:
		 
		 --app-path		Specify the application path
		 
 	entity		Creates an entity file or generate entities from db with -g

		 Usage:
		 
		 myo entity <entity name>
		 
		 Creates an empty entity file
		 
		 

		 myo entity -g 		

		 Generates entity files from the database

		 with no options it will use your config to access the db and

		 put the files into the entity folder

		 options:

		 --db-dsn 		 The dsn of your db
		 --db-host 		 Database host
		 --db-name 		 Database name, overides --db-dsn
		 --db-user 		 Database username
		 --db-pass 		 Database password
		 --entity-path 		 The folder to put generated files in
		 


 	ext		Creates myo extensions.

  		 Usage:

  		 myo ext <extension name>

  		 The new extension will be used as a command:

  		 myo <extension name>


 	help		Provides more information about commands.

		 Usage:

		 myo help <command>


 	mvc		Creates different parts of the MVC layout.

  		 mvc <flag> [option]

  		 Options:

  		 --module <module name>

  		 Creates a module and defaults to module 'default'


  		 --controller <controller name>

  		 Creates a controller and defaults to 'index'


  		 --model <model name>

  		 Creates a model


  		 --action <action name>

  		 Creates an action for a given controller

PHP's EASY MVC

Getting Started

Welcome

Look no more, Phiber is what you're after

Features

License

Working with Phiber

Install

Configuration

Bootstrap

Routes

OOSQL

Found a typo? Want to correct something? Please fork this doc and send a pull request