├── Lean
    ├── Http
    │   ├── Response.php
    │   └── Request.php
    ├── File
    │   ├── Handler.php
    │   ├── Remove.php
    │   ├── Upload.php
    │   ├── Image.php
    │   ├── Download.php
    │   └── Export.php
    ├── Request
    │   ├── Get.php
    │   ├── Post.php
    │   ├── Files.php
    │   └── Http.php
    ├── Lean.php
    ├── Utils
    │   ├── Label.php
    │   ├── Hash.php
    │   ├── Select.php
    │   └── Link.php
    ├── App2.php
    ├── Format.php
    ├── Request.php
    ├── Null.php
    ├── Request2.php
    ├── Auth.php
    ├── Format
    │   ├── Money.php
    │   ├── Time.php
    │   └── Date.php
    ├── Mvc.php
    ├── App.php
    ├── Session
    │   └── Namespace.php
    ├── Singleton.php
    ├── Logger.php
    ├── Session.php
    ├── Route.php
    ├── Config.php
    ├── Route2.php
    ├── View.php
    └── Launch.php
├── composer.json
└── README.md


/Lean/Http/Response.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 


--------------------------------------------------------------------------------
/Lean/File/Handler.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dyorg/Lean/HEAD/Lean/File/Handler.php


--------------------------------------------------------------------------------
/Lean/File/Remove.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dyorg/Lean/HEAD/Lean/File/Remove.php


--------------------------------------------------------------------------------
/Lean/File/Upload.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dyorg/Lean/HEAD/Lean/File/Upload.php


--------------------------------------------------------------------------------
/Lean/File/Image.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Myapp_File_Image
 4 | {
 5 | 	public function exibir($image, $type)
 6 | 	{
 7 | 		header('Content-type'. $type);
 8 | 		echo $image;
 9 | 	}
10 | }


--------------------------------------------------------------------------------
/Lean/Request/Get.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Request;
 3 | 
 4 | class Get extends Http
 5 | {
 6 | 	static private $instance;
 7 | 
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self($_GET);
11 | 
12 | 		return self::$instance;
13 | 	}
14 | }


--------------------------------------------------------------------------------
/Lean/Request/Post.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Request;
 3 | 
 4 | class Post extends Http
 5 | {
 6 | 	static private $instance;
 7 | 
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self($_POST);
11 | 
12 | 		return self::$instance;
13 | 	}
14 | }


--------------------------------------------------------------------------------
/Lean/Request/Files.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Request;
 3 | 
 4 | class Files extends Http
 5 | {
 6 | 	static private $instance;
 7 | 
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self($_FILES);
11 | 
12 | 		return self::$instance;
13 | 	}
14 | }


--------------------------------------------------------------------------------
/Lean/Lean.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Lean\Launch;
 4 | 
 5 | if (!defined('PHP_VERSION_ID') || PHP_VERSION_ID < 50300)
 6 | 	die('PHP Lean Framework requires PHP 5.3 or higher');
 7 | 
 8 | define('PHP_LEANFRAMEWORK_VERSION_ID','0.1');
 9 | 
10 | function lean_initialize()
11 | {
12 | 	$launch = new \Lean\Launch();
13 | 	$launch->run();	
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/Lean/Utils/Label.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Myapp_Element_Label
 4 | {
 5 | 	static public function message($string)
 6 | 	{
 7 | 		if (!empty($string)) return $out = "<span class='message'>$string</span>";
 8 | 	}
 9 | 
10 | 	static public function error($string)
11 | 	{
12 | 		if (!empty($string)) return $out = "<span class='error'>$string</span>";
13 | 	}
14 | }


--------------------------------------------------------------------------------
/Lean/App2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | class App2
 5 | {					
 6 | 	public function format() 
 7 | 	{ 
 8 | 		return Format::singleton(); 
 9 | 	}
10 | 	
11 | 	public function logger() 
12 | 	{	
13 | 		return Logger::singleton();
14 | 	}
15 | 	
16 | 	public function request() 
17 | 	{	
18 | 		return Request::singleton(); 
19 | 	}
20 | 
21 | 	public function route()
22 | 	{
23 | 		
24 | 	}
25 | }


--------------------------------------------------------------------------------
/Lean/File/Download.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\File;
 3 | 
 4 | class Download extends \Singleton
 5 | {
 6 | 	static public function force($path, $file, $name = null)
 7 | 	{
 8 | 		if (is_null($name)) $name = $file; 
 9 | 		
10 | 		$path = $path . DIRECTORY_SEPARATOR . $file;
11 | 		header ("Content-Disposition: attachment; filename=".$name."");
12 | 		header ("Content-Type: application/octet-stream");
13 | 		header ("Content-Length: ".filesize($path));
14 | 		readfile($path);
15 | 	} 
16 | }


--------------------------------------------------------------------------------
/Lean/Request/Http.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Request;
 3 | 
 4 | class Http extends \Lean\Singleton
 5 | {
 6 | 	static protected $http_variable;
 7 | 
 8 | 	public function __construct($http_variable = null)
 9 | 	{
10 | 		foreach ($http_variable as $key => $value) {
11 | 			$this->{$key} = $value;
12 | 		}
13 | 	}
14 | 
15 | 	public function decode($to = 'ISO-8859-1', $from = 'UTF-8')
16 | 	{
17 | 		foreach ($this as $key => $value)
18 | 		{
19 | 			$this->$key = mb_convert_encoding($value, $to, $from);
20 | 		}
21 | 
22 | 		return $this;
23 | 	}
24 | }


--------------------------------------------------------------------------------
/Lean/Format.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | class Format extends Singleton
 5 | {
 6 | 	static private $instance;
 7 | 	
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self;
11 | 		
12 | 		return self::$instance;
13 | 	}
14 | 	
15 | 	public function date()
16 | 	{
17 | 		return Format\Date::singleton();
18 | 	}
19 | 	
20 | 	public function money()
21 | 	{
22 | 		return Format\Money::singleton();
23 | 	}
24 | 	
25 | 	public function time()
26 | 	{
27 | 		return Format\Time::singleton();
28 | 	}
29 | }


--------------------------------------------------------------------------------
/Lean/Request.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | use Lean\Request\Files;
 5 | 
 6 | class Request extends Request\Http
 7 | {	
 8 | 	static private $instance;
 9 | 	
10 | 	public static function singleton()
11 | 	{
12 | 		if(!isset(self::$instance))	self::$instance = new self($_REQUEST);
13 | 	
14 | 		return self::$instance;
15 | 	}
16 | 	
17 | 	public function post() { return Request\Post::singleton(); }
18 | 	
19 | 	public function get() { return Request\Get::singleton(); }
20 | 	
21 | 	public function files() { return Request\Files::singleton(); }
22 | 	
23 | }
24 | 
25 | 
26 | 
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/Lean/Null.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | class Null
 5 | {
 6 | 	static private $instance;
 7 | 
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self;
11 | 
12 | 		return self::$instance;
13 | 	}
14 | 
15 | 	private function __construct() {}
16 | 	
17 | 	final private function __clone() {}
18 | 
19 | 	public function __get($var) { return $this; }
20 | 
21 | 	public function __set($var, $value) { return $this; }
22 | 
23 | 	public function __toString() { return ''; }
24 | 
25 | 	public function __invoke() { return self::singleton(); }
26 | 	
27 | 	public function __call($var, $args) { return $this; }
28 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "lean/lean",
 3 |     "description": "Lean PHP, a micro Framework PHP really simple.",
 4 |     "type": "library",
 5 |     "keywords": ["microframework", "api", "rest", "mvc"],
 6 |     "homepage": "https://github.com/dyorg/Lean",
 7 |     "license": "MIT",
 8 |     "authors": [
 9 |         {
10 |             "name": "Dyorg Almeida",
11 |             "email": "dyorg@rabbiit.com",
12 |             "homepage": "http://rabbiit.com"
13 |         }
14 |     ],
15 |     "require": {
16 |         "php": ">=5.3.0"
17 |     },
18 |     "autoload": {
19 |         "psr-4": {
20 |           "Lean\\": "Lean/",
21 |           "app\\": "../../../app/"
22 |         }
23 |     }
24 | }


--------------------------------------------------------------------------------
/Lean/Request2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | use Lean\Request\Files;
 5 | 
 6 | class Request2 extends Request\Http
 7 | {	
 8 | 	const ANY 	= 'any';
 9 | 	const DELETE = 'delete';
10 | 	const GET 	= 'get';
11 | 	const POST 	= 'post';
12 | 	const PUT 	= 'put';
13 | 	
14 | 	static private $instance;
15 | 	
16 | 	public static function singleton()
17 | 	{
18 | 		if(!isset(self::$instance))	self::$instance = new self($_REQUEST);
19 | 	
20 | 		return self::$instance;
21 | 	}
22 | 	
23 | 	public function post() { return Request\Post::singleton(); }
24 | 	
25 | 	public function get() { return Request\Get::singleton(); }
26 | 	
27 | 	public function files() { return Request\Files::singleton(); }
28 | 	
29 | }
30 | 
31 | 
32 | 
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/Lean/Auth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Myapp_Auth
 4 | {
 5 | 	static $redirect;
 6 | 	
 7 | 	static $auth = true;
 8 | 	
 9 | 	static public function authenticate($password_user, $password_db)
10 | 	{
11 | 		if ($password_user == $password_db)
12 | 		{
13 | 			Myapp_Session::session()->setAttribute('AUTH_SESSION', 'YES');
14 | 
15 | 			return true;
16 | 		}
17 | 
18 | 		return false;
19 | 	}
20 | 	
21 | 	static public function isAuth()
22 | 	{
23 | 		if (self::$auth == false) return true;
24 | 		
25 | 		if (Myapp_Session::session()->getAttribute('AUTH_SESSION') === 'YES')
26 | 		{
27 | 			return true;
28 | 		}
29 | 		
30 | 		return false;
31 | 	}
32 | 	
33 | 	static public function discart()
34 | 	{
35 | 		Myapp_Session::session()->unsetAttribute('AUTH_SESSION');
36 | 		//Myapp_Session::session('AUTH_SESSION', 'NO');
37 | 		return true;
38 | 	}
39 | }


--------------------------------------------------------------------------------
/Lean/Format/Money.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Format;
 3 | 
 4 | class Money extends \Lean\Singleton
 5 | {
 6 | 	static private $instance;
 7 | 	
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self;
11 | 		
12 | 		return self::$instance;
13 | 	}
14 | 	
15 | 	public static function format_to_human($value)
16 | 	{			
17 | 		if (empty($value) || $value == '') return '0,00';
18 | 
19 | 		return number_format($value, 2, ',', '.');
20 | 	}
21 | 
22 | 	public static function format_to_machine($value)
23 | 	{
24 | 		/*
25 | 		 * se for tipo n�merico n�o � necess�rio formatar
26 | 		*/
27 | 		if (is_numeric($value)) return $value;
28 | 
29 | 		if (empty($value)) return 0;
30 | 
31 | 		$value = str_replace('.', '', $value);
32 | 		$value = str_replace(',', '.', $value);
33 | 
34 | 		return $value;
35 | 	}
36 | }


