├── .env.sample
├── .gitignore
├── LICENSE
├── README.md
├── app
    └── index.php
├── bootstrap
    ├── constants.php
    ├── environment.php
    ├── error.php
    ├── function.php
    └── index.php
├── composer.json
├── docker-compose.yml.sample
├── essentials
    ├── Base64.php
    ├── Encode.php
    ├── File.php
    ├── Hash.php
    ├── Http.php
    ├── Proxy.php
    ├── Regex.php
    ├── Text.php
    ├── Url.php
    ├── Utils
    │   └── Instance.php
    └── ePHP.php
└── public_html
    ├── .htaccess
    └── index.php


/.env.sample:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/phpzm/ePHP/6b9fdb917336baf61e6e5289e1cd6cc135d1b95f/.env.sample


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /.idea
2 | /.env
3 | /docker-compose.yml
4 | /vendor
5 | /composer.phar
6 | 
7 | *.cache


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Grupo de PHP da Zona da Mata
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Essentials PHP (ePHP)
 2 | 
 3 | O `Essentials PHP` é um conjunto simples de funções, classes e configurações básicas para simplificar a vida do desenvolvedor.
 4 | 
 5 | Você pode aplicar o `Essentials PHP` à qualquer projeto PHP que você tenha. Veremos mais pra frente as vantagens que você pode obter com isso.
 6 | 
 7 | ## Motivação
 8 | 
 9 | Existe hoje uma lacuna muito grande entre usar o PHP diretamente ou adotar algum framework. Não há entre estes dois pontos um meio termo acessível e o que eu tenho visto por ai é o uso do PHP sem o mínimo de segurança e/ou organização quando não se usa um FW (framework) - embora a simples adoção do FW também não garanta totalmente qualidade nem segurança para o projeto. o ePHP entra nesse meio, e entrega uma forma simples e de qualidade para usar o PHP sem muitas firulas e com a opção de mexer no seu fluxo de trabalho só à medida que você precisar.
