wtrmln/libs/url.php

   1 <?php
   2 /********************************************************************
   3
   4   Watermelon CMS
   5
   6 Copyright 2008 Radosław Pietruszewski
   7
   8 This program is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU General Public License
  10 version 2 as published by the Free Software Foundation.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 ********************************************************************/
  22
  23 /*
  24  * Lib URL
  25  * wersja 1.8.1
  26  *
  27  * Parsowanie URL-i etc.
  28  *
  29  */
  30
  31 class URL
  32 {
  33    /*
  34     * public static string[] $segments
  35     *
  36     * segmenty URL-a (np. foo/bar == array('foo', 'bar'))
  37     *
  38     * $segments = array($segment[, $segment[, ... ]])
  39     *   $segment - pojedynczy segment
  40     */
  41    public static $segments = array();
  42
  43    /*
  44     * public static string $class
  45     *
  46     * nazwa kontrolera do wykonania
  47     */
  48
  49    static public $class = '';
  50
  51    /*
  52     * public static string $method
  53     *
  54     * nazwa funkcji składowej (metody) kontrolera do wykonania
  55     */
  56
  57    public static $method = '';
  58
  59    /*
  60     * private static bool $inited
  61     *
  62     * true,  jeśli biblioteka została już zainicjalizowana
  63     * false, jeśli nie
  64     */
  65
  66    private static $inited = false;
  67
  68    /*
  69     * public static bool $onesegment = false
  70     *
  71     * true,  jeśli w URL-u jest tylko jeden segment
  72     * false, jeśli w URL-u jest więcej niż jeden segment
  73     */
  74
  75    public static $onesegment = false;
  76
  77    /*
  78     * public void URL(string $default)
  79     *
  80     * Konstruktor. Inicjalizuje bibliotekę uzupełniając pole 'segments'
  81     * Zwraca false jeśli już była wcześniej zainicjalizowana
  82     * Wywala błąd krytyczny, jeśli nie podano argumentu $default
  83     * i nie była jeszcze zainicjalizowana.
  84     *
  85     * string $default - nazwa domyślnego kontrolera
  86     *
  87     */
  88
  89    public function URL($default = null)
  90    {
  91       // jeśli klasa została już zainicjalizowana, nie kontynuujemy działania
  92       // tej funkcji składowej
  93
  94       if(self::$inited === true)
  95       {
  96          return false;
  97       }
  98
  99       // żeby klasa mogła funkcjonować poprawnie, nie można pozwolić na
 100       // nie podanie domyślnego kontrolera. Tutaj musi być to zrobione "ręcznie"
 101       // dlatego, że funkcja jest (jako konstruktor) wykonywana wielokrotnie w
 102       // kodzie, już po inicjalizacji biblioteki.
 103
 104       if($default === null)
 105       {
 106          panic('Lib URL: 0');
 107       }
 108
 109       // pobieramy dane o URL-u
 110
 111       $URL  = (isset($_SERVER['PATH_INFO']) ? $_SERVER['PATH_INFO'] : @getenv('PATH_INFO'));
 112       $URL2 = array();
 113
 114       // parsujemy segmenty URL-a (ze względów bezpieczeństwa pozwalam
 115       // tylko na znaki 0-9A-Za-z+-._)
 116
 117       foreach(explode('/', $URL) as $segment)
 118       {
 119          $segment2 = '';
 120          foreach(str_split($segment) as $char)
 121          {
 122             $char = ord($char); // char -> int
 123
 124             // pozwalam tylko na znaki takie jak:
 125
 126             // cyfry
 127
 128             if($char >= 48 && $char <= 57)
 129             {
 130                $segment2 .= chr($char);
 131             }
 132
 133             // duże litery
 134
 135             if($char >= 65 && $char <= 90)
 136             {
 137                $segment2 .= chr($char);
 138             }
 139
 140             // małe litery
 141
 142             if($char >= 97 && $char <= 122)
 143             {
 144                $segment2 .= chr($char);
 145             }
 146
 147             // plus (+)
 148
 149             if($char == 43)
 150             {
 151                $segment2 .= chr($char);
 152             }
 153
 154             // minus (-)
 155
 156             if($char == 45)
 157             {
 158                $segment2 .= chr($char);
 159             }
 160
 161             // kropka (.)
 162
 163             if($char == 46)
 164             {
 165                $segment2 .= chr($char);
 166             }
 167
 168             // podkreślenie (_)
 169
 170             if($char == 95)
 171             {
 172                $segment2 .= chr($char);
 173             }
 174          }
 175
 176          // jeśli ktoś zrobił wielokrotne slashe, wywalamy pusty segment
 177          if(!empty($segment2))
 178          {
 179             $URL2[] = $segment2;
 180          }
 181       }
 182
 183
 184       // czyszczenie nazwy kontrolera
 185       // (jeśli brak nazwy kontrolera, ustaw na domyślną)
 186
 187
 188       if(isset($URL2[0]))
 189       {
 190          // czyszczenie segmentu z potencjalnie niebezpiecznego syfu
 191          // (nawet nie chodzi o bezpieczeństwo, ale wiadomo, że
 192          // kontroler o nazwie Foo.bar nie ma prawa istnieć
 193          // ze względu na ograniczenia nazewnictwa w PHP)
 194
 195          $seg   = strtolower($URL2[0]);
 196          $seg   = str_split($seg);
 197          $seg_n = '';
 198
 199          // parsujemy nazwę kontrolera (ze względów bezpieczeństwa pozwalam
 200          // tylko na znaki 0-9A-Za-z_)
 201
 202          foreach($seg as $char)
 203          {
 204             $char = ord($char); //char -> int
 205
 206             // pozwalam tylko na znaki takie jak:
 207
 208             // litery
 209
 210             if($char >= 97 && $char <= 122)
 211             {
 212                $seg_n .= chr($char);
 213             }
 214
 215             // cyfry
 216
 217             if($char >= 48 && $char <= 57)
 218             {
 219                $seg_n .= chr($char);
 220             }
 221
 222             // podkreślenie (_)
 223
 224             if($char == 95)
 225             {
 226                $seg_n .= chr($char);
 227             }
 228
 229             // myślnik (-)
 230
 231             if($char == 45)
 232             {
 233                $seg_n .= chr($char);
 234             }
 235          }
 236
 237          $t[0] = $seg_n;
 238       }
 239       else
 240       {
 241          // jeśli nie podano nazwy kontrolera, ustaw na domyślną
 242
 243          $t[0] = $default;
 244       }
 245
 246       // czyszczenie nazwy funkcji składowej/metody kontrolera
 247       // (jeśli brak, ustaw na index)
 248
 249       if(isset($URL2[1]))
 250       {
 251          $seg   = strtolower($URL2[1]);
 252          $seg   = str_split($seg);
 253          $seg_n = '';
 254
 255          // parsujemy nazwę kontrolera (ze względów bezpieczeństwa pozwalam
 256          // tylko na znaki 0-9A-Za-z_)
 257
 258          foreach($seg as $char)
 259          {
 260             $char = ord($char); //char -> int
 261
 262             // pozwalam tylko na znaki takie jak:
 263
 264             // litery
 265
 266             if($char >= 97 && $char <= 122)
 267             {
 268                $seg_n .= chr($char);
 269             }
 270
 271             // cyfry
 272
 273             if($char >= 48 && $char <= 57)
 274             {
 275                $seg_n .= chr($char);
 276             }
 277
 278             // podkreślenie (_)
 279
 280             if($char == 95)
 281             {
 282                $seg_n .= chr($char);
 283             }
 284          }
 285
 286          // niestety nie da się stworzyć metody o nazwie new :/
 287
 288          if($seg_n == 'new')
 289          {
 290             $seg_n = '_new';
 291          }
 292
 293          $t[1] = $seg_n;
 294       }
 295       else
 296       {
 297          // jeśli nie podano nazwy funkcji składowej/metody kontrolera
 298          // ustaw na index (domyślna funkcja składowa)
 299
 300          $t[1] = 'index';
 301
 302          self::$onesegment = true;
 303       }
 304
 305       // usuń dwa pierwsze segmenty (kontroler i jego funkcja składowa)
 306       // jeśli są tylko dwa segmenty lub mniej, oczyść tablicę
 307       // (wychodzi na to samo, ale PHP nie wywala błędu)
 308
 309       if(count($URL2) > 2)
 310       {
 311          $URL2 = array_splice($URL2, -(count($URL2) - 2));
 312       }
 313       else
 314       {
 315          $URL2 = array();
 316       }
 317
 318       // złączenie tablic - tej z oczyszczonymi lub domyślnymi nazwami kontrolera
 319       // i funkcji składowej/metody kontrolera z tą tablicą, która ma pozostałe
 320       // segmenty (lub nie ma, jeśli nie podano)
 321
 322       $URL2 = array_merge($t, $URL2);
 323
 324       // nadanie odpowiednich wartości
 325
 326       self::$segments = $URL2;
 327       self::$class    = self::$segments[0];
 328       self::$method   = self::$segments[1];
 329       self::$inited   = true;
 330    }
 331
 332    /*
 333     * public string segment(int $ID)
 334     *
 335     * Zwraca treść danego [$ID] segmentu.
 336     * Segmenty są liczone od jeden
 337     * (a nie od zera, jak to jest w PHP-owskich tablicach)
 338     *
 339     * Zwraca false w przypadku niepowodzenia
 340     * (tj. jeśli żądany segment nie istnieje)
 341     *
 342     */
 343
 344    public function segment($ID)
 345    {
 346       if(isset(self::$segments[$ID - 1]))
 347       {
 348          return self::$segments[$ID - 1];
 349       }
 350       else
 351       {
 352          return false;
 353       }
 354    }
 355
 356    /*
 357     * public int segments()
 358     *
 359     * Zwraca ilość segmentów
 360     *
 361     */
 362
 363    public function segments()
 364    {
 365       return count(self::$segments);
 366    }
 367 }
 368 ?>