--------------------------------------------------------------------------------
/Lean/Mvc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | /**
 5 |  * 
 6 |  * @author	Dyorg Almeida
 7 |  * @since	21/10/2014
 8 |  *
 9 |  */
10 | class Mvc extends App 
11 | {				
12 | 	/**
13 | 	 * Verify either action is a method pre defined
14 | 	 * 
15 | 	 * <exemples>
16 | 	 * 
17 | 	 * $_REQUEST[action] = 'test'; 
18 | 	 * $this->test_action();
19 | 	 * 
20 | 	 * $_POST[action] = 'hello'; 
21 | 	 * $this->hello_action();
22 | 	 * 
23 | 	 * </exemples>
24 | 	 */
25 | 	public function __construct()
26 | 	{			
27 | 		if(!empty($this->request()->action))
28 | 		{
29 | 			$method_action = $this->request()->action . '_action';
30 | 			
31 | 			if(method_exists($this, $method_action))
32 | 			{
33 | 				$this->{$method_action}();
34 | 			}
35 | 		}
36 | 	}
37 | 	
38 | 	
39 | 	public function view()
40 | 	{
41 | 		return View::singleton(get_class($this));
42 | 	}
43 | }


--------------------------------------------------------------------------------
/Lean/File/Export.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Myapp_Export_Header
 4 | {
 5 | 	static private function export($filename)
 6 | 	{
 7 | 		ob_clean();
 8 | 		
 9 | 		header ("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
10 | 		header ("Last-Modified: " . gmdate("D,d M YH:i:s") . " GMT");
11 | 		header ("Cache-Control: no-cache, must-revalidate");
12 | 		header ("Pragma: no-cache");
13 | 		header ("Content-Disposition: attachment; filename={$filename}" );
14 | 		header ("Content-Description: PHP Generated Data" );
15 | 	}
16 | 
17 | 	/* Exportar para arquivos RTF/DOC */
18 | 	static public function toWord($filename)
19 | 	{
20 | 		self::export($filename);
21 | 		header( "Content-type: application/msword" );
22 | 	}
23 | 
24 | 	/* Exportar para arquivos RTF/DOC */
25 | 	static public function toPDF($filename)
26 | 	{
27 | 		self::export($filename);
28 | 		header( "Content-type: application/pdf" );
29 | 	}
30 | 
31 | 	static public function toXLS($filename)
32 | 	{
33 | 		self::export($filename);
34 | 		header("Content-type: application/x-msdownload");
35 | 		//header ("Content-type: application/x-msexcel");
36 | 	}
37 | }


--------------------------------------------------------------------------------
/Lean/Utils/Hash.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Utils;
 3 | 
 4 | class Hash
 5 | {
 6 | 	const NUMERIC = '0123456789';
 7 | 	
 8 | 	const ALPHA = 'abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ';
 9 | 	
10 | 	const ALPHA_ONLY_UPPER = 'ABCDEFGHIJKLMNOPQRSTUWXYZ';
11 | 	
12 | 	const ALPHA_ONLY_LOWER = 'abcdefghijklmnopqrstuwxyz';
13 | 	
14 | 	const SYMBOLS = '!@#$%&*-+?:|';
15 | 	
16 | 	const ALL = '99';
17 | 	
18 | 	/**
19 | 	 * Cria um hash
20 | 	 * 
21 | 	 * <code>
22 | 	 * Hash::generate(8, Hash::ALPHA);
23 | 	 * Hash::generate(5, Hash::ALPHA_ONLY_UPPER);
24 | 	 * Hash::generate(8, Hash::ALPHA_ONLY_LOWER . Hash::NUMERIC);
25 | 	 * Hash::generate(10, Hash::SYMBOLS);
26 | 	 * Hash::generate(10, Hash::ALL);
27 | 	 * </code>
28 | 	 * 
29 | 	 * @param integer $sizeof Tamanho do hash a ser criado
30 | 	 * @param string $caracters
31 | 	 * @return hash
32 | 	 */
33 | 	static public function generate($sizeof = 8, $caracters = self::NUMERIC)
34 | 	{
35 | 		$hash = NULL;
36 | 		
37 |     	for ($i = 0; $i < $sizeof; $i++) {
38 |         	$hash .= substr($caracters, rand(0, strlen($caracters)-1), 1);
39 |     	}
40 |     		
41 |     	return $hash;
42 | 	}
43 | }


--------------------------------------------------------------------------------
/Lean/Utils/Select.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean\Utils;
 3 | 
 4 | class Select
 5 | {
 6 | 	public static function create()
 7 | 	{
 8 | 		
 9 | 	} 
10 | 	
11 | 	public static function create_options($list, array $options = null) // $firstblank = true, $contentdefault = null, $option_selected = null)
12 | 	{
13 | 		$option_selected = null;
14 | 		$option_first_ = null;
15 | 		
16 | 		
17 | 		if(is_null($options))
18 | 		{
19 | 			if(isset($options['option_selected'])) $option_selected = $options['option_selected'];
20 | 			if(isset($options['option_selected'])) $option_selected = $options['option_selected'];
21 | 		}
22 | 		
23 | 		
24 | 		$output = null;
25 | 		
26 | 		$value = (string) $value;
27 | 		
28 | 		if ($firstblank == true)
29 | 		{
30 | 			if (is_null($contentdefault) || $options) $contentdefault = '&nbsp';
31 | 				
32 | 			$output = "<option value=''>$contentdefault</option>";
33 | 		}
34 | 
35 | 		if ($options)
36 | 		{
37 | 			foreach ($options as $key => $option)
38 | 			{
39 | 				if ($value === (string) $key)
40 | 				$output .= "<option value='$key' selected>$option</option>";
41 | 				else
42 | 				$output .= "<option value='$key'>$option</option>";
43 | 			}
44 | 		}
45 | 
46 | 		return $output;
47 | 	}
48 | }


--------------------------------------------------------------------------------
/Lean/App.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | class App extends Singleton
 5 | {				
 6 | 	/**
 7 | 	 * Verify either action is a method pre defined
 8 | 	 * 
 9 | 	 * <exemples>
10 | 	 * 
11 | 	 * $_REQUEST[action] = 'test'; 
12 | 	 * $this->test_action();
13 | 	 * 
14 | 	 * $_POST[action] = 'hello'; 
15 | 	 * $this->hello_action();
16 | 	 * 
17 | 	 * </exemples>
18 | 	 */
19 | 	public function __construct()
20 | 	{			
21 | 		if(!empty($this->request()->action))
22 | 		{
23 | 			$method_action = $this->request()->action . '_action';
24 | 			
25 | 			if(method_exists($this, $method_action))
26 | 			{
27 | 				$this->{$method_action}();
28 | 			}
29 | 		}
30 | 	}
31 | 
32 |     /**
33 |      * @return Format
34 |      */
35 | 	public function format() 
36 | 	{ 
37 | 		return Format::singleton(); 
38 | 	}
39 | 
40 |     /**
41 |      * @return Logger
42 |      */
43 | 	public function logger() 
44 | 	{	
45 | 		return Logger::singleton();
46 | 	}
47 | 
48 |     /**
49 |      * @return Http\Request
50 |      */
51 | 	public function request() 
52 | 	{
53 |         return Http\Request::singleton();
54 | 	}
55 | 
56 |     /**
57 |      * @return View
58 |      */
59 | 	public function view() 
60 | 	{
61 | 		return View::singleton(get_class($this));
62 | 	}
63 | }


--------------------------------------------------------------------------------
/Lean/Session/Namespace.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Myapp_Session_Namespace extends Myapp_Session
 4 | {
 5 | 	private $namespace;
 6 | 	
 7 | 	public function __construct($namespace = null)	
 8 | 	{
 9 | 		if (is_null($namespace)) $namespace = APPLICATION_ENV;
10 | 		
11 | 		$this->namespace = 'NAMESPACE_'.$namespace;
12 | 		
13 | 		parent::__construct();
14 | 	}
15 | 	
16 | 	static public function session($namespace)
17 | 	{
18 | 		return new Myapp_Session_Namespace($namespace);
19 | 	}
20 | 	
21 | 	public function getAttribute($key = null)
22 | 	{
23 | 		if ($key)
24 | 		{
25 | 			$ns = parent::getAttribute($this->namespace);
26 | 		
27 | 			if ($ns === null) return null;
28 | 			
29 | 			return $ns[$key];
30 | 		}
31 | 		else 
32 | 		{
33 | 			return self::session($this->namespace);
34 | 		}
35 | 	}
36 | 	
37 | 	public function setAttribute($key, $value)
38 | 	{
39 | 		parent::setAttribute($this->namespace,  array($key => $value));
40 | 	}
41 | 	
42 | 	public function unsetAttribute($key)
43 | 	{
44 | 		parent::setAttribute($this->namespace,  array($key => null));
45 | 	}
46 | 	
47 | 	public function isNamespace()
48 | 	{
49 | 		parent::isSession($this->namespace);
50 | 	}
51 | 	
52 | 	public function clear()
53 | 	{
54 | 		parent::unsetAttribute($this->namespace);
55 | 	}	
56 | 	
57 | 	public function destroy()
58 | 	{
59 | 		$this->clear();
60 | 	}
61 | }


--------------------------------------------------------------------------------
/Lean/Utils/Link.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Myapp_Element_Link
 4 | {
 5 | 	static private $styles = array();
 6 | 	
 7 | 	static private $scripts = array();
 8 | 	
 9 | 	static public function addScript($path)
10 | 	{
11 | 		self::$scripts[]= "<script language=\"javascript\" src=\"".ROOT.$path."\" type=\"text/javascript\" ></script>";
12 | 	}
13 | 	
14 | 	static public function addStyle($path, $media = 'all')
15 | 	{
16 | 		self::$styles[] = "<link rel=\"stylesheet\" href=\"".ROOT.$path."\" type=\"text/css\" media=\"$media\">";
17 | 	}	
18 | 	
19 | 	static public function loadScripts()
20 | 	{
21 | 		echo implode('', self::$scripts);
22 | 	}
23 | 	
24 | 	static public function loadStyles()
25 | 	{
26 | 		echo implode('', self::$styles);
27 | 	}	
28 | 	
29 | 	static public function image($path, $alt = null, $title = null, $class= null)
30 | 	{
31 | 		echo "<img alt=\"$alt\" title=\"".$title."\" src=\"".ROOT.$path."\" class=\"$class\">";
32 | 	}
33 | 	
34 | 	static public function loadJQuery($version = '1.7', $env = null)
35 | 	{
36 | 		if(APPLICATION_ENV == 'development' || $env == 'development')
37 | 		{
38 | 			$output = "<script src=\"".ROOT."/scripts/jquery/jquery-$version.min.js\" type=\"text/javascript\"></script>";
39 | 		}
40 | 		else 
41 | 		{
42 | 			$output = "<script type=\"text/javascript\" src=\"https://ajax.googleapis.com/ajax/libs/jquery/$version/jquery.min.js\"></script>";
43 | 		}
44 | 		
45 | 		print $output;
46 | 	}
47 | }


--------------------------------------------------------------------------------
/Lean/Singleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @package LeanFramework
 4 |  */
 5 | namespace Lean;
 6 | 
 7 | /**
 8 |  * This implementation of the singleton pattern does not conform to the strong definition
 9 |  * given by the "Gang of Four." The __construct() method has not be privatized so that
10 |  * a singleton pattern is capable of being achieved; however, multiple instantiations are also
11 |  * possible. This allows the user more freedom with this pattern.
12 |  * credits to ActiveRecord
13 |  * 
14 |  * @package LeanFramework
15 |  */
16 | abstract class Singleton extends \stdClass
17 | {
18 | 	/**
19 | 	 * Array of cached singleton objects.
20 | 	 *
21 | 	 * @var array
22 | 	 */
23 | 	private static $instances = array();
24 | 
25 | 	/**
26 | 	 * Static method for instantiating a singleton object.
27 | 	 *
28 | 	 * @return object
29 | 	 */
30 | 	public static function singleton()
31 | 	{
32 | 		$class_name = get_called_class();
33 | 
34 | 		if (!isset(self::$instances[$class_name]))
35 | 			self::$instances[$class_name] = new $class_name;
36 | 
37 | 		return self::$instances[$class_name];
38 | 	}
39 | 
40 | 	protected function __construct() {}
41 | 	
42 | 	/**
43 | 	 * Singleton objects should not be cloned.
44 | 	 *
45 | 	 * @return void
46 | 	 */
47 | 	final private function __clone() {}
48 | 
49 | 	/**
50 | 	 * Similar to a get_called_class() for a child class to invoke.
51 | 	 *
52 | 	 * @return string
53 | 	 */
54 | 	final protected function get_called_class()
55 | 	{
56 | 		$backtrace = debug_backtrace();
57 |     	return get_class($backtrace[2]['object']);
58 | 	}
59 | 	
60 | 	public function __get($var) {
61 | 		return $this->$var();	
62 | 	}
63 | 	
64 | 	//public function __call($method, $args) { return Null::singleton(); }
65 | 	public function __call($method, $args) { return null; }
66 | 
67 | }
68 | ?>


--------------------------------------------------------------------------------
/Lean/Logger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Lean;
 3 | 
 4 | class Logger extends Singleton
 5 | {
 6 | 	static private $instance;
 7 | 	
 8 | 	public static function singleton()
 9 | 	{
10 | 		if(!isset(self::$instance))	self::$instance = new self;
11 | 	
12 | 		return self::$instance;
13 | 	}
14 | 	
15 | 	public static function log_writer(\Exception $exception, $clear = false, $error_file = 'ex_log.html')
16 | 	{
17 | 		$message = $exception->getMessage();
18 | 		$code = $exception->getCode();
19 | 		$file = $exception->getFile();
20 | 		$line = $exception->getLine();
21 | 		$trace = $exception->getTraceAsString();
22 | 		$date = date('M d, Y h:iA');
23 | 			
24 | 		$log_message = "<h3>Exception information:</h3>
25 | 		<p>
26 | 		<strong>Date:</strong> {$date}
27 | 		</p>
28 | 
29 | 		<p>
30 | 		<strong>Message:</strong> {$message}
31 | 		</p>
32 | 			
33 | 		<p>
34 | 		<strong>Code:</strong> {$code}
35 | 		</p>
36 | 
37 | 		<p>
38 | 		<strong>File:</strong> {$file}
39 | 		</p>
40 | 
41 | 		<p>
42 | 		<strong>Line:</strong> {$line}
43 | 		</p>
44 | 
45 | 		<h3>Stack trace:</h3>
46 | 		<pre>{$trace}</pre>
47 | 		
48 | 		<h3>Request information:</h3>
49 | 		<pre>";
50 | 		foreach ($_REQUEST as $key => $value) {
51 | 			$log_message .= "<strong>$key</strong>: $value<br/>";
52 | 		}
53 | 		$log_message .= "</pre>";
54 | 		
55 | 		$log_message .= "<h3>Server information:</h3>
56 | 		<pre>";
57 | 		foreach ($_SERVER as $key => $value) {
58 | 			$log_message .= "<strong>$key</strong>: $value<br/>";
59 | 		}
60 | 		$log_message .= "</pre>
61 | 		<br />
62 | 		<hr /><br /><br />";
63 | 			
64 | 		if( is_file($error_file) === false ) {
65 | 			file_put_contents($error_file, '');
66 | 		}
67 | 
68 | 		if( $clear ) {
69 | 			$content = '';
70 | 		} else {
71 | 			$content = file_get_contents($error_file);
72 | 		}
73 | 
74 | 		file_put_contents($error_file, $log_message . $content);
75 | 	}
76 | }


--------------------------------------------------------------------------------
/Lean/Session.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean;
  3 | 
  4 | class Session
  5 | {	
  6 | 	static private $instance;
  7 | 	
  8 | 	const NAMESESSION_DEFAULT = 'DEFAULT';
  9 | 	
 10 | 	private $namesession;	
 11 | 	
 12 | 	static public function getSession($namesession = self::NAMESESSION_DEFAULT)
 13 | 	{
 14 | 		if(!isset(self::$instance))	self::$instance = new self;
 15 | 	
 16 | 		self::$instance->startSession();
 17 | 		
 18 | 		self::$instance->setNamesession($namesession);
 19 | 		
 20 | 		return self::$instance;
 21 | 	}
 22 | 	
 23 | 	private function __construct() { }
 24 | 	
 25 | 	public function __destruct()
 26 | 	{
 27 | 		$this->closeSession();
 28 | 	}
 29 | 	
 30 | 	private function startSession()
 31 | 	{
 32 | 		if (!isset($_SESSION))
 33 | 		{
 34 | 			session_start();
 35 | 		}
 36 | 	}
 37 | 	
 38 | 	public function closeSession()
 39 | 	{
 40 | 		if (!isset($_SESSION))
 41 | 		{
 42 | 			session_write_close();
 43 | 		}
 44 | 	}
 45 | 	
 46 | 	public function clear()
 47 | 	{
 48 | 		$this->destroy();
 49 | 	}
 50 | 	
 51 | 	public function destroy()
 52 | 	{
 53 | 		unset($_SESSION[$this->namesession]);
 54 | 		return true;
 55 | 	}
 56 | 	
 57 | 	public function destroyAll()
 58 | 	{
 59 | 		if (isset($_SESSION)) session_destroy();
 60 | 		return true;
 61 | 	}
 62 | 	
 63 | 	public function getAttr($key = NULL)
 64 | 	{
 65 | 		if ($key === null)
 66 | 		{
 67 | 			return $_SESSION[$this->namesession];
 68 | 		}
 69 | 		else
 70 | 		{
 71 | 			if($this->isSession($key))
 72 | 			{				
 73 | 				return $_SESSION[$this->namesession][$key];
 74 | 			}
 75 | 			else
 76 | 			{
 77 | 				return null;
 78 | 			} 
 79 | 		}
 80 | 	}
 81 | 	
 82 | 	public function isSession($key)
 83 | 	{
 84 | 		if(isset($_SESSION[$this->namesession][$key])) {
 85 | 			return true;
 86 | 		}
 87 | 		else {
 88 | 			return false;
 89 | 		}
 90 | 	}
 91 | 	
 92 | 	public function setAttr($key, $value)
 93 | 	{
 94 | 		$_SESSION[$this->namesession][$key] = $value;
 95 | 	}
 96 | 	
 97 | 	public function unsetAttr($key)
 98 | 	{
 99 | 		unset($_SESSION[$this->namesession][$key]);
100 | 	}
101 | 	
102 | 	public function getNamesession()
103 | 	{
104 | 		return $this->namesession;
105 | 	}
106 | 	
107 | 	public function setNamesession($namesession)
108 | 	{
109 | 		$this->namesession = $namesession;
110 | 	}
111 | }
112 | 


--------------------------------------------------------------------------------
/Lean/Route.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Lean;
  4 | 
  5 | class Route
  6 | {
  7 | 	final public function __construct() {}
  8 | 	
  9 | 	private static $route_controller_default = 'Index';
 10 | 	
 11 | 	private static $route_module_default = 'main';
 12 | 	
 13 | 	private static $route_default = '';
 14 | 	
 15 | 	private static $routes_path = null;
 16 | 	
 17 | 	private static $routes = array();
 18 | 	
 19 | 	static public function set($uri, array $route)
 20 | 	{
 21 | 		self::$routes[$uri] = $route;
 22 | 	}
 23 | 
 24 | 	
 25 | 	/**
 26 | 	 * @example {
 27 | 	 * Route::alias('home', 'index');
 28 | 	 * Route::alias(array('home', 'main'), 'index');
 29 | 	 * }
 30 | 	 * 
 31 | 	 * @param (uri or array) $from
 32 | 	 * @param uri $to
 33 | 	 * @throws RouteException
 34 | 	 */
 35 | 	static public function alias($from, $to)
 36 | 	{
 37 | 		if(!isset(self::$routes[$to])) throw new RouteException("route $to indefined");
 38 | 		
 39 | 		if (is_array($from)) {
 40 | 			
 41 | 			foreach ($from as $f) {
 42 | 				
 43 | 				self::set($f, self::$routes[$to]);
 44 | 				
 45 | 			}
 46 | 			
 47 | 		} else {
 48 | 			
 49 | 			self::set($from, self::$routes[$to]);
 50 | 			
 51 | 		}
 52 | 	}
 53 | 	
 54 | 	public static function set_routes_path($path)
 55 | 	{
 56 | 		self::$routes_path = $path;
 57 | 		
 58 | 		include_once $path;
 59 | 	}
 60 | 	
 61 | 	public static function get_routes_path()
 62 | 	{
 63 | 		return self::$routes_path;
 64 | 	}
 65 | 	
 66 | 	public static function get_routes()
 67 | 	{
 68 | 		return self::$routes;
 69 | 	}
 70 | 	
 71 | 	public static function set_route_controller_default($controller)
 72 | 	{
 73 | 		self::$route_controller_default = $controller;
 74 | 	}
 75 | 	
 76 | 	public static function get_route_controller_default()
 77 | 	{
 78 | 		return self::$route_controller_default;
 79 | 	}
 80 | 	
 81 | 	public static function set_route_module_default($module)
 82 | 	{
 83 | 		self::$route_module_default = $module;
 84 | 	}
 85 | 	
 86 | 	public static function get_route_module_default()
 87 | 	{
 88 | 		return self::$route_module_default;
 89 | 	}
 90 | 	
 91 | 	public static function set_route_default($route)
 92 | 	{
 93 | 		self::$route_default = $route;
 94 | 	}
 95 | 	
 96 | 	public static function get_route_default()
 97 | 	{
 98 | 		return self::$route_default;
 99 | 	}
100 | 
101 | }
102 | 
103 | class RouteException extends \Exception { }


--------------------------------------------------------------------------------
/Lean/Config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Lean;
  4 | 
  5 | class Config
  6 | {
  7 | 	final public function __construct() {}
  8 | 	
  9 | 	private static $root_path = 'webroot';
 10 | 	
 11 | 	private static $application_path = '\app';
 12 | 	
 13 | 	private static $module_prefixe = '';
 14 | 	
 15 | 	private static $route_controller_default = 'Index';
 16 | 	
 17 | 	private static $route_module_default = 'main';
 18 | 	
 19 | 	private static $route_default = '';
 20 | 	
 21 | 	private static $routes_path = null;
 22 | 	
 23 | 	public static function set_application_path($application_path)
 24 | 	{
 25 | 		self::$application_path = $application_path;
 26 | 	}
 27 | 	
 28 | 	public static function get_application_path()
 29 | 	{
 30 | 		return self::$application_path;
 31 | 	}
 32 | 	
 33 | 	public static function set_module_prefixe($module_prefixe)
 34 | 	{
 35 | 		self::$module_prefixe = $module_prefixe;
 36 | 	}
 37 | 	
 38 | 	public static function get_module_prefixe()
 39 | 	{
 40 | 		return self::$module_prefixe;
 41 | 	}
 42 | 	
 43 | 	public static function set_route_controller_default($controller)
 44 | 	{
 45 | 		self::$route_controller_default = $controller;
 46 | 	}
 47 | 	
 48 | 	public static function get_route_controller_default()
 49 | 	{
 50 | 		return self::$route_controller_default;
 51 | 	}
 52 | 	
 53 | 	public static function set_route_module_default($module)
 54 | 	{
 55 | 		self::$route_module_default = $module;
 56 | 	}
 57 | 	
 58 | 	public static function get_route_module_default()
 59 | 	{
 60 | 		return self::$route_module_default;
 61 | 	}
 62 | 	
 63 | 	public static function set_route_default($route)
 64 | 	{
 65 | 		self::$route_default = $route;
 66 | 	}
 67 | 	
 68 | 	public static function get_route_default()
 69 | 	{
 70 | 		return self::$route_default;
 71 | 	}
 72 | 	
 73 | 	public static function set_routes_path($routes)
 74 | 	{
 75 | 		self::$routes_path = $routes;
 76 | 	}
 77 | 	
 78 | 	public static function get_routes_path()
 79 | 	{
 80 | 		return self::$routes_path;
 81 | 	}
 82 | 	
 83 | 	public static function get_routes()
 84 | 	{
 85 | 		if(self::$routes_path)
 86 | 			return include_once self::$routes_path;
 87 | 		else
 88 | 			return array();
 89 | 	}
 90 | 	
 91 | 	public static function set_root_path($path)
 92 | 	{
 93 | 		self::$root_path = $path;
 94 | 	}
 95 | 	
 96 | 	public static function get_root_path()
 97 | 	{
 98 | 		return self::$root_path;
 99 | 	}
100 | }


--------------------------------------------------------------------------------
/Lean/Route2.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean;
  3 | 
  4 | class Route2
  5 | {
  6 | 	static private $instance;
  7 | 
  8 | 	public static function singleton()
  9 | 	{
 10 | 		if(!isset(self::$instance))	self::$instance = new self;
 11 | 
 12 | 		return self::$instance;
 13 | 	}
 14 | 	
 15 | 	private static $route_controller_default = 'Index';
 16 | 	
 17 | 	private static $route_module_default = 'main';
 18 | 	
 19 | 	private static $route_default = '';
 20 | 	
 21 | 	private static $routes_path = null;
 22 | 	
 23 | 	private static $routes = array();
 24 | 
 25 | 	
 26 | 	public function register($uri, $action)
 27 | 	{
 28 | 		$this->routes[ Request::ANY ][ $uri ] = $action;
 29 | 	}
 30 | 	
 31 | 	public function any($uri, $action)
 32 | 	{
 33 | 		$this->routes[ Request::ANY ][ $uri ] = $action;
 34 | 	}
 35 | 
 36 | 	public function get($uri, $action)
 37 | 	{
 38 | 		$this->routes[ Request::GET ][ $uri ] = $action;
 39 | 	}
 40 | 	
 41 | 	public function delete($uri, $action)
 42 | 	{
 43 | 		$this->routes[ Request::DELETE ][ $uri ] = $action;
 44 | 	}
 45 | 	
 46 | 	public function post($uri, $action)
 47 | 	{
 48 | 		$this->routes[ Request::POST ][ $uri ] = $action;
 49 | 	}
 50 | 	
 51 | 	public function put($uri, $action)
 52 | 	{
 53 | 		$this->routes[ Request::PUT ][ $uri ] = $action;
 54 | 	}
 55 | 	
 56 | 	
 57 | 	
 58 | 	/**
 59 | 	 * @example {
 60 | 	 * Route::alias('home', 'index');
 61 | 	 * Route::alias(array('home', 'main'), 'index');
 62 | 	 * }
 63 | 	 * 
 64 | 	 * @param (uri or array) $from
 65 | 	 * @param uri $to
 66 | 	 * @throws RouteException
 67 | 	 */
 68 | 	public function alias($from, $to)
 69 | 	{
 70 | 		if(!isset(self::$routes[$to])) throw new RouteException("route $to indefined");
 71 | 		
 72 | 		if (is_array($from)) {
 73 | 			
 74 | 			foreach ($from as $f) {
 75 | 				
 76 | 				self::set($f, self::$routes[$to]);
 77 | 				
 78 | 			}
 79 | 			
 80 | 		} else {
 81 | 			
 82 | 			self::set($from, self::$routes[$to]);
 83 | 			
 84 | 		}
 85 | 	}
 86 | 	
 87 | 	public static function set_routes_path($path)
 88 | 	{
 89 | 		self::$routes_path = $path;
 90 | 		
 91 | 		include_once $path;
 92 | 	}
 93 | 	
 94 | 	public static function get_routes_path()
 95 | 	{
 96 | 		return self::$routes_path;
 97 | 	}
 98 | 	
 99 | 	public static function get_routes()
100 | 	{
101 | 		return self::$routes;
102 | 	}
103 | 	
104 | 	public static function set_route_controller_default($controller)
105 | 	{
106 | 		self::$route_controller_default = $controller;
107 | 	}
108 | 	
109 | 	public static function get_route_controller_default()
110 | 	{
111 | 		return self::$route_controller_default;
112 | 	}
113 | 	
114 | 	public static function set_route_module_default($module)
115 | 	{
116 | 		self::$route_module_default = $module;
117 | 	}
118 | 	
119 | 	public static function get_route_module_default()
120 | 	{
121 | 		return self::$route_module_default;
122 | 	}
123 | 	
124 | 	public static function set_route_default($route)
125 | 	{
126 | 		self::$route_default = $route;
127 | 	}
128 | 	
129 | 	public static function get_route_default()
130 | 	{
131 | 		return self::$route_default;
132 | 	}
133 | 
134 | }
135 | 
136 | class RouteException extends \Exception { }


--------------------------------------------------------------------------------
/Lean/View.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean;
  3 | 
  4 | class View
  5 | {
  6 | 	private $view = array();
  7 | 	
  8 | 	public $lean;
  9 | 	
 10 | 	static private $instance;
 11 | 	
 12 | 	static private $extension_default = '.phtml'; 
 13 | 	
 14 | 	public static function singleton($classname)
 15 | 	{
 16 | 		if(!isset(self::$instance))	self::$instance = new self($classname);
 17 | 	
 18 | 		return self::$instance;
 19 | 	}
 20 | 	
 21 | 	public static function set_extension_default($extension)
 22 | 	{
 23 | 		self::$extension_default = $extension;
 24 | 	}
 25 | 
 26 | 	private function __construct($classname) 
 27 | 	{			
 28 | 		if ($lastnspos = strripos($classname, '\\')) 
 29 | 		{
 30 | 			$namespace = substr($classname, 0, $lastnspos);
 31 | 			
 32 | 			$classname = substr($classname, $lastnspos + 1);
 33 | 			
 34 | 			$this->view['directory'] = $this->view['class'] = strtolower(str_replace('Controller', '', $classname));
 35 | 			
 36 | 			$namespace = explode('\\', $namespace);
 37 | 			
 38 | 			$this->view['app'] = $namespace[0];
 39 | 			
 40 | 			$this->view['module'] = $namespace[1];
 41 | 		}		
 42 | 		
 43 | 		$this->lean = $this->app = App::singleton();
 44 | 	}
 45 | 		
 46 | 	public function renderPath($pathfile) {
 47 | 		include_once $pathfile;
 48 | 	}
 49 | 	
 50 | 	public function render($options = 'index') {
 51 | 		/**
 52 | 		 * render content page
 53 | 		*/
 54 | 		$this->temp = array();
 55 | 		$this->set_options_views('temp', $options);
 56 | 		$this->make('temp');
 57 | 		
 58 | 		return $this;
 59 | 	}
 60 | 	
 61 | 	public function set($name, $options = 'index')
 62 | 	{
 63 | 		$this->$name = array();
 64 | 		$this->set_options_views($name, $options);
 65 | 		return $this;
 66 | 	}
 67 | 	
 68 | 	private function set_options_views($var, $options)
 69 | 	{				
 70 | 		$this->{$var}['app'] = $this->view['app'];
 71 | 		$this->{$var}['module'] = $this->view['module'];
 72 | 		$this->{$var}['directory'] = $this->view['directory'];
 73 | 		$this->{$var}['extension'] = self::$extension_default;
 74 | 		
 75 | 		if(is_string($options)) 
 76 | 		{				
 77 | 			$options = array_reverse(explode('.', $options));
 78 | 			
 79 | 			$pos = array('page', 'directory', 'module', 'app');
 80 | 			
 81 | 			foreach ($options as $key => $option) 
 82 | 			{	
 83 | 				$this->{$var}[$pos[$key]] = $option;
 84 | 			}
 85 | 		}
 86 | 		elseif(is_array($options))
 87 | 		{
 88 | 			if (isset($options['page'])) {
 89 | 				$this->{$var}['page'] = $options['page'];
 90 | 			}
 91 | 			
 92 | 			if (isset($options['app'])) {
 93 | 				$this->{$var}['app'] = $options['app'];
 94 | 			}
 95 | 			
 96 | 			if (isset($options['module'])) {
 97 | 				$this->{$var}['module'] = $options['module'];
 98 | 			}
 99 | 			
100 | 			if (isset($options['directory'])) {
101 | 				$this->{$var}['directory'] = $options['directory'];
102 | 			}
103 | 			
104 | 			if (isset($options['extension'])) {
105 | 				$this->{$var}['extension'] = $options['extension'];
106 | 			}
107 | 		}
108 | 	}
109 | 			
110 | 	public function make($name) {
111 | 		include_once $this->{$name}['app'] . DIRECTORY_SEPARATOR . $this->{$name}['module'] . DIRECTORY_SEPARATOR . 'views' . DIRECTORY_SEPARATOR . $this->{$name}['directory'] . DIRECTORY_SEPARATOR . $this->{$name}['page'] . $this->{$name}['extension'];
112 | 	}
113 | 	
114 | 	public function redirect($url) {
115 | 		header('location:' . $url); die();
116 | 	}
117 | 		
118 | 	public function get_property($name = null)
119 | 	{		
120 | 		if(array_key_exists($name, $this->view)) 
121 | 		{
122 | 			return $this->view[$name];
123 | 		} 
124 | 		else 
125 | 		{
126 | 			return null;
127 | 		}
128 | 	}
129 | 	
130 | 	public function __get($var) { return Null::singleton(); }
131 | }


--------------------------------------------------------------------------------
/Lean/Launch.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean;
  3 | 
  4 | use Lean\Http\Request;
  5 | 
  6 | class Launch
  7 | {
  8 | 	private $action_method_to_launch;
  9 | 	
 10 | 	private $path_class_to_launch;
 11 | 	
 12 | 	static public function instance()
 13 | 	{
 14 | 		return new self;
 15 | 	}
 16 | 	
 17 | 	public function run()
 18 | 	{
 19 | 		$this->process();		
 20 | 	}
 21 | 	
 22 | 	private function dispache($module, $controller, $method, array $params = null)
 23 | 	{
 24 | 		if(empty($module)) {
 25 | 			$module = Route::get_route_module_default();
 26 | 		}
 27 | 		
 28 | 		if(empty($controller)) {
 29 | 			$controller = Route::get_route_controller_default();
 30 | 		}
 31 | 		
 32 | 		if(empty($method)) {
 33 | 			$method = 'index';
 34 | 		}
 35 | 		
 36 | 		$class = Config::get_application_path() . "\\" . Config::get_module_prefixe() . $module . "\\controllers\\" . $controller . "Controller";
 37 | 
 38 |         if ($params) {
 39 |             $num_param = 0;
 40 |             $set_params = rtrim(str_repeat('$params[$num_param++],', count($params)), ',');
 41 |         }
 42 |         else {
 43 |             $set_params = '';
 44 |         }
 45 | 
 46 |         eval($class.'::singleton()->'.$method.'('.$set_params.');');
 47 | 	}
 48 | 	
 49 | 	private function get_info()
 50 | 	{
 51 | 		/* verifica url com index.php */
 52 | 		preg_match('/(.*)\/index.php(.*)/', $_SERVER["PHP_SELF"], $matches);
 53 | 
 54 | 		/* relative uri base */
 55 | 		$relative_uri_base = $matches[1];
 56 | 
 57 | 		/* route path information */
 58 | 		$path_info = $matches[2];
 59 | 
 60 | 		$url = Request::singleton()->getUrl();
 61 | 
 62 | 		/* verifica url sem index.php */
 63 | 		if(!preg_match('/index.php/', $url->getPath()))	{
 64 | 			$path_info = str_replace($relative_uri_base, '', $url->getPath());
 65 | 		}
 66 | 		
 67 | 		/* define url root */
 68 | 		define(strtoupper(Config::get_root_path()), $relative_uri_base.'/');
 69 | 
 70 | 		$path_info = trim($path_info, '/');
 71 | 
 72 | 		return $path_info;
 73 | 	}
 74 | 	
 75 | 	private function process()
 76 | 	{		
 77 | 		
 78 | 		$info = self::get_info();		
 79 | 
 80 | 		/*
 81 | 		 * rotas
 82 | 		 */
 83 | 		if($routes = Route::get_routes())
 84 | 		{
 85 | 			if(array_key_exists($info, $routes))
 86 | 			{
 87 | 				$route = $routes[$info];
 88 | 				
 89 | 				if(is_object($route))
 90 | 				{
 91 | 					$route();
 92 | 				}
 93 | 				elseif(is_array($route))
 94 | 				{
 95 | 					$module = isset($route['module']) ? $route['module'] : NULL;
 96 | 					$controller = isset($route['controller']) ? $route['controller'] : NULL;
 97 | 					$method = isset($route['method']) ? $route['method'] : NULL;
 98 |                     $params = isset($route['params']) ? (array) $route['params'] : NULL;
 99 | 					
100 | 					$this->dispache($module, $controller, $method, $params);
101 | 
102 | 				}
103 | 
104 | 				return true;
105 | 			}
106 | 		}
107 | 		
108 | 		
109 | 		/*
110 | 		 * rota padrão caso info seja vazio 
111 | 		 */
112 | 		if(empty($info)) 
113 | 		{
114 | 			$route_default = Route::get_route_default();
115 | 			if(!empty($route_default)) $info = $route_default; 
116 | 		}
117 | 		
118 | 
119 | 		/*
120 | 		 * explode info
121 | 		 */
122 | 		if(isset($info)) 
123 | 		{
124 | 			$url_string =  explode('/', strtolower(trim($info, '/')));
125 | 			if($url_string[0] == '') $url_string = null;
126 | 		}
127 | 	
128 | 		
129 | 		/*
130 | 		 * valida e dispara método
131 | 		 */
132 | 		$module = isset($url_string[0]) ? $url_string[0] : null;
133 | 	
134 | 		$controller = isset($url_string[1]) ? (str_replace(' ', '', ucwords(str_replace('-', ' ', $url_string[1])))) : null;		
135 | 		
136 | 		$method = isset($url_string[2]) ? str_replace('-', '_', $url_string[2]) : null;
137 | 		
138 | 		$this->dispache($module, $controller, $method);
139 | 		
140 | 	}
141 | 	
142 | 	
143 | }


--------------------------------------------------------------------------------
/Lean/Format/Time.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean\Format;
  3 | 
  4 | class Time extends \Lean\Singleton
  5 | {
  6 | 	static private $instance;
  7 | 	
  8 | 	const FORMAT_HOUR_MINUTES = '%H:%M';
  9 | 	const FORMAT_HOUR_MINUTES_SECONDS = '%H:%M:%S';
 10 |     const FORMAT_HOUR = '%H';
 11 |     const FORMAT_MINUTES = '%M';
 12 |     const FORMAT_SECONDS = '%S';
 13 | 
 14 | 	public static function singleton() {
 15 | 		if(!isset(self::$instance))	self::$instance = new self;
 16 | 		return self::$instance;
 17 | 	}
 18 | 	
 19 | 	/**
 20 | 	 * Tratamento e Formatação de horas
 21 | 	 * Este método permite formatar horas maiores que 23:59:59
 22 | 	 * 
 23 | 	 * @example
 24 | 	 * echo format('12:10') // 12:10:00
 25 | 	 * echo format('122:10') // 122:10:00
 26 | 	 * echo format('12') // 12:00:00
 27 | 	 * echo format('12:60') // 12:59:00
 28 | 	 * echo format('12:99:99') // 12:59:59
 29 |      * echo format('1:1') // 01:01:00
 30 |      * echo format('5:30') // 05:30:00
 31 | 	 * 
 32 | 	 * @param string $hour Hora a ser formatada 00:00 ou 00:00:00
 33 | 	 * @param string $format Formato para conversão
 34 | 	 * @return string
 35 | 	 */
 36 | 	public static function format($hour, $format = self::FORMAT_HOUR_MINUTES_SECONDS)
 37 | 	{
 38 | 		/* tratamento de horas, minutos e segundos */
 39 | 		list ($h, $m, $s) = array_pad(explode(':', $hour), 3, '00');
 40 | 
 41 |         $h = str_pad((int) $h , 2, '0', STR_PAD_LEFT);
 42 |         $m = str_pad((int) $m , 2, '0', STR_PAD_LEFT);
 43 |         $s = str_pad((int) $s , 2, '0', STR_PAD_LEFT);
 44 | 
 45 |         if ($m > 59) $m = '59';
 46 |         if ($s > 59) $s = '59';
 47 | 
 48 | 		if ($format == self::FORMAT_HOUR_MINUTES)
 49 |             return "$h:$m";
 50 | 
 51 | 		if ($format == self::FORMAT_HOUR_MINUTES_SECONDS)
 52 |             return "$h:$m:$s";
 53 | 
 54 | 		return strftime($format, strtotime($hour));
 55 | 	}
 56 | 	
 57 | 	/**
 58 | 	 * Retorna hora atual no formato HH:MM:SS
 59 | 	 * @return string Hora no formato HH:MM:SS
 60 | 	 */
 61 | //	public static function now() {
 62 | //		return date('H:i:s');
 63 | //	}
 64 | 
 65 |     public static function now($format = self::FORMAT_HOUR_MINUTES_SECONDS) {
 66 |         return strftime($format);
 67 |     }
 68 | 
 69 | 	public static function time_to_seconds($time) {
 70 | 		$hours = substr($time, 0, -6);
 71 | 		$minutes = substr($time, -5, 2);
 72 | 		$seconds = substr($time, -2);
 73 | 
 74 | 		return $hours * 3600 + $minutes * 60 + $seconds;
 75 | 	}
 76 | 
 77 | 	public static function seconds_to_time($seconds) {
 78 | 		$hours = floor($seconds / 3600);
 79 | 		$minutes = floor($seconds % 3600 / 60);
 80 | 		$seconds = $seconds % 60;
 81 | 
 82 | 		return sprintf("%02d:%02d:%02d", $hours, $minutes, $seconds);
 83 | 	}
 84 | 
 85 | 	public static function sum($time1, $time2, $op = 'add')
 86 | 	{
 87 | 		$now = new \DateTime(Date::now(Date::FORMAT_DATE));
 88 | 		if ($op != 'add') $op == 'sub';
 89 | 	
 90 | 		$time1_slices = explode(':', $time1);
 91 | 		$time1_hour = isset($time1_slices[0]) ? (int) $time1_slices[0] : '00';
 92 | 		$time1_min	= isset($time1_slices[1]) ? (int) $time1_slices[1] : '00';
 93 | 		$time1_sec 	= isset($time1_slices[2]) ? (int) $time1_slices[2] : '00';
 94 | 	
 95 | 		$time2_slices = explode(':', $time2);
 96 | 		$time2_hour = isset($time2_slices[0]) ? (int) $time2_slices[0] : '00';
 97 | 		$time2_min 	= isset($time2_slices[1]) ? (int) $time2_slices[1] : '00';
 98 | 		$time2_sec 	= isset($time2_slices[2]) ? (int) $time2_slices[2] : '00';
 99 | 	
100 | 		$now->add(new \DateInterval("PT{$time1_hour}H{$time1_min}M{$time1_sec}S"));
101 | 		$now->{$op}(new \DateInterval("PT{$time2_hour}H{$time2_min}M{$time2_sec}S"));
102 | 		$time = $now->format('H:i:s');
103 | 	
104 | 		return $time;
105 | 	
106 | 	}
107 | 	
108 | 	public static function subtract($time1, $time2) {
109 | 		return self::sum($time1, $time2, 'sub');
110 | 	}
111 | }


--------------------------------------------------------------------------------
/Lean/Format/Date.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean\Format;
  3 | 
  4 | class Date extends \Lean\Singleton
  5 | {
  6 | 	static private $instance;
  7 | 
  8 | 	/**
  9 | 	 * @var string Formatos para conversão
 10 | 	 */
 11 | 	const FORMAT_DATE = '%Y-%m-%d';
 12 | 	const FORMAT_DATE_TIME = '%Y-%m-%d %H:%M:%S';
 13 | 	const FORMAT_DATE_USER = '%d/%m/%Y';
 14 | 	const FORMAT_DATE_TIME_USER = '%d/%m/%Y %H:%M:%S';
 15 | 	const FORMAT_DATE_LONG = '%A, %d de %B de %Y';
 16 | 	const FORMAT_DAY = '%d';
 17 | 	const FORMAT_MONTH = '%m';
 18 | 	const FORMAT_YEAR = '%Y';
 19 | 	const FORMAT_TIME = '%H:%M:%S';
 20 | 	const FORMAT_TIME_SHORT = '%H:%M';
 21 | 	const FORMAT_DATE_TIME_HASH = '%Y%m%d_%H%M%S';
 22 | 
 23 | 	public static function singleton()
 24 | 	{
 25 | 		if(!isset(self::$instance))	self::$instance = new self();
 26 | 
 27 | 		return self::$instance;
 28 | 	}
 29 | 
 30 | 	public static function format($date, $format)
 31 | 	{
 32 | 		return strftime($format, strtotime($date));
 33 | 	}
 34 | 	
 35 | 	public static function format_to_human($date, $format = null)
 36 | 	{				
 37 | 		if ( substr($date, 0, 10) == '0000-00-00' || empty($date)) return '';
 38 | 
 39 | 		if (!is_null($format)) return strftime($format, strtotime($date));
 40 | 
 41 | 		if (strlen($date) <= 10)
 42 | 			return strftime(self::FORMAT_DATE_USER, strtotime($date));
 43 | 		else
 44 | 			return strftime(self::FORMAT_DATE_TIME_USER, strtotime($date));
 45 | 	}
 46 | 
 47 | 	public static function format_to_machine($date, $format = null)
 48 | 	{
 49 | 		if (self::validateFormatDatabase($date)) return $date;
 50 | 
 51 | 		if ($date == '' || empty($date)) return '0000-00-00';
 52 | 		
 53 | 		$date_valid_user = self::validateUser($date);
 54 | 
 55 | 		if ($date_valid_user)
 56 | 		{
 57 | 			$slices = explode('-', $date_valid_user);
 58 | 			
 59 | 			if (!is_null($format)) 	return strftime($format, mktime(0,0,0, $slices[1],$slices[0], $slices[2]));
 60 | 			
 61 | 			return strftime(self::FORMAT_DATE, mktime(0,0,0, $slices[1],$slices[0], $slices[2]));
 62 |  		}
 63 |  		else
 64 |  		{
 65 |  			if (!is_null($format)) return strftime($format, strtotime($date));
 66 |  			
 67 |  			return strftime(self::FORMAT_DATE, strtotime($date));
 68 |  		}
 69 | 	}
 70 | 
 71 | 	public static function now($format = self::FORMAT_DATE_TIME)
 72 | 	{
 73 | 		return strftime($format);
 74 | 	}
 75 | 
 76 | 	/**
 77 | 	 * @deprecated
 78 | 	 * @see Date::validate_format_human
 79 | 	 */
 80 | 	public static function validateUser($date)
 81 | 	{
 82 | 		if (empty($date)) return false;
 83 | 
 84 | 		$date = str_replace('/', '-', $date);
 85 | 		$slices = explode('-', $date);
 86 | 
 87 | 		if (!isset($slices[0])) return false;
 88 | 		if (!isset($slices[1])) return false;
 89 | 		if (!isset($slices[2])) return false;
 90 | 
 91 | 		if(checkdate($slices[1], $slices[0], $slices[2]))
 92 | 		{
 93 | 			return $date;
 94 | 		}
 95 | 		else
 96 | 		{
 97 | 			return false;
 98 | 		}
 99 | 	}
100 | 	
101 | 	public static function validate_format_human($date)
102 | 	{
103 | 		$date = str_replace('/', '-', $date);
104 | 		
105 | 		if(!preg_match('/^([0-9]{2})-([0-9]{2})-([0-9]{2,4})/', $date, $matches)) return false;
106 | 		
107 | 		if(!isset($matches[1]) || !isset($matches[2]) || !isset($matches[3]) ) return false;
108 | 		
109 | 		if(!checkdate($matches[2], $matches[1], $matches[3])) return false;
110 | 			
111 | 		return true;
112 | 	}
113 | 	
114 | 	public static function validate_format_machine($date)
115 | 	{
116 | 		if(!preg_match('/^([0-9]{4})-([0-9]{2})-([0-9]{2})/', $date, $matches)) return false;
117 | 	
118 | 		if(!isset($matches[1]) || !isset($matches[2]) || !isset($matches[3]) ) return false;
119 | 	
120 | 		if(!checkdate($matches[2], $matches[3], $matches[1])) return false;
121 | 			
122 | 		return true;
123 | 	}
124 | 
125 | 	/**
126 | 	 * @deprecated
127 | 	 * @see Date::validate_format_machine
128 | 	 */
129 | 	public static function validateFormatDatabase($date)
130 | 	{
131 | 		return preg_match('/^[0-9]{4}-[0-9]{2}-[0-9]{2}/', $date);
132 | 	}
133 | 	
134 | 	public static function validate($date)
135 | 	{
136 | 		if(self::validate_format_machine($date)) return true;
137 | 		
138 | 		if(self::validate_format_human($date)) return true;
139 | 		
140 | 		return false;
141 | 	}
142 | }


--------------------------------------------------------------------------------
/Lean/Http/Request.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Lean\Http;
  3 | 
  4 | use Lean\Singleton;
  5 | 
  6 | class Request extends Singleton 
  7 | {
  8 | 	public function __construct($http_method = null) {
  9 | 		if (!$http_method) $http_method = $_REQUEST;
 10 | 		foreach ($http_method as $key => $value) {
 11 | 			$this->{$key} = $value;
 12 | 		}
 13 | 	}
 14 | 
 15 | 	/**
 16 | 	 * @return self
 17 | 	 */
 18 | 	public static function singleton() {
 19 | 		return parent::singleton();
 20 | 	}
 21 | 
 22 | 	public function decode($to = 'ISO-8859-1', $from = 'UTF-8') {
 23 | 		foreach ($this as $key => $value) {
 24 | 			$this->$key = mb_convert_encoding($value, $to, $from);
 25 | 		}
 26 | 		
 27 | 		return $this;
 28 | 	}
 29 | 
 30 |     /**
 31 |      * @return Request
 32 |      */
 33 |     public function delete() {
 34 |         return Post::singleton();
 35 |     }
 36 | 
 37 |     /**
 38 |      * @return Request
 39 |      */
 40 |     public function files() {
 41 |         return Files::singleton();
 42 |     }
 43 | 
 44 |     /**
 45 |      * @return Request
 46 |      */
 47 | 	public function get() {
 48 | 		return Get::singleton();
 49 | 	}
 50 | 
 51 |     /**
 52 |      * @return Request
 53 |      */
 54 |     public function head() {
 55 |         return Post::singleton();
 56 |     }
 57 | 
 58 |     /**
 59 |      * @return Request
 60 |      */
 61 |     public function post() {
 62 |         return Post::singleton();
 63 |     }
 64 | 
 65 |     /**
 66 |      * @return Request
 67 |      */
 68 | 	public function put() {
 69 | 		return Post::singleton();
 70 | 	}
 71 | 
 72 |     /**
 73 |      * @return Method
 74 |      */
 75 | 	public function getMethod() {
 76 | 		return Method::singleton();
 77 | 	}
 78 | 
 79 | 	/**
 80 | 	 * @return Url
 81 | 	 */
 82 | 	public function getUrl() {
 83 | 		return Url::singleton();
 84 | 	}
 85 | }
 86 | 
 87 | /**
 88 |  * Class Post
 89 |  * @package Lean\Http
 90 |  */
 91 | class Post extends Request
 92 | {
 93 | 	public function __construct() {
 94 | 		parent::__construct($_POST);
 95 | 	}
 96 | }
 97 | 
 98 | /**
 99 |  * Class Files
100 |  * @package Lean\Http
101 |  */
102 | class Files extends Request
103 | {
104 | 	public function __construct() {
105 | 		parent::__construct($_FILES);
106 | 	}
107 | }
108 | 
109 | /**
110 |  * Class Get
111 |  * @package Lean\Http
112 |  */
113 | class Get extends Request
114 | {
115 | 	public function __construct() {
116 | 		parent::__construct($_GET);
117 | 	}
118 | }
119 | 
120 | /**
121 |  * Class Url
122 |  * @package Lean\Http
123 |  */
124 | class Url extends Singleton {
125 | 
126 | 	private $uri_parsed;
127 | 
128 | 	/**
129 | 	 * @return self
130 | 	 */
131 | 	public static function singleton() {
132 | 		return parent::singleton();
133 | 	}
134 | 
135 | 	public function __construct() {
136 | 		$this->uri_parsed = parse_url($this->getUri());
137 | 	}
138 | 
139 | 	public function getHash() {
140 | 		return isset($this->uri_parsed['fragment']) ? $this->uri_parsed['fragment'] : null;
141 | 	}
142 | 
143 | 	public function getHost() {
144 | 		return $_SERVER['SERVER_NAME'];
145 | 	}
146 | 
147 | 	public function getHostWithPort() {
148 | 		return $this->getHost() . ':' . $this->getPort();
149 | 	}
150 | 
151 | 	public function getPath() {
152 | 		return isset($this->uri_parsed['path']) ? $this->uri_parsed['path'] : null;
153 | 	}
154 | 
155 | 	public function getPort() {
156 | 		return $_SERVER['SERVER_PORT'];
157 | 	}
158 | 
159 | 	public function getProtocol() {
160 | 		return isset($this->uri_parsed['scheme']) ? $this->uri_parsed['scheme'] : null;
161 | 	}
162 | 
163 | 	public function getQuery() {
164 | 		return isset($this->uri_parsed['query']) ? $this->uri_parsed['query'] : null;
165 | 	}
166 | 
167 | 	public function getUri() {
168 |         $url = strtok($_SERVER['REQUEST_URI'], '?');
169 | 
170 |         if (empty($url)) {
171 |             return $_SERVER['REQUEST_URI'];
172 |         } else {
173 |             return $url .'?'. urlencode($_SERVER['QUERY_STRING']);
174 |         }
175 | 	}
176 | 
177 | 	public function getUrl() {
178 | 		return $this->getHost() . $this->getUri();
179 | 	}
180 | 
181 | 	public function __toString() {
182 | 		return $this->getUrl();
183 | 	}
184 | }
185 | 
186 | 
187 | /**
188 |  * Class Method
189 |  * @package Lean\Http
190 |  */
191 | class Method extends Singleton {
192 | 
193 | 	const METHOD_DELETE = 'DELETE';
194 | 	const METHOD_GET = 'GET';
195 | 	const METHOD_HEAD = 'HEAD';
196 | 	const METHOD_OPTIONS = 'OPTIONS';
197 | 	const METHOD_PATCH = 'PATCH';
198 | 	const METHOD_POST = 'POST';
199 | 	const METHOD_PUT = 'PUT';
200 | 
201 | 	/**
202 | 	 * @return self
203 | 	 */
204 | 	public static function singleton() {
205 | 		return parent::singleton();
206 | 	}
207 | 
208 | 	public function getMethod() {
209 | 		return $_SERVER['REQUEST_METHOD'];
210 | 	}
211 | 
212 | 	public function isDelete() {
213 | 		return $this->getMethod() == self::METHOD_DELETE;
214 | 	}
215 | 
216 | 	public function isGet() {
217 | 		return $this->getMethod() == self::METHOD_GET;
218 | 	}
219 | 
220 | 	public function isHead() {
221 | 		return $this->getMethod() == self::METHOD_HEAD;
222 | 	}
223 | 
224 | 	public function isOptions() {
225 | 		return $this->getMethod() == self::METHOD_OPTIONS;
226 | 	}
227 | 
228 | 	public function isPatch() {
229 | 		return $this->getMethod() == self::METHOD_PATCH;
230 | 	}
231 | 
232 | 	public function isPost() {
233 | 		return $this->getMethod() == self::METHOD_POST;
234 | 	}
235 | 
236 | 	public function isPut() {
237 | 		return $this->getMethod() == self::METHOD_PUT;
238 | 	}
239 | 
240 | 	public function __toString() {
241 | 		return $this->getMethod();
242 | 	}
243 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Lean PHP Framework
  2 | 
  3 | Lean PHP Framework is a micro framework PHP (~40KB). Modern frameworks are powerfull but so much complicated,
  4 | the mostly of resources you never gonna use, some functionality sounds good but if you don't really need it's a
  5 | only waste of time.
  6 | With Lean you can construct fast e lightweight softwares, with follows resources:
  7 | 
  8 | * Structure MVC, REST or both;
  9 | * Requests;
 10 | * Routes (automatic or custom);
 11 | * Namespaces;
 12 | * Class autoload;
 13 | * PHP code hidden;
 14 | * Basic template engine;
 15 | * Date and Time manipulation;
 16 | * Easy configuration;
 17 | 
 18 | ### Requirement
 19 | 
 20 | PHP 5.3+
 21 | 
 22 | ### Basic structure
 23 | 
 24 | ```php
 25 | -- rootdir
 26 |     -- app
 27 |         -- main (module)
 28 |             -- controllers
 29 |                 -- HomeController.php
 30 |             -- models
 31 |             -- views
 32 |                 -- home
 33 |                     -- index.phtml
 34 |         -- Bootstrap.php
 35 |         -- Routes.php
 36 |     -- public_html
 37 |         -- css
 38 |         -- js
 39 |         -- img
 40 |         -- index.php
 41 |         -- .htaccess
 42 |     -- vendor
 43 |         -- composer
 44 |         -- lean
 45 |         -- autoload.php
 46 | ```
 47 | 
 48 | Create into your rootdir teh follows directories:
 49 | 
 50 | - `app`: You will write all your application php into app directory (controllers, models, views and configs), this way your application not stay exposed.
 51 | 
 52 | - `public_html`: Into public_html directory we have only **index.php** as file .php. You can put all yours public files, like css, javascripts, images, fonts, etc.
 53 | 
 54 | - `vendor`: Composer will create it and copy our lib to lean directory.
 55 | 
 56 | ## Getting started
 57 | 
 58 | ### Instalation
 59 | 
 60 | Install via [Composer](http://getcomposer.org "Composer")
 61 | 
 62 | ```bash
 63 | composer require lean/lean
 64 | ```
 65 | 
 66 | ### Easy configuration
 67 | 
 68 | create file `index.php` into **public_html** directory
 69 | 
 70 | > Into index.php we have only one line, all of rest application php keep safe into app directory.
 71 | 
 72 | ```php
 73 | <?php require_once '../app/Bootstrap.php'; ?>
 74 |  ```
 75 | 
 76 | create file `.htaccess` into **public_html** directory to custom urls works
 77 | 
 78 | > Don't forget enable mod_rewrite on apache
 79 | 
 80 | ```bash
 81 | RewriteEngine On
 82 | RewriteCond %{REQUEST_FILENAME} -s [OR]
 83 | RewriteCond %{REQUEST_FILENAME} -l [OR]
 84 | RewriteCond %{REQUEST_FILENAME} -d
 85 | RewriteRule ^.*$ - [NC,L]
 86 | RewriteRule ^.*$ index.php [NC,L]
 87 | ```
 88 | 
 89 | Create file `Bootstrap.php` into **app** directory
 90 | 
 91 | ```php
 92 | <?php
 93 | require_once '../vendor/autoload.php';
 94 | 
 95 | /**
 96 |  * errors - use E_ALL only in development
 97 |  */
 98 | error_reporting(E_ALL);
 99 | 
100 | /**
101 |  * include path
102 |  */
103 | set_include_path(
104 | 	PATH_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 
105 | 	PATH_SEPARATOR . get_include_path());
106 | 
107 | /** 
108 |  * locale e zone
109 |  * Lean has some great Date and Hour classes, so keep it configured to use them
110 |  */
111 | date_default_timezone_set('America/Sao_Paulo');
112 | setlocale(LC_ALL, 'pt_BR', 'pt_BR.iso-8859-1', 'pt_BR.utf-8', 'portuguese');
113 | 
114 | /**
115 |  * init lean framework
116 |  */
117 | Lean\Launch::instance()->run();
118 | ```
119 | 
120 | Well done! It's all configuration necessary to run like a pro.
121 | 
122 | 
123 | ### Hello world
124 | 
125 | Regardless of whether their application is rest or not, I think is a good ideia keep your access logic always into controllers,
126 | into Routes.php you keep only routes ;)
127 | 
128 | ```php
129 | <?php
130 | namespace app\main\controllers;
131 | 
132 | class IndexController extends \Lean\App
133 | {
134 | 	public function index() {
135 | 		echo 'Hello World!';
136 | 	}
137 | }
138 | ```
139 | 
140 | It's work, access in your browser
141 | http://localhost/rootdir/public_html
142 | 
143 | > Remember, in your site type only **www.your-domain.com**, everything else php is hidden.
144 | 
145 | 
146 | ## Automatic route controller
147 | 
148 | http://localhost/rootdir/public_html/`$1`/`$2`/`$3`
149 | 
150 | * `$1` : Module - if not informed, use main module (main directory)
151 | * `$2` : Controller - if not informed, instance indexController class
152 | * `$3` : Method - if not informed, call index method
153 | 
154 | ```php
155 | <?php
156 | namespace app\main\controllers;
157 | 
158 | class ProductController extends \Lean\App
159 | {
160 |     public function index() {
161 |         echo 'About Product'
162 |     }
163 | 
164 | 	public function festures_list() {
165 | 		echo 'Product list';
166 | 	}
167 | 
168 | 	public function buy_action() {
169 | 	    echo 'Processing your order...'
170 | 	}
171 | }
172 | ```
173 | 
174 | To ProductController example, the result is:
175 | 
176 | > uri `/main/product` result is **About Product!**   
177 | > uri `/main/product/index` result is **About Product!**  
178 | > uri `/main/product/features-list` result is **Product list!**  
179 | > uri `/main/product/features_list` result is **Product list!**  
180 | > uri `/main/product/buy` result is **Processing your order...**  
181 | > uri `/main/product/buy-action` result is **Processing your order...**  
182 | > uri `/main/product/buy_action` result is **Processing your order...**  
183 | 
184 | To IndexController example, the result is:
185 | 
186 | > uri `/` result is **Hello World!**  
187 | > uri `/main` result is **Hello World!**  
188 | > uri `/main/index` result is **Hello World!**  
189 | > uri `/main/index/index` result is **Hello World!**  
190 | 
191 | 
192 | ## Custom routes
193 | 
194 | ### Config routes file
195 | 
196 | In `app/Bootstrap.php` add file routes before launch Lean
197 | 
198 | ```php
199 | ...
200 | 
201 | /**
202 |  * routes file
203 |  */
204 | Lean\Route::set_routes_path('app/Routes.php');
205 | 
206 | /**
207 |  * init lean framework
208 |  */
209 | Lean\Launch::instance()->run();
210 | ```
211 | 
212 | ### Basic route
213 | 
214 | create file `Routes.php` into **app** directory
215 | 
216 | ```php
217 | <?php
218 | use Lean\Route;
219 | 
220 | Route::set('foo/bar', function() {
221 | 	echo 'Hi';
222 | });
223 | ```
224 | 
225 | > Url: http://your-site.com/foo/bar // result is 'Hi'
226 | 
227 | ### Route to method in controller
228 | 
229 | ```php
230 | <?php
231 | use Lean\Route;
232 | 
233 | Route::set('product', array(
234 | 	'controller' => 'product',
235 | ));
236 | 
237 | Route::set('resources', array(
238 | 	'controller' => 'product',
239 | 	'method' => 'resources_list'
240 | ));
241 | 
242 | Route::set('learn-more-about-product', array(
243 | 	'controller' => 'product',
244 | 	'method' => 'resources_list'
245 | ));
246 | ```
247 | 
248 | > Url `http://your-site.com/product` result is **About Product**  
249 | > Url `http://your-site.com/resources` result is **Product List**  
250 | > Url `http://your-site.com/learn-more-about-product` result is **Product List**  
251 | 
252 | ### Route to different module
253 | 
254 | ```php
255 | <?php
256 | use Lean\Route;
257 | 
258 | Route::set('checkout', array(
259 |     'module' => 'api'
260 | 	'controller' => 'payment',
261 | ));
262 | ```
263 | 
264 | ### Simple route alias
265 | 
266 | ```php
267 | Route::alias('old-page-about-product', 'product');
268 | ```
269 | 
270 | ### Multiple route alias
271 | 
272 | ```php
273 | Route::alias(array('old-page-about-product', 'foo', 'bar'), 'product');
274 | ```
275 | 
276 | ## Request object
277 | 
278 | Recovery request data in controllers
279 | 
280 | ```php
281 | <?php
282 | namespace app\main\controllers;
283 | 
284 | class ProductController extends \Lean\App
285 | {
286 | 	public function index()
287 | 	{		
288 | 	    ...
289 | 	    
290 | 		/**
291 | 		 * get all methods - same of variable $_REQUEST
292 | 		 */
293 | 		echo $this->request->name;
294 | 		echo $this->request->last_name;
295 | 		
296 | 		/**
297 | 		 * get only method post - same of variable $_POST
298 | 		 */
299 | 		echo $this->request()->post()->name;
300 | 
301 | 		/**
302 |          * get only method post - same of variable $_POST
303 |          */
304 | 		echo $this->request()->get()->name;
305 | 
306 | 		/**
307 |          * get only method file - same of variable $_FILE
308 |          */	 
309 | 		 $request = $this->request()->file()->name;		
310 | 		 
311 | 		 /**
312 | 		  * you can too instance request object
313 | 		  */
314 | 		 $request = new \Lean\Http\Request();
315 | 		 $request->name
316 | 		 
317 | 		 ...
318 | 	}
319 | }
320 | ```
321 | 
322 | ## Using Views
323 | 
324 | In views directory, you must create `product` and `layout` subdirectories with `.phtml` files.
325 | 
326 | ```php
327 | ...
328 |     -- controllers
329 |         -- ProductController.php
330 |     -- models
331 |     -- views
332 |         -- product
333 |             -- index.phtml
334 |             -- edit.phtml
335 |         -- layout
336 |             -- header.phtml
337 |             -- footer.phtml
338 |             -- template.html
339 | ...
340 | ```
341 | 
342 | Create `template.phtml` in layout directory, you can include header and footer parts here
343 | 
344 | ```html
345 | <html>
346 | <head>
347 | 	<title>My new app</title>
348 | </head>
349 | <body>
350 | 
351 |     <!-- include header.phtml from layout directory -->
352 | 	<? $this->app->view->render('layout.header') ?>
353 | 
354 | 	<div id="container">
355 | 		<!-- include page setted in content variable via ProductController -->
356 | 		<? $this->app->view->make('content') ?>
357 | 	</div>
358 | 	
359 | 	<!-- include footer.phtml from layout directory
360 | 	<? $this->app->view->render('layout.footer') ?>
361 | 	
362 | </body>
363 | </html>
364 | ```
365 | 
366 | Rendering yours views
367 | 
368 | ```php
369 | <?php
370 | namespace app\main\controllers;
371 | 
372 | class ProductController extends \Lean\App
373 | {
374 | 	public function index()
375 | 	{	
376 | 		/**
377 | 		 * set which page will rendered by "content" variable in "template.html"
378 | 		 * by default, if informed only "index" will rendered .phtml file into product directory
379 | 		 */
380 | 		$this->view()->set('content', 'index');
381 | 		
382 | 		/*
383 | 		 * render template
384 | 		 */
385 | 		$this->view()->render('layout.template');
386 | 	}
387 | 	
388 | 	public function edit()
389 | 	{	
390 | 		/**
391 | 		 * this example will rendered "/product/edit.phtml" file
392 | 		 */
393 | 		$this->view()->set('content', 'edit');
394 | 		
395 | 		/*
396 |          * render template
397 |          */
398 | 		$this->view()->render('layout.template');
399 | 	}
400 | }
401 | ```
402 | 
403 | ## Date
404 | 
405 | ### Available date formats
406 | 
407 | ```php
408 | Date::FORMAT_DATE = 'YYYY-mm-dd';
409 | Date::FORMAT_DATE_TIME = 'YYYY-mm-dd HH:MM:SS';
410 | Date::FORMAT_DATE_USER = 'dd/mm/YYYY';
411 | Date::FORMAT_DATE_TIME_USER = 'dd/mm/YYYY HH:MM:SS';
412 | Date::FORMAT_DATE_LONG = 'Sexta-feira, 30 de janeiro de 2015';
413 | Date::FORMAT_DAY = 'dd';
414 | Date::FORMAT_MONTH = 'mm';
415 | Date::FORMAT_YEAR = 'YY';
416 | Date::FORMAT_TIME = 'HH:MM:SS';
417 | Date::FORMAT_TIME_SHORT = 'HH:MM';
418 | Date::FORMAT_DATE_TIME_HASH = 'YYYYmmdd_HHMMSS';
419 | ```
420 | 
421 | * `YYYY` : Year 4 digits  
422 | * `mm` : Month 2 digits  
423 | * `dd` : Day 2 digits  
424 | * `HH` : Hours 2 digits  
425 | * `MM` : Minutes 2 digits  
426 | * `SS` : Seconds 2 digits  
427 | 
428 | ### Now
429 | 
430 | Print today date
431 | 
432 | ```php
433 | use Lean\Format\Date as Date;
434 | 
435 | echo Date::now() // "YYYY-mm-dd HH:MM:SS" 
436 | echo Date::now(Date::FORMAT_DATE_USER) // "dd/mm/YYYY"
437 | echo Date::now(Date::FORMAT_TIME) // "HH:MM:SS"
438 | ```
439 | 
440 | ### Format date
441 | 
442 | Format using constants date
443 | 
444 | ```php
445 | echo Date:format('2015-01-30 10:59:59', Date::FORMAT_DATE) // 2015-01-30
446 | echo Date:format('2015-01-30 10:59:59', Date::FORMAT_DATE_TIME) // 2015-01-30 10:59:59 (nothing change)
447 | echo Date:format('2015-01-30 10:59:59', Date::FORMAT_DATE_USER) // 30/01/2015
448 | echo Date:format('2015-01-30 10:59:59', Date::FORMAT_DATE_TIME_USER) // 30/01/2015 10:59:59
449 | echo Date:format('2015-01-30 10:59:59', Date::FORMAT_TIME_SHORT) // 10:59
450 | ```
451 | 
452 | Format to users
453 | 
454 | ```php
455 | echo Date:format_to_human('2015-01-30 10:59:59') // 30/01/30 10:59:59
456 | echo Date:format_to_human('2015-01-30') // 30/01/30
457 | echo Date:format_to_human('30/01/2015 10:59:59') // 30/01/30 10:59:59 (nothing change)
458 | echo Date:format_to_human('30/01/2015') // 30/01/30 (nothing change)
459 | echo Date:format_to_human('30/01/2015 10:59:59', Date::FORMAT_DATE_USER) // 30/01/30
460 | echo Date:format_to_human('2015-01-30 10:59:59', Date::FORMAT_DATE_USER) // 30/01/30
461 | ```
462 | 
463 | Format to datebase
464 | 
465 | ```php
466 | echo Date:format_to_machine('2015-01-30 10:59:59') // 2015-01-30 10:59:59 (nothing change)
467 | echo Date:format_to_machine('2015-01-30') // 2015-01-30 (nothing change)
468 | echo Date:format_to_machine('30/01/2015 10:59:59') // 2015-01-30 10:59:59
469 | echo Date:format_to_machine('30/01/2015') // 2015-01-30
470 | echo Date:format_to_machine('30/01/2015 10:59:59', Date::FORMAT_DATE) // 2015-01-30
471 | echo Date:format_to_machine('2015-01-30 10:59:59', Date::FORMAT_DATE) // 2015-01-30
472 | ```
473 | 
474 | ### Validating date
475 | 
476 | Validate date format
477 | 
478 | ```php
479 | echo Date::validate('01/01/2015'); // true
480 | echo Date::validate('01/01/2015 12:10:00'); // true
481 | echo Date::validate('2015-01-01'); // true
482 | echo Date::validate('2015-01-01 12:10:00'); // true
483 | echo Date::validate('201-501-01'); // false
484 | echo Date::validate('foo'); // false
485 | ```
486 | 
487 | Validate especific date user format (00/00/0000 00:00:00)
488 | 
489 | ```php
490 | echo Date::validate_format_human('01/01/2015'); // true
491 | echo Date::validate_format_human('01/01/2015 12:10:00'); // true
492 | echo Date::validate_format_human('2015-01-01'); // false
493 | echo Date::validate_format_human('2015-01-01 12:10:00'); // false
494 | echo Date::validate_format_human('201-501-01'); // false
495 | echo Date::validate_format_human('foo'); // false
496 | ```
497 | 
498 | Validate especific date datebase format (0000-00-00 00:00:00)
499 | 
500 | ```php
501 | echo Date::validate_format_machine('01/01/2015'); // false
502 | echo Date::validate_format_machine('01/01/2015 12:10:00'); // false
503 | echo Date::validate_format_machine('2015-01-01'); // true
504 | echo Date::validate_format_machine('2015-01-01 12:10:00'); // true
505 | echo Date::validate_format_machine('201-501-01'); // false
506 | echo Date::validate_format_machine('foo'); // false
507 | ```
508 | 
509 | ## Time
510 | 
511 | ### Available time formats
512 | 
513 | ```php
514 | Time::FORMAT_HOUR_MINUTES = 'HH:MM';
515 | Time::FORMAT_HOUR_MINUTES_SECONDS = 'HH:MM:SS';
516 | Time::FORMAT_HOUR = 'HH';
517 | Time::FORMAT_MINUTES = 'MM';
518 | Time::FORMAT_SECONDS = 'SS';
519 | ```
520 | 
521 | * `HH` : Hours 2 digits  
522 | * `MM` : Minutes 2 digits  
523 | * `SS` : Seconds 2 digits
524 | 
525 | ### Now
526 | 
527 | Print time at moment
528 | 
529 | ```php
530 | use Lean\Format\Time as Time;
531 | 
532 | echo Time::now() // "HH:MM:SS" 
533 | echo Time::now(Time::FORMAT_HOUR_MINUTES) // "HH:MM"
534 | echo Time::now(Time::FORMAT_HOUR) // "HH"
535 | ```
536 | 
537 | ### Format time
538 | 
539 | Format time default
540 | 
541 | ```php
542 | echo Time::format('12:10') // 12:10:00
543 | echo Time::format('122:10') // 122:10:00
544 | echo Time::format('12') // 12:00:00
545 | echo Time::format('12:60') // 12:59:00
546 | echo Time::format('12:99:99') // 12:59:59
547 | echo Time::format('1:1') // 01:01:00
548 | echo Time::format('5:30') // 05:30:00
549 | ```
550 | 
551 | Format using constants time
552 | 
553 | ```php
554 | echo Time::format('12:10', Time::FORMAT_HOUR_MINUTES_SECONDS) // 12:10:00
555 | echo Time::format('12:10:5', Time::FORMAT_HOUR_MINUTES_SECONDS) // 12:10:05
556 | echo Time::format('12', Time::FORMAT_HOUR_MINUTES_SECONDS) // 12:00:00
557 | 
558 | echo Time::format('12:10:15', Time::FORMAT_HOUR_MINUTES) // 12:10
559 | echo Time::format('12', Time::FORMAT_HOUR_MINUTES) // 12:00
560 | echo Time::format('2:10:15', Time::FORMAT_HOUR_MINUTES) // 02:10
561 | ```
562 | 
563 | ### Converter time
564 | 
565 | Convert time to seconds
566 | 
567 | ```php
568 | echo Time::time_to_seconds('01:30:00') // 5400
569 | echo Time::time_to_seconds('01:15:00') // 4500
570 | echo Time::time_to_seconds('00:01:15') // 75
571 | echo Time::time_to_seconds('48:00:00') // 172800
572 | ```
573 | 
574 | Convert seconds to time
575 | 
576 | ```php
577 | echo Time::seconds_to_time('5400') // 01:30:00
578 | echo Time::seconds_to_time('4500') // 01:15:00 
579 | echo Time::seconds_to_time('75') // 00:01:15
580 | echo Time::seconds_to_time('172800') // 48:00:00
581 | ```
582 | 
583 | ### Calculate time
584 | 
585 | Sum time
586 | 
587 | ```php
588 | echo Time::sum('01:15:00', '02:30:05'); // 03:45:05
589 | echo Time::sum('12:30:00', '07:00:00'); // 19:30:00
590 | echo Time::sum('12:30:00', '12:00:00'); // 00:30:00
591 | ```
592 | 
593 | Subtract time
594 | 
595 | ```php
596 | echo Time::subtract('02:30:05', '01:15:00'); // 01:15:05
597 | echo Time::subtract('12:30:00', '07:00:00'); // 05:30:00
598 | echo Time::subtract('12:30:00', '13:00:00'); // 23:30:00
599 | ```
600 | 
601 | ## Author
602 | 
603 | Created by [Dyorg Almeida](http://linkedin.com/in/dyorgalmeida), a full-stack web developer and PHP expert ([Zend Certified Engineer](http://www.zend.com/en/yellow-pages/ZEND020495)). 
604 | Today Dyorg is founder and CTO at [Rabbiit](http://rabbiit.com), a brazilian startup that develops a simple time tracking software.  
605 | 
606 | http://rabbiit.com - Sign up for free  (available only in portuguese for now)
607 | 
608 | ## License
609 | 
610 | The Lean PHP framework is released under MIT public license.  
611 | http://www.opensource.org/licenses/MIT  
612 | Copyright (c) 2015
613 | 


--------------------------------------------------------------------------------