10 | 
11 | A ideia é eliminar do desenvolvimento com PHP acessos diretos a arquivos e o famoso `include db.inc.php`. O PHP já deixou isso para trás, mas falta ferramentas para auxiliar os dev's a seguirem adiante também.
12 | 
13 | ## Por onde começar
14 | 
15 | Faça download do [arquivo]( https://github.com/phpzm/essentials/archive/master.zip) que contém a estrutura do projeto.
16 | 
17 | Em seguida crie uma pasta para o projeto e descompacte o arquivo que você baixou dentro dela.
18 | 
19 | Agora é a vez de baixar o Composer. Vá até o [site do composer](https://getcomposer.org/download) role até o final da página e escolha uma versão compatível com a sua versão do PHP. Faça o download do arquivo para a pasta que você criou. Neste momento a versão estável mais atual é a [1.5.6](https://getcomposer.org/download/1.5.6/composer.phar) e ela é compatível com o PHP 7.1 que estou usando : )
20 | 
21 | O próximo passo é abrir uma janela de terminal nesse diretório e dar o comando `php composer.phar install`
22 | 
23 | Pronto! Agora você já está pronto para rodar o projeto.
24 | 
25 | #### Rodando o "Hello World!"
26 | 
27 | Você pode optar por:
28 | - Usar o servidor embutido no PHP: use o comando `php -S localhost:8080 -t public_html/` para iniciar o projeto;
29 | 
30 | - Usar o Nginx através do docker-compose: crie uma cópia do `docker-compose.yml.sample` removendo o `.sample` do fim do nome do arquivo. Feito isso basta rodar `docker-compose up`.
31 | 
32 | - Usar o que já está acostumado: seguindo por aqui imagino que você saiba onde colocar os arquivos e como acessar eles
33 | 
34 | Qualquer um dois dois primeiros caminhos vão te levar a acessar o "Hello World!" em [http://localhost:8080](http://localhost:8080), e, obviamente, você pode mudar essas configurações. Caso tenha optado por usar o que já está acostumado a URL de acesso será no formato que você está familiarizado.
35 | 
36 | ## Pra que isso tudo gente?!
37 | 
38 |  A ideia do ePHP é entregar facilidatores para o desenvolvedor. Separamos alguns tópicos a serem tratados que o projeto visa a resolver de forma rápida e muito simples.
39 |  
40 | - Acesso centralizado: Um dos objetivos mais importantes deste projeto é remover da raiz do web server a aplicação. Utilizando alguns recursos disponibilizados é possível colocar toda a aplicação "legada" a ser protegida dentro da pasta `app` e configurar como os arquivos serão acessados. Com esta modificação de segurança seu projeto já começa a ter um nível diferenciado de segurança.
41 | 
42 | - Super Globais: O segundo ponto a ser tocado é abstrair o acesso às super globais entregando funções que estão disponíveis em qualquer parte do projeto. Usando esses recursos você consegue limpar as entradas do usuário de acordo com o tipo de dado informado e minimiza muito o impacto de falhas de segurança que explorem combinações de valores de entrada para "zuar" com a sua aplicação. O acesso aos dados usa os mecanismos do [filter_input](http://php.net/filter_input) garantido a higienização dos valores recebidos. Além disso também é possível dar suporte a receber dados em formato JSON (payload) através da mesma função que é usada para os dados enviados via POST.
43 | 
44 | - Construção de comandos SQL: Você provavelmente está acostumado a criar comandos SQL e concatenar strings com `$_GET` e `$_POST`, mas essa prática vai pulverizar pelo seu código possíveis falhas de segurança. Para contornar isso você leva um construtir de comandos SQL na faixa que usa os famosos `Prepared Statements` para criar as instruções deixando seu código mais limpo e menos desprotegido.
45 | 
46 | 


--------------------------------------------------------------------------------
/app/index.php:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 |   <title>Demo</title>
 4 |   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.6.1/css/bulma.min.css"
 5 |         integrity="sha256-v5YlJGWVLS5hQ+o48fBzCKHEP2vMNsku57x3CosYykc=" crossorigin="anonymous"/>
 6 |   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
 7 |         integrity="sha256-eZrrJcwDc/3uDhsdt61sL2oOBY362qM3lon1gyExkL0=" crossorigin="anonymous"/>
 8 | </head>
 9 | <body>
10 | <section class="container">
11 |   <br>
12 |   <h1><?php out('Você está acessando o host <b>', Url::host(), Url::path(), '</b>', ' from ', address()); ?></h1>
13 |   <hr>
14 |   <pre><?php out(Http::all()) ?></pre>
15 |   <pre><?php out(Http::file('resume')) ?></pre>
16 |   <form class="column" method="post" enctype="multipart/form-data">
17 |     <div class="field">
18 |       <label class="label">Form label</label>
19 |       <div class="control">
20 |         <input class="input" type="text" name="input" placeholder="Input">
21 |       </div>
22 |     </div>
23 |     <div class="field">
24 |       <p class="control">
25 |       <span class="select">
26 |         <select>
27 |           <option>Select dropdown</option>
28 |         </select>
29 |       </span>
30 |       </p>
31 |     </div>
32 |     <div class="field">
33 |       <p class="control">
34 |         <textarea class="textarea" name="textarea" placeholder="Textarea"></textarea>
35 |       </p>
36 |     </div>
37 |     <div class="field">
38 |       <p class="control">
39 |         <label class="checkbox">
40 |           <input type="checkbox" name="checkbox">
41 |           Checkbox
42 |         </label>
43 |       </p>
44 |     </div>
45 |     <div class="field">
46 |       <p class="control">
47 |         <label class="radio">
48 |           <input type="radio" name="radio">
49 |           Radio
50 |         </label>
51 |         <label class="radio">
52 |           <input type="radio" name="radio">
53 |           Buttons
54 |         </label>
55 |       </p>
56 |     </div>
57 |     <div class="field">
58 |       <label class="label">File</label>
59 |       <div class="file">
60 |         <label class="file-label">
61 |           <input class="file-input" type="file" name="resume">
62 |           <span class="file-cta">
63 |             <span class="file-icon">
64 |               <i class="fa fa-upload"></i>
65 |             </span>
66 |             <span class="file-label">
67 |               Choose a file…
68 |             </span>
69 |           </span>
70 |         </label>
71 |       </div>
72 |     </div>
73 |     <div class="field">
74 |       <p class="control">
75 |         <button class="button is-link">Button</button>
76 |       </p>
77 |     </div>
78 |   </form>
79 | </section>
80 | </body>
81 | </html>


--------------------------------------------------------------------------------
/bootstrap/constants.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // native types
 4 | const TYPE_BOOLEAN = 'boolean';
 5 | const TYPE_INTEGER = 'integer';
 6 | const TYPE_FLOAT = 'float';
 7 | const TYPE_STRING = 'string';
 8 | const TYPE_ARRAY = 'array';
 9 | const TYPE_OBJECT = 'object';
10 | const TYPE_RESOURCE = 'resource';
11 | const TYPE_NULL = 'null';
12 | const TYPE_UNKNOWN_TYPE = 'unknown type';
13 | 
14 | // custom types
15 | const TYPE_DATE = 'date';
16 | 
17 | // context operators
18 | const __AND__ = ' AND ';
19 | const __OR__ = ' OR ';
20 | const __COMMA__ = ', ';
21 | const __NULL__ = '__NULL__';
22 | 
23 | 


--------------------------------------------------------------------------------
/bootstrap/environment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // show all errors
 4 | error_reporting(E_ALL);
 5 | 
 6 | // system settings
 7 | ini_set('display_errors', env('ERRORS_DISPLAY', 'On'));
 8 | ini_set('log_errors', env('ERRORS_LOG', 'On'));
 9 | ini_set('track_errors', env('ERRORS_TRACK', 'Off'));
10 | ini_set('html_errors', env('ERRORS_HTML', 'Off'));
11 | 


--------------------------------------------------------------------------------
/bootstrap/error.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (!function_exists('error_handler')) {
 4 |     /**
 5 |      * @param $code
 6 |      * @param $message
 7 |      * @param $file
 8 |      * @param $line
 9 |      * @throws ErrorException
10 |      */
11 |     function error_handler($code, $message, $file, $line)
12 |     {
13 |         throw new ErrorException($message, $code, 1, $file, $line);
14 |     }
15 | 
16 |     set_error_handler("error_handler");
17 | }
18 | 


--------------------------------------------------------------------------------
/bootstrap/function.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | if (!function_exists('filter')) {
  4 |     /**
  5 |      * @param int $source
  6 |      * @param string $index
  7 |      * @return mixed
  8 |      */
  9 |     function filter($source, $index)
 10 |     {
 11 |         return filter_input($source, $index);
 12 |     }
 13 | }
 14 | 
 15 | if (!function_exists('server')) {
 16 |     /**
 17 |      * @param string $index
 18 |      * @return mixed
 19 |      */
 20 |     function server($index)
 21 |     {
 22 |         return filter(INPUT_SERVER, $index);
 23 |     }
 24 | }
 25 | 
 26 | if (!function_exists('env')) {
 27 |     /**
 28 |      * @param string $property
 29 |      * @param mixed $default (null)
 30 |      * @return string
 31 |      */
 32 |     function env($property, $default = null)
 33 |     {
 34 |         $filename = path(dirname(__DIR__), '.env');
 35 |         if (!file_exists($filename) || !is_file($filename)) {
 36 |             return $default;
 37 |         }
 38 |         $properties = parse_ini_file($filename);
 39 |         if (!is_array($properties)) {
 40 |             return $default;
 41 |         }
 42 |         return get($properties, $property);
 43 |     }
 44 | }
 45 | 
 46 | if (!function_exists('path')) {
 47 |     /**
 48 |      * @param array $arguments
 49 |      * @return string
 50 |      */
 51 |     function path(...$arguments)
 52 |     {
 53 |         return implode('/', $arguments);
 54 |     }
 55 | }
 56 | 
 57 | if (!function_exists('out')) {
 58 |     /**
 59 |      * @param mixed $values
 60 |      */
 61 |     function out(...$values)
 62 |     {
 63 |         print implode(' ', array_map(function ($value) {
 64 |             return parse($value);
 65 |         }, $values));
 66 |     }
 67 | }
 68 | 
 69 | if (!function_exists('parse')) {
 70 |     /**
 71 |      * @param mixed $value
 72 |      * @return string
 73 |      */
 74 |     function parse($value)
 75 |     {
 76 |         switch (gettype($value)) {
 77 |             case TYPE_BOOLEAN:
 78 |                 return $value ? 'true' : 'false';
 79 |                 break;
 80 |             case TYPE_INTEGER:
 81 |             case TYPE_FLOAT:
 82 |             case TYPE_STRING:
 83 |                 return trim($value);
 84 |                 break;
 85 |             case TYPE_ARRAY:
 86 |             case TYPE_OBJECT:
 87 |             case TYPE_RESOURCE:
 88 |                 return json_encode($value);
 89 |             // case TYPE_NULL:
 90 |             // case TYPE_UNKNOWN_TYPE:
 91 |             default:
 92 |                 return '';
 93 |         }
 94 |     }
 95 | }
 96 | 
 97 | if (!function_exists('coalesce')) {
 98 |     /**
 99 |      * @param array ...$arguments
100 |      * @return mixed
101 |      * @throws ErrorException
102 |      */
103 |     function coalesce(...$arguments)
104 |     {
105 |         foreach ($arguments as $argument) {
106 |             if (!is_null($argument)) {
107 |                 return $argument;
108 |             }
109 |         }
110 |         throw new ErrorException("Can't resolve coalesce options");
111 |     }
112 | }
113 | 
114 | if (!function_exists('get')) {
115 |     /**
116 |      * @param mixed $value
117 |      * @param string|int $property (null)
118 |      * @param mixed $default (null)
119 |      * @return mixed
120 |      */
121 |     function get($value, $property = null, $default = null)
122 |     {
123 |         if (is_null($property)) {
124 |             return $default;
125 |         }
126 |         if (!$value) {
127 |             return $default;
128 |         }
129 |         if (is_array($value)) {
130 |             if (isset($value[$property])) {
131 |                 return $value[$property];
132 |             }
133 |             return search($value, $property, $default);
134 |         }
135 |         /** @noinspection PhpVariableVariableInspection */
136 |         if ($value && is_object($value) && isset($value->$property)) {
137 |             /** @noinspection PhpVariableVariableInspection */
138 |             return $value->$property;
139 |         }
140 |         return $default;
141 |     }
142 | }
143 | 
144 | /**
145 |  * @SuppressWarnings("ExitExpression")
146 |  */
147 | if (!function_exists('stop')) {
148 |     /**
149 |      * @param array ...$arguments
150 |      */
151 |     function stop(...$arguments)
152 |     {
153 |         ob_start();
154 |         if (count($arguments) === 1) {
155 |             $arguments = $arguments[0];
156 |         }
157 |         echo json_encode($arguments);
158 |         $contents = ob_get_contents();
159 |         ob_end_clean();
160 |         out($contents);
161 |         die;
162 |     }
163 | }
164 | 
165 | if (!function_exists('guid')) {
166 |     /**
167 |      * @param bool $brackets
168 |      * @return string
169 |      */
170 |     function guid($brackets = false)
171 |     {
172 |         mt_srand((double)microtime() * 10000);
173 | 
174 |         $char = strtoupper(md5(uniqid(rand(), true)));
175 |         $hyphen = chr(45);
176 |         $uuid = substr($char, 0, 8) . $hyphen . substr($char, 8, 4) . $hyphen . substr($char, 12, 4) . $hyphen .
177 |             substr($char, 16, 4) . $hyphen . substr($char, 20, 12);
178 |         if ($brackets) {
179 |             $uuid = chr(123) . $uuid . chr(125);
180 |         }
181 | 
182 |         return $uuid;
183 |     }
184 | }
185 | 
186 | if (!function_exists('error_message')) {
187 |     /**
188 |      * @param Throwable $error
189 |      * @return string
190 |      */
191 |     function error_message(Throwable $error)
192 |     {
193 |         $pieces = [];
194 |         $line = function ($message, $file, $line) {
195 |             $file = str_replace(dirname(__DIR__, 2), '', $file);
196 |             return $message . ' on ' . $file . ' in ' . $line;
197 |         };
198 | 
199 |         $pieces[] = $line($error->getMessage(), $error->getFile(), $error->getLine());
200 | 
201 |         if (method_exists($error, 'getDetails')) {
202 |             $pieces[] = '~';
203 |             $pieces[] = json_encode($error->getDetails(), JSON_PRETTY_PRINT);
204 |         }
205 |         if (is_array($error->getTrace())) {
206 |             $pieces[] = '~';
207 |             foreach ($error->getTrace() as $item) {
208 |                 $class = get($item, 'class');
209 |                 $function = get($item, 'function');
210 |                 $pieces[] = $line("`{$class}::{$function}`", get($item, 'file'), get($item, 'line'));
211 |             }
212 |         }
213 |         return implode(PHP_EOL, $pieces);
214 |     }
215 | }
216 | 
217 | if (!function_exists('search')) {
218 |     /**
219 |      * @param array $context
220 |      * @param array|string $path
221 |      * @param mixed $default (null)
222 |      * @return mixed|null
223 |      */
224 |     function search(array $context, $path, $default = null)
225 |     {
226 |         if (!is_array($path)) {
227 |             $path = explode('.', $path);
228 |         }
229 |         foreach ($path as $piece) {
230 |             if (!is_array($context) || !array_key_exists($piece, $context)) {
231 |                 return $default;
232 |             }
233 |             $context = $context[$piece];
234 |         }
235 |         return $context;
236 |     }
237 | }
238 | 
239 | if (!function_exists('read')) {
240 |     /**
241 |      * @param string $prompt
242 |      * @param string $options
243 |      * @return string
244 |      */
245 |     function read($prompt = '$ ', $options = '')
246 |     {
247 |         if ($options) {
248 |             $prompt = "{$prompt} {$options}\$ ";
249 |         }
250 |         $reader = function () use ($prompt) {
251 |             return readline("{$prompt}");
252 |         };
253 |         if (PHP_OS === 'WINNT') {
254 |             $reader = function () use ($prompt) {
255 |                 echo $prompt;
256 |                 return stream_get_line(STDIN, 1024, PHP_EOL);
257 |             };
258 |         }
259 |         $line = $reader();
260 |         readline_add_history($line);
261 | 
262 |         return trim($line);
263 |     }
264 | }
265 | 
266 | if (!function_exists('type')) {
267 |     /**
268 |      * @param mixed $value
269 |      * @param string $type
270 |      * @return bool
271 |      */
272 |     function type($value, string $type)
273 |     {
274 |         return gettype($value) === $type;
275 |     }
276 | }
277 | 
278 | /**
279 |  * @SuppressWarnings("SuperGlobals")
280 |  */
281 | if (!function_exists('address')) {
282 |     /**
283 |      * @return string
284 |      */
285 |     function address()
286 |     {
287 |         $sources = ['REMOTE_ADDR', 'HTTP_X_FORWARDED_FOR', 'HTTP_CLIENT_IP'];
288 |         foreach ($sources as $source) {
289 |             if (isset($_SERVER[$source])) {
290 |                 return $_SERVER[$source];
291 |             }
292 |         }
293 |         return 'x.x.x.x';
294 |     }
295 | }
296 | 


--------------------------------------------------------------------------------
/bootstrap/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * load useful functions
 5 |  */
 6 | require_once __DIR__ . '/function.php';
 7 | 
 8 | /**
 9 |  * configure environment
10 |  */
11 | require_once __DIR__ . '/environment.php';
12 | 
13 | /**
14 |  * register constants
15 |  */
16 | require_once __DIR__ . '/constants.php';
17 | 
18 | /**
19 |  * error handlers
20 |  */
21 | require_once __DIR__ . '/error.php';
22 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "autoload": {
 3 |     "psr-4": {
 4 |       "App\\": "app/",
 5 |       "": "essentials/"
 6 |     },
 7 |     "files": [
 8 |       "bootstrap/index.php"
 9 |     ]
10 |   }
11 | }


--------------------------------------------------------------------------------
/docker-compose.yml.sample:
--------------------------------------------------------------------------------
 1 | # v2 syntax
 2 | version: '2'
 3 | 
 4 | services:
 5 | 
 6 |   essentials.mysql:
 7 |     image: ambientum/mysql:5.7
 8 |     container_name: essentials.mysql
 9 |     volumes:
10 |       - ./.docker/mysql:/var/lib/mysql
11 |     ports:
12 |       - "3306:3306"
13 |     environment:
14 |       - MYSQL_ROOT_PASSWORD=root
15 |       - MYSQL_DATABASE=database
16 |       - MYSQL_USER=user
17 |       - MYSQL_PASSWORD=password
18 | 
19 |   essentials:
20 |     image: ambientum/php:7.0-nginx
21 |     container_name: essentials
22 |     volumes:
23 |       - .:/var/www/app
24 |     ports:
25 |       - "9000:8080"
26 |     links:
27 |       - essentials.mysql
28 | 


--------------------------------------------------------------------------------
/essentials/Base64.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Base64
 5 |  *
 6 |  * @method static string encode(string $string)
 7 |  * @method static string decode(string $string, bool $strict = null)
 8 |  */
 9 | abstract class Base64 extends Proxy
10 | {
11 |     /**
12 |      * @var array
13 |      */
14 |     protected static $map = [
15 |         'encode' => [
16 |             'name' => 'base64_encode',
17 |         ],
18 |         'decode' => [
19 |             'name' => 'base64_decode',
20 |         ],
21 |     ];
22 | }
23 | 


--------------------------------------------------------------------------------
/essentials/Encode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Encode
 5 |  *
 6 |  * @method static string ascii(string $string)
 7 |  * @method static string soundex(string $string)
 8 |  */
 9 | abstract class Encode extends Proxy
10 | {
11 |     /**
12 |      * @var array
13 |      */
14 |     protected static $map = [
15 |         'ascii' => [
16 |             'name' => 'ord',
17 |         ],
18 |         'soundex' => [
19 |             'name' => 'soundex',
20 |         ],
21 |     ];
22 | }
23 | 


--------------------------------------------------------------------------------
/essentials/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class File
 5 |  *
 6 |  * @method static int write(string $filename, mixed $data, int $flags = 0, resource $context = null)
 7 |  * @method static string read(string $filename, bool $use_include_path = false, resource $context = null, int $offset = 0, int $maxlen = null)
 8 |  * @method static bool exists(string $filename)
 9 |  */
10 | abstract class File extends Proxy
11 | {
12 |     /**
13 |      * @var array
14 |      */
15 |     protected static $map = [
16 |         /** @link http://php.net/manual/en/function.file-put-contents.php */
17 |         'write' => [
18 |             'name' => 'file_put_contens',
19 |         ],
20 |         /** @link http://php.net/manual/en/function.file-get-contents.php */
21 |         'read' => [
22 |             'name' => 'file_get_contens',
23 |         ],
24 |         /** @link http://php.net/manual/en/function.file-exists.php */
25 |         'exists' => [
26 |             'name' => 'file_exists',
27 |         ],
28 |     ];
29 | }
30 | 


--------------------------------------------------------------------------------
/essentials/Hash.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Hash
 5 |  *
 6 |  * @method static string md5(string $string, bool $raw = false)
 7 |  * @method static string sha1(string $string, bool $raw = false)
 8 |  */
 9 | abstract class Hash extends Proxy
10 | {
11 |     /**
12 |      * @var array
13 |      */
14 |     protected static $map = [
15 |         'md5' => [
16 |             'name' => 'md5',
17 |         ],
18 |         'sha1' => [
19 |             'name' => 'sha1',
20 |         ],
21 |     ];
22 | }


--------------------------------------------------------------------------------
/essentials/Http.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * class Http
 5 |  */
 6 | abstract class Http
 7 | {
 8 |     /**
 9 |      * @param string $index
10 |      * @return mixed
11 |      */
12 |     public static function post($index)
13 |     {
14 |         return filter(INPUT_POST, $index);
15 |     }
16 | 
17 |     /**
18 |      * @param string $index
19 |      * @return mixed
20 |      */
21 |     public static function get($index)
22 |     {
23 |         return filter(INPUT_GET, $index);
24 |     }
25 | 
26 |     /**
27 |      * @param string $index
28 |      * @return mixed
29 |      */
30 |     public static function file($index)
31 |     {
32 |         $files = static::files();
33 |         if (isset($files[$index])) {
34 |             return $files[$index];
35 |         }
36 |         return null;
37 |     }
38 | 
39 |     /**
40 |      * @return array
41 |      * @SuppressWarnings("SuperGlobals")
42 |      */
43 |     public static function files()
44 |     {
45 |         return $_FILES;
46 |     }
47 | 
48 |     /**
49 |      * @param string $index
50 |      * @return mixed
51 |      * @SuppressWarnings("SuperGlobals")
52 |      */
53 |     public static function all($index = null)
54 |     {
55 |         if (is_null($index)) {
56 |             return $_REQUEST;
57 |         }
58 |         return filter(INPUT_REQUEST, $index);
59 |     }
60 | }
61 | 
62 | 


--------------------------------------------------------------------------------
/essentials/Proxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Proxy
 5 |  */
 6 | abstract class Proxy
 7 | {
 8 |     /**
 9 |      * @var array
10 |      */
11 |     protected static $map = [];
12 | 
13 |     /**
14 |      * @param $name
15 |      * @param $arguments
16 |      * @return mixed
17 |      * @throws Exception
18 |      */
19 |     public static function __callStatic($name, $arguments)
20 |     {
21 |         if (!isset(static::$map[$name])) {
22 |             throw new Exception("Function `{$name}` not found");
23 |         }
24 |         $function = static::$map[$name]['name'];
25 |         $parameters = static::parameters($name, $arguments);
26 |         return call_user_func_array($function, $parameters);
27 |     }
28 | 
29 |     /**
30 |      * @param $name
31 |      * @param $arguments
32 |      * @return array
33 |      * @throws Exception
34 |      */
35 |     private static function parameters($name, $arguments)
36 |     {
37 |         if (!isset(static::$map[$name]['arguments'])) {
38 |             return $arguments;
39 |         }
40 |         $parameters = [];
41 |         foreach (static::$map[$name]['arguments'] as $index) {
42 |             if (!isset($arguments[$index])) {
43 |                 throw new Exception("Invalid arguments to `{$name}`");
44 |             }
45 |             $parameters[] = $arguments[$index];
46 |         }
47 |         return $parameters;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/essentials/Regex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Regex
 5 |  *
 6 |  * @method static string split($pattern, string $subject, int $limit = -1, int $flags = 0)
 7 |  */
 8 | abstract class Regex extends Proxy
 9 | {
10 |     /**
11 |      * @var array
12 |      */
13 |     public static $map = [
14 |         'split' => [
15 |             'name' => 'preg_split', // $pattern, $subject, $limit = -1, $flags = 0
16 |         ],
17 |     ];
18 | }
19 | 


--------------------------------------------------------------------------------
/essentials/Text.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Text
 5 |  *
 6 |  * @method static int length(string $string)
 7 |  * @method static string replace(string $string, string $search, string $replace)
 8 |  * @method static mixed first(string $string, string $search)
 9 |  * @method static mixed last(string $string, string $search)
10 |  * @method static string upper(string $string)
11 |  * @method static string lower(string $string)
12 |  * @method static string capitalize(string $string)
13 |  * @method static string unCapitalize(string $string)
14 |  * @method static array split(string $delimiter, string $string, int $limit = null)
15 |  * @method static string join(string $glue, array $pieces)
16 |  * @method static string levenshtein(string $a, string $b)
17 |  * @method static string substring(string $string , int $start, int $length = null)
18 |  * @method static string trim(string $string , string $characters = null)
19 |  * @method static string wrap(string $string , int $width = 75, string $break = "\n", bool $cut = false)
20 |  * @method static int compare(string $a, string $b)
21 |  * @method static array divide(string $string, int $length = 1)
22 |  * @method static string shuffle(string $string)
23 |  * @method static string repeat(string $string, int $multiplier)
24 |  */
25 | abstract class Text extends Proxy
26 | {
27 |     /**
28 |      * @var array
29 |      */
30 |     protected static $map = [
31 |         'length' => [
32 |             'name' => 'strlen',
33 |         ],
34 |         'replace' => [
35 |             'name' => 'str_replace',
36 |             'arguments' => [1, 2, 0],
37 |         ],
38 |         'first' => [
39 |             'name' => 'strpos',
40 |         ],
41 |         'last' => [
42 |             'name' => 'strrchr',
43 |         ],
44 |         'upper' => [
45 |             'name' => 'strtoupper',
46 |         ],
47 |         'lower' => [
48 |             'name' => 'strtolower',
49 |         ],
50 |         'capitalize' => [
51 |             'name' => 'ucwords',
52 |         ],
53 |         'unCapitalize' => [
54 |             'name' => 'lcfirst',
55 |         ],
56 |         'split' => [
57 |             'name' => 'explode',
58 |         ],
59 |         'join' => [
60 |             'name' => 'implode',
61 |         ],
62 |         'levenshtein' => [
63 |             'name' => 'levenshtein',
64 |         ],
65 |         'substring' => [
66 |             'name' => 'substr',
67 |         ],
68 |         'trim' => [
69 |             'name' => 'trim',
70 |         ],
71 |         'wrap' => [
72 |             'name' => 'wordwrap',
73 |         ],
74 |         'compare' => [
75 |             'name' => 'strcmp',
76 |         ],
77 |         'divide' => [
78 |             'name' => 'str_split',
79 |         ],
80 |         'shuffle' => [
81 |             'name' => 'str_shuffle',
82 |         ],
83 |         'repeat' => [
84 |             'name' => 'str_repeat',
85 |         ],
86 |     ];
87 | }
88 | 


--------------------------------------------------------------------------------
/essentials/Url.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class Url
 5 |  */
 6 | abstract class Url
 7 | {
 8 |     /**
 9 |      * @var string
10 |      */
11 |     const REF = 'index.php/';
12 | 
13 |     /**
14 |      * @return string
15 |      */
16 |     public static function host()
17 |     {
18 |         $self = static::self();
19 |         $uri = static::uri();
20 |         $start = '';
21 |         if ($self !== $uri) {
22 |             $start = static::start($self);
23 |         }
24 |         return server('HTTP_HOST') . $start;
25 |     }
26 | 
27 |     /**
28 |      * @return string
29 |      */
30 |     public static function path()
31 |     {
32 |         $self = static::self();
33 |         $uri = static::uri();
34 |         if ($self !== $uri) {
35 |             $start = static::start($self);
36 |             $search = '/' . preg_quote($start, '/') . '/';
37 |             $uri = preg_replace($search, '', $uri, 1);
38 |         }
39 |         return $uri;
40 |     }
41 | 
42 |     /**
43 |      * @return mixed
44 |      */
45 |     private static function self()
46 |     {
47 |         return str_replace(static::REF, '', server('PHP_SELF'));
48 |     }
49 | 
50 |     /**
51 |      * @return string
52 |      */
53 |     private static function uri()
54 |     {
55 |         return server('REQUEST_URI') ? explode('?', server('REQUEST_URI'))[0] : '';
56 |     }
57 | 
58 |     /**
59 |      * @param $self
60 |      * @return string
61 |      */
62 |     private static function start($self)
63 |     {
64 |         $pieces = explode('/', $self);
65 |         array_pop($pieces);
66 |         return implode('/', $pieces);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/essentials/Utils/Instance.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Utils;
 4 | 
 5 | /**
 6 |  * Trait Instance
 7 |  * @package Utils
 8 |  */
 9 | trait Instance
10 | {
11 |     /**
12 |      * @return static
13 |      */
14 |     public static function instance()
15 |     {
16 |         return new static();
17 |     }
18 | }


--------------------------------------------------------------------------------
/essentials/ePHP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Utils\Instance;
 4 | 
 5 | /**
 6 |  * Class ePHP
 7 |  */
 8 | class ePHP
 9 | {
10 |     /**
11 |      * @trait
12 |      */
13 |     use Instance;
14 | 
15 |     /**
16 |      * @param string $file
17 |      * @param array $params
18 |      * @return mixed
19 |      */
20 |     public function compile($file, $params = [])
21 |     {
22 |         $root = env('APP_DIR');
23 |         $filename = realpath($file);
24 |         if ($root) {
25 |             $filename = realpath(path($root, $file));
26 |         }
27 |         if (!file_exists($filename) || is_dir($filename)) {
28 |             return null;
29 |         }
30 |         ob_start();
31 |         if (is_array($params)) {
32 |             extract($params);
33 |         }
34 |         /** @noinspection PhpIncludeInspection */
35 |         include $filename;
36 |         $content = ob_get_contents();
37 |         if ($content) {
38 |             ob_end_clean();
39 |         }
40 |         return $content;
41 |     }
42 | }


--------------------------------------------------------------------------------
/public_html/.htaccess:
--------------------------------------------------------------------------------
1 | Options +FollowSymLinks
2 | 
3 | RewriteEngine On
4 | RewriteCond %{REQUEST_FILENAME} !-f
5 | RewriteCond %{REQUEST_FILENAME} !-d
6 | RewriteRule ^(.*)$ index.php [NC,L]
7 | 


--------------------------------------------------------------------------------
/public_html/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require dirname(__DIR__) . '/vendor/autoload.php';
 4 | 
 5 | try {
 6 |     $path = Url::path();
 7 |     if ($path === '/') {
 8 |         $path = '/index.php';
 9 |     }
10 |     $app = Text::substring($path, 1);
11 | 
12 |     $compiled = ePHP::instance()->compile(dirname(__DIR__) . '/app/' . $app);
13 |     if (is_null($compiled)) {
14 |         /** @noinspection PhpVoidFunctionResultUsedInspection */
15 |         return out('Whoops');
16 |     }
17 |     out($compiled);
18 | } catch (Throwable $error) {
19 |     echo $error->getMessage();
20 | }
21 | 


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