git-svn-id: https://msi/svn/firstRepo/Service/trunk@19 0f545695-f87b-41b6-9a03-7f16563b5454

.htaccess

@@ -0,0 +1,12 @@
+<ifModule mod_rewrite.c>
+	RewriteEngine On
+	RewriteCond %{REQUEST_FILENAME} !-f
+	RewriteRule ^(.*)$ serviceapp.php [QSA,L]
+</ifModule>
+
+<Limit GET POST PUT DELETE>
+  Allow from *.gruppolapastamadre.it
+</Limit>
+
+Header set Access-Control-Allow-Origin *.gruppolapastamadre.it
+Header set Access-Control-Allow-Methods: "GET,POST,OPTIONS,DELETE,PUT"

MySqlClass.php

@@ -0,0 +1,89 @@
+<?php
+class MysqlClass
+{
+	  // parametri per la connessione al database
+	  /*private $nomehost = "mysql.hostinger.it";     
+	  private $nomeuser = "u766568765_lpm";          
+	  private $password = "8zX2gTIjfwXEdEgaSaWe"; 
+	  private $mydb =     "u766568765_lpm";
+	    */ 
+	  private $nomehost = "sql.gruppolapastamadre.it";     
+	  private $nomeuser = "w18092_ricuser";          
+	  private $password = "RTvg0o6IESoqQyx8CCJn"; 
+	  private $mydb =     "w18092_ricettario";
+	
+	  // controllo sulle connessioni attive
+	  private $attiva = false;
+	  private $connessione = null;
+	 
+	  // funzione per la connessione a MySQL
+	  public function connetti()
+	  {
+		if(!$this->attiva)
+		{
+          $this->connessione = mysql_connect($this->nomehost,$this->nomeuser,$this->password);
+          if ($this->connessione == FALSE)
+          	die(mysql_error());
+          mysql_select_db($this->mydb, $this->connessione) or die ("Errore nella selezione del database. Verificare i parametri nel file config.inc.php");
+		  $this->attiva = true;
+		}
+		else{
+		    return true;
+		}
+        
+	  }
+	  
+	  public function executeQuery($queryStr)
+	  {
+	  	$this->connetti();
+		
+      	if (!$res = mysql_query($queryStr, $this->connessione)) die(mysql_error());
+			return true;
+		return false;
+	  }
+	  
+	  public function insertRecord($queryStr)
+	  {
+	  	$this->connetti();
+		
+      	if (!$res = mysql_query($queryStr, $this->connessione)) die(mysql_error()); 
+	  	return mysql_insert_id();
+	  }
+	  
+  	public function queryToObject($queryStr)
+	{
+		$this->connetti();
+		
+		$sth = mysql_query($queryStr, $this->connessione) or die(mysql_error());
+				
+		$rows = array();
+		while($r = mysql_fetch_assoc($sth)) {
+			array_push($rows,array_map('utf8_encode', $r));
+		}
+		mysql_free_result($sth);
+		return $rows;
+	}
+	  
+	  	// funzione per la chiusura della connessione
+		public function disconnetti()
+		{
+			if($this->attiva)
+			{
+				if(mysql_close($this->connessione))
+				{
+					$this->attiva = false;
+					return true;
+				}
+				else
+				{
+					return false;
+				}
+			}
+		}
+		
+		public function __destruct()
+		{
+			$this->disconnetti();
+		}
+     }
+?>

PHPImageWorkshop/Core/Exception/ImageWorkshopLayerException.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace PHPImageWorkshop\Core\Exception;
+
+use PHPImageWorkshop\Exception\ImageWorkshopBaseException as ImageWorkshopBaseException;
+
+// If no autoloader, uncomment these lines:
+//require_once(__DIR__.'/../../Exception/ImageWorkshopBaseException.php');
+
+/**
+ * ImageWorkshopLayerException
+ * 
+ * Manage ImageWorkshopLayer exceptions
+ * 
+ * @link http://phpimageworkshop.com
+ * @author Sybio (Clément Guillemain  / @Sybio01)
+ * @license http://en.wikipedia.org/wiki/MIT_License
+ * @copyright Clément Guillemain
+ */
+class ImageWorkshopLayerException extends ImageWorkshopBaseException
+{
+}

PHPImageWorkshop/Core/Exception/ImageWorkshopLibException.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace PHPImageWorkshop\Core\Exception;
+
+use PHPImageWorkshop\Exception\ImageWorkshopBaseException as ImageWorkshopBaseException;
+
+// If no autoloader, uncomment these lines:
+//require_once(__DIR__.'/../../Exception/ImageWorkshopBaseException.php');
+
+/**
+ * ImageWorkshopLibException
+ * 
+ * Manage ImageWorkshopLib exceptions
+ * 
+ * @link http://phpimageworkshop.com
+ * @author Sybio (Clément Guillemain  / @Sybio01)
+ * @license http://en.wikipedia.org/wiki/MIT_License
+ * @copyright Clément Guillemain
+ */
+class ImageWorkshopLibException extends ImageWorkshopBaseException
+{
+}

PHPImageWorkshop/Core/ImageWorkshopLib.php

@@ -0,0 +1,299 @@
+<?php
+
+namespace PHPImageWorkshop\Core;
+
+use PHPImageWorkshop\Core\Exception\ImageWorkshopLibException as ImageWorkshopLibException;
+
+// If no autoloader, uncomment these lines:
+//require_once(__DIR__.'/Exception/ImageWorkshopLibException.php');
+
+/**
+ * ImageWorkshopLib class
+ *
+ * Contains some tools to help in some ImageWorkshop calculations
+ *
+ * @link http://phpimageworkshop.com
+ * @author Sybio (Clément Guillemain  / @Sybio01)
+ * @license http://en.wikipedia.org/wiki/MIT_License
+ * @copyright Clément Guillemain
+ */
+class ImageWorkshopLib
+{
+    /**
+     * @var integer
+     */
+    const ERROR_FONT_NOT_FOUND = 3;
+    
+    /**
+     * Calculate the left top positions of a layer inside a parent layer container
+     * $position: http://phpimageworkshop.com/doc/22/corners-positions-schema-of-an-image.html
+     *
+     * @param integer $containerWidth
+     * @param integer $containerHeight
+     * @param integer $layerWidth
+     * @param integer $layerHeight
+     * @param integer $layerPositionX
+     * @param integer $layerPositionY
+     * @param string $position
+     *
+     * @return array
+     */
+    public static function calculatePositions($containerWidth, $containerHeight, $layerWidth, $layerHeight, $layerPositionX, $layerPositionY, $position = 'LT')
+    {
+        $position = strtolower($position);
+
+        if ($position == 'rt') {
+
+            $layerPositionX = $containerWidth - $layerWidth - $layerPositionX;
+
+        } elseif ($position == 'lb') {
+
+            $layerPositionY = $containerHeight - $layerHeight - $layerPositionY;
+
+        } elseif ($position == 'rb') {
+
+            $layerPositionX = $containerWidth - $layerWidth - $layerPositionX;
+            $layerPositionY = $containerHeight - $layerHeight - $layerPositionY;
+
+        } elseif ($position == 'mm') {
+
+            $layerPositionX = (($containerWidth - $layerWidth) / 2) + $layerPositionX;
+            $layerPositionY = (($containerHeight - $layerHeight) / 2) + $layerPositionY;
+
+        } elseif ($position == 'mt') {
+
+            $layerPositionX = (($containerWidth - $layerWidth) / 2) + $layerPositionX;
+
+        } elseif ($position == 'mb') {
+
+            $layerPositionX = (($containerWidth - $layerWidth) / 2) + $layerPositionX;
+            $layerPositionY = $containerHeight - $layerHeight - $layerPositionY;
+
+        } elseif ($position == 'lm') {
+
+            $layerPositionY = (($containerHeight - $layerHeight) / 2) + $layerPositionY;
+
+        } elseif ($position == 'rm') {
+
+            $layerPositionX = $containerWidth - $layerWidth - $layerPositionX;
+            $layerPositionY = (($containerHeight - $layerHeight) / 2) + $layerPositionY;
+        }
+
+        return array(
+            'x' => $layerPositionX,
+            'y' => $layerPositionY,
+        );
+    }
+    
+    /**
+     * Convert Hex color to RGB color format
+     *
+     * @param string $hex
+     *
+     * @return array
+     */
+    public static function convertHexToRGB($hex)
+    {
+        return array(
+            'R' => (int) base_convert(substr($hex, 0, 2), 16, 10),
+            'G' => (int) base_convert(substr($hex, 2, 2), 16, 10),
+            'B' => (int) base_convert(substr($hex, 4, 2), 16, 10),
+        );
+    }
+    
+    /**
+     * Generate a new image resource var
+     *
+     * @param integer $width
+     * @param integer $height
+     * @param string $color
+     * @param integer $opacity
+     *
+     * @return resource
+     */
+    public static function generateImage($width = 100, $height = 100, $color = 'ffffff', $opacity = 127)
+    {
+        $RGBColors = ImageWorkshopLib::convertHexToRGB($color);
+
+        $image = imagecreatetruecolor($width, $height);
+        imagesavealpha($image, true);
+        $color = imagecolorallocatealpha($image, $RGBColors['R'], $RGBColors['G'], $RGBColors['B'], $opacity);
+        imagefill($image, 0, 0, $color);
+
+        return $image;
+    }
+    
+    /**
+     * Return dimension of a text
+     *
+     * @param $fontSize
+     * @param $fontAngle
+     * @param $fontFile
+     * @param $text
+     *
+     * @return array or boolean
+     */
+    public static function getTextBoxDimension($fontSize, $fontAngle, $fontFile, $text)
+    {
+        if (!file_exists($fontFile)) {
+            throw new ImageWorkshopLibException('Can\'t find a font file at this path : "'.$fontFile.'".', static::ERROR_FONT_NOT_FOUND);
+        }
+        
+        $box = imagettfbbox($fontSize, $fontAngle, $fontFile, $text);
+
+		if (!$box) {
+
+			return false;
+		}
+
+        $minX = min(array($box[0], $box[2], $box[4], $box[6]));
+        $maxX = max(array($box[0], $box[2], $box[4], $box[6]));
+        $minY = min(array($box[1], $box[3], $box[5], $box[7]));
+        $maxY = max(array($box[1], $box[3], $box[5], $box[7]));
+        $width = ($maxX - $minX);
+        $height = ($maxY - $minY);
+        $left = abs($minX) + $width;
+        $top = abs($minY) + $height;
+
+        // to calculate the exact bounding box, we write the text in a large image
+        $img = @imagecreatetruecolor($width << 2, $height << 2);
+        $white = imagecolorallocate($img, 255, 255, 255);
+        $black = imagecolorallocate($img, 0, 0, 0);
+        imagefilledrectangle($img, 0, 0, imagesx($img), imagesy($img), $black);
+
+        // for ensure that the text is completely in the image
+        imagettftext($img, $fontSize, $fontAngle, $left, $top, $white, $fontFile, $text);
+
+        // start scanning (0=> black => empty)
+        $rleft = $w4 = $width<<2;
+        $rright = 0;
+        $rbottom = 0;
+        $rtop = $h4 = $height<<2;
+
+        for ($x = 0; $x < $w4; $x++) {
+
+			for ($y = 0; $y < $h4; $y++) {
+
+				if (imagecolorat($img, $x, $y)) {
+
+					$rleft = min($rleft, $x);
+					$rright = max($rright, $x);
+					$rtop = min($rtop, $y);
+					$rbottom = max($rbottom, $y);
+				}
+			}
+		}
+
+        imagedestroy($img);
+
+        return array(
+            'left' => $left - $rleft,
+            'top' => $top - $rtop,
+            'width' => $rright - $rleft + 1,
+            'height' => $rbottom - $rtop + 1,
+        );
+    }
+    
+    /**
+     * Copy an image on another one and converse transparency
+     *
+     * @param resource $destImg
+     * @param resource $srcImg
+     * @param integer $destX
+     * @param integer $destY
+     * @param integer $srcX
+     * @param integer $srcY
+     * @param integer $srcW
+     * @param integer $srcH
+     * @param integer $pct
+     */
+    public static function imageCopyMergeAlpha(&$destImg, &$srcImg, $destX, $destY, $srcX, $srcY, $srcW, $srcH, $pct = 0)
+    {
+        $destX = (int) $destX;
+        $destY = (int) $destY;
+        $srcX = (int) $srcX;
+        $srcY = (int) $srcY;
+        $srcW = (int) $srcW;
+        $srcH = (int) $srcH;
+        $pct = (int) $pct;
+        $destW = imageSX($destImg);
+        $destH = imageSY($destImg);
+
+        for ($y = 0; $y < $srcH + $srcY; $y++) {
+
+            for ($x = 0; $x < $srcW + $srcX; $x++) {
+
+                if ($x + $destX >= 0 && $x + $destX < $destW && $x + $srcX >= 0 && $x + $srcX < $srcW && $y + $destY >= 0 && $y + $destY < $destH && $y + $srcY >= 0 && $y + $srcY < $srcH) {
+
+                    $destPixel = imageColorsForIndex($destImg, imageColorat($destImg, $x + $destX, $y + $destY));
+                    $srcImgColorat = imageColorat($srcImg, $x + $srcX, $y + $srcY);
+                    
+                    if ($srcImgColorat >= 0) {
+                    
+                        $srcPixel = imageColorsForIndex($srcImg, $srcImgColorat);
+    
+                        $srcAlpha = 1 - ($srcPixel['alpha'] / 127);
+                        $destAlpha = 1 - ($destPixel['alpha'] / 127);
+                        $opacity = $srcAlpha * $pct / 100;
+    
+                        if ($destAlpha >= $opacity) {
+    						$alpha = $destAlpha;
+    					}
+    
+                        if ($destAlpha < $opacity) {
+    						$alpha = $opacity;
+    					}
+    
+                        if ($alpha > 1) {
+    						$alpha = 1;
+    					}
+    
+                        if ($opacity > 0) {
+                            
+                            $destRed = round((($destPixel['red'] * $destAlpha * (1 - $opacity))));
+                            $destGreen = round((($destPixel['green'] * $destAlpha * (1 - $opacity))));
+                            $destBlue = round((($destPixel['blue'] * $destAlpha * (1 - $opacity))));
+                            $srcRed = round((($srcPixel['red'] * $opacity)));
+                            $srcGreen = round((($srcPixel['green'] * $opacity)));
+                            $srcBlue = round((($srcPixel['blue'] * $opacity)));
+                            $red = round(($destRed + $srcRed  ) / ($destAlpha * (1 - $opacity) + $opacity));
+                            $green = round(($destGreen + $srcGreen) / ($destAlpha * (1 - $opacity) + $opacity));
+                            $blue = round(($destBlue + $srcBlue ) / ($destAlpha * (1 - $opacity) + $opacity));
+    
+                            if ($red   > 255) {
+    							$red   = 255;
+    						}
+    
+                            if ($green > 255) {
+    							$green = 255;
+                            }
+    
+    						if ($blue  > 255) {
+    							$blue  = 255;
+    						}
+    
+                            $alpha = round((1 - $alpha) * 127);
+                            $color = imageColorAllocateAlpha($destImg, $red, $green, $blue, $alpha);
+                            imageSetPixel($destImg, $x + $destX, $y + $destY, $color);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    /**
+     * Merge two image var
+     *
+     * @param resource $destinationImage
+     * @param resource $sourceImage
+     * @param integer $destinationPosX
+     * @param integer $destinationPosY
+     * @param integer $sourcePosX
+     * @param integer $sourcePosY
+     */
+    public static function mergeTwoImages(&$destinationImage, $sourceImage, $destinationPosX = 0, $destinationPosY = 0, $sourcePosX = 0, $sourcePosY = 0)
+    {
+        imageCopy($destinationImage, $sourceImage, $destinationPosX, $destinationPosY, $sourcePosX, $sourcePosY, imageSX($sourceImage), imageSY($sourceImage));
+    }
+}

PHPImageWorkshop/Exception/ImageWorkshopBaseException.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace PHPImageWorkshop\Exception;
+
+/**
+ * ImageWorkshopBaseException
+ * 
+ * The inherited exception class
+ * 
+ * @link http://phpimageworkshop.com
+ * @author Bjørn Børresen | Sybio (Clément Guillemain  / @Sybio01)
+ * @license http://en.wikipedia.org/wiki/MIT_License
+ * @copyright Clément Guillemain
+ */
+class ImageWorkshopBaseException extends \Exception
+{
+    /**
+     * Constructor
+     * 
+     * @param string $message
+     * @param integer $code
+     * @param Exception $previous
+     */
+    public function __construct($message, $code = 0, \Exception $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
+    
+    /**
+     * __toString method
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return __CLASS__.": [{$this->code}]: {$this->message}\n";
+    }
+}

PHPImageWorkshop/Exception/ImageWorkshopException.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace PHPImageWorkshop\Exception;
+
+use PHPImageWorkshop\Exception\ImageWorkshopBaseException as ImageWorkshopBaseException;
+
+// If no autoloader, uncomment these lines:
+//require_once(__DIR__.'/ImageWorkshopBaseException.php');
+
+/**
+ * ImageWorkshopException
+ * 
+ * Manage ImageWorkshop exceptions
+ * 
+ * @link http://phpimageworkshop.com
+ * @author Sybio (Clément Guillemain  / @Sybio01)
+ * @license http://en.wikipedia.org/wiki/MIT_License
+ * @copyright Clément Guillemain
+ */
+class ImageWorkshopException extends ImageWorkshopBaseException
+{
+}

PHPImageWorkshop/ImageWorkshop.php

@@ -0,0 +1,168 @@
+<?php
+
+namespace PHPImageWorkshop;
+
+use PHPImageWorkshop\Core\ImageWorkshopLayer as ImageWorkshopLayer;
+use PHPImageWorkshop\Core\ImageWorkshopLib as ImageWorkshopLib;
+use PHPImageWorkshop\Exception\ImageWorkshopException as ImageWorkshopException;
+
+// If no autoloader, uncomment these lines:
+//require_once(__DIR__.'/Core/ImageWorkshopLayer.php');
+//require_once(__DIR__.'/Exception/ImageWorkshopException.php');
+
+/**
+ * ImageWorkshop class
+ * 
+ * Use this class as a factory to initialize ImageWorkshop layers
+ *
+ * @version 2.0.6
+ * @link http://phpimageworkshop.com
+ * @author Sybio (Clément Guillemain / @Sybio01)
+ * @license http://en.wikipedia.org/wiki/MIT_License
+ * @copyright Clément Guillemain
+ */
+class ImageWorkshop
+{
+    /**
+     * @var integer
+     */
+    const ERROR_NOT_AN_IMAGE_FILE = 1;
+    
+    /**
+     * @var integer
+     */
+    const ERROR_IMAGE_NOT_FOUND = 2;
+    
+    /**
+     * @var integer
+     */
+    const ERROR_NOT_WRITABLE_FILE = 3;
+    
+    /**
+     * @var integer
+     */
+    const ERROR_CREATE_IMAGE_FROM_STRING = 4;
+      
+    /**
+     * Initialize a layer from a given image path
+     * 
+     * From an upload form, you can give the "tmp_name" path
+     * 
+     * @param string $path
+     * 
+     * @return ImageWorkshopLayer
+     */
+    public static function initFromPath($path)
+    {
+        if (file_exists($path) && !is_dir($path)) {
+            
+            if (!is_readable($path)) {
+                throw new ImageWorkshopException('Can\'t open the file at "'.$path.'" : file is not writable, did you check permissions (755 / 777) ?', static::ERROR_NOT_WRITABLE_FILE);
+            }
+            
+            $imageSizeInfos = @getImageSize($path);
+            $mimeContentType = explode('/', $imageSizeInfos['mime']);
+            
+            if (!$mimeContentType || !array_key_exists(1, $mimeContentType)) {
+                throw new ImageWorkshopException('Not an image file (jpeg/png/gif) at "'.$path.'"', static::ERROR_NOT_AN_IMAGE_FILE);
+            }
+            
+            $mimeContentType = $mimeContentType[1];
+            
+            switch ($mimeContentType) {
+                case 'jpeg':
+                    $image = imageCreateFromJPEG($path);
+                break;
+
+                case 'gif':
+                    $image = imageCreateFromGIF($path);
+                break;
+
+                case 'png':
+                    $image = imageCreateFromPNG($path);
+                break;
+
+                default:
+                    throw new ImageWorkshopException('Not an image file (jpeg/png/gif) at "'.$path.'"', static::ERROR_NOT_AN_IMAGE_FILE);
+                break;
+            }
+            
+            return new ImageWorkshopLayer($image);
+        }
+        
+        throw new ImageWorkshopException('No such file found at "'.$path.'"', static::ERROR_IMAGE_NOT_FOUND);
+    }
+    
+    /**
+     * Initialize a text layer
+     * 
+     * @param string $text
+     * @param string $fontPath
+     * @param integer $fontSize
+     * @param string $fontColor
+     * @param integer $textRotation
+     * @param integer $backgroundColor
+     * 
+     * @return ImageWorkshopLayer
+     */
+    public static function initTextLayer($text, $fontPath, $fontSize = 13, $fontColor = 'ffffff', $textRotation = 0, $backgroundColor = null)
+    {
+        $textDimensions = ImageWorkshopLib::getTextBoxDimension($fontSize, $textRotation, $fontPath, $text);
+
+        $layer = static::initVirginLayer($textDimensions['width'], $textDimensions['height'], $backgroundColor);
+        $layer->write($text, $fontPath, $fontSize, $fontColor, $textDimensions['left'], $textDimensions['top'], $textRotation);
+        
+        return $layer;
+    }
+    
+    /**
+     * Initialize a new virgin layer
+     * 
+     * @param integer $width
+     * @param integer $height
+     * @param string $backgroundColor
+     * 
+     * @return ImageWorkshopLayer
+     */
+    public static function initVirginLayer($width = 100, $height = 100, $backgroundColor = null)
+    {
+        $opacity = 0;
+        
+        if (!$backgroundColor || $backgroundColor == 'transparent') {
+            $opacity = 127;
+            $backgroundColor = 'ffffff';
+        }
+        
+        return new ImageWorkshopLayer(ImageWorkshopLib::generateImage($width, $height, $backgroundColor, $opacity));
+    }
+    
+    /**
+     * Initialize a layer from a resource image var
+     * 
+     * @param \resource $image
+     * 
+     * @return ImageWorkshopLayer
+     */
+    public static function initFromResourceVar($image)
+    {
+        return new ImageWorkshopLayer($image);
+    }
+    
+    /**
+     * Initialize a layer from a string (obtains with file_get_contents, cURL...)
+     * 
+     * This not recommanded to initialize JPEG string with this method, GD displays bugs !
+     * 
+     * @param string $imageString
+     * 
+     * @return ImageWorkshopLayer
+     */
+    public static function initFromString($imageString)
+    {
+        if (!$image = @imageCreateFromString($imageString)) {
+            throw new ImageWorkshopException('Can\'t generate an image from the given string.', static::ERROR_CREATE_IMAGE_FROM_STRING);
+        }
+        
+        return new ImageWorkshopLayer($image);
+    }
+}

Slim/Environment.php

@@ -0,0 +1,224 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * Environment
+ *
+ * This class creates and returns a key/value array of common
+ * environment variables for the current HTTP request.
+ *
+ * This is a singleton class; derived environment variables will
+ * be common across multiple Slim applications.
+ *
+ * This class matches the Rack (Ruby) specification as closely
+ * as possible. More information available below.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.6.0
+ */
+class Environment implements \ArrayAccess, \IteratorAggregate
+{
+    /**
+     * @var array
+     */
+    protected $properties;
+
+    /**
+     * @var \Slim\Environment
+     */
+    protected static $environment;
+
+    /**
+     * Get environment instance (singleton)
+     *
+     * This creates and/or returns an environment instance (singleton)
+     * derived from $_SERVER variables. You may override the global server
+     * variables by using `\Slim\Environment::mock()` instead.
+     *
+     * @param  bool             $refresh Refresh properties using global server variables?
+     * @return \Slim\Environment
+     */
+    public static function getInstance($refresh = false)
+    {
+        if (is_null(self::$environment) || $refresh) {
+            self::$environment = new self();
+        }
+
+        return self::$environment;
+    }
+
+    /**
+     * Get mock environment instance
+     *
+     * @param  array       $userSettings
+     * @return \Slim\Environment
+     */
+    public static function mock($userSettings = array())
+    {
+        $defaults = array(
+            'REQUEST_METHOD' => 'GET',
+            'SCRIPT_NAME' => '',
+            'PATH_INFO' => '',
+            'QUERY_STRING' => '',
+            'SERVER_NAME' => 'localhost',
+            'SERVER_PORT' => 80,
+            'ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'ACCEPT_LANGUAGE' => 'en-US,en;q=0.8',
+            'ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
+            'USER_AGENT' => 'Slim Framework',
+            'REMOTE_ADDR' => '127.0.0.1',
+            'slim.url_scheme' => 'http',
+            'slim.input' => '',
+            'slim.errors' => @fopen('php://stderr', 'w')
+        );
+        self::$environment = new self(array_merge($defaults, $userSettings));
+
+        return self::$environment;
+    }
+
+    /**
+     * Constructor (private access)
+     *
+     * @param  array|null $settings If present, these are used instead of global server variables
+     */
+    private function __construct($settings = null)
+    {
+        if ($settings) {
+            $this->properties = $settings;
+        } else {
+            $env = array();
+
+            //The HTTP request method
+            $env['REQUEST_METHOD'] = $_SERVER['REQUEST_METHOD'];
+
+            //The IP
+            $env['REMOTE_ADDR'] = $_SERVER['REMOTE_ADDR'];
+
+            // Server params
+            $scriptName = $_SERVER['SCRIPT_NAME']; // <-- "/foo/index.php"
+            $requestUri = $_SERVER['REQUEST_URI']; // <-- "/foo/bar?test=abc" or "/foo/index.php/bar?test=abc"
+            $queryString = isset($_SERVER['QUERY_STRING']) ? $_SERVER['QUERY_STRING'] : ''; // <-- "test=abc" or ""
+
+            // Physical path
+            if (strpos($requestUri, $scriptName) !== false) {
+                $physicalPath = $scriptName; // <-- Without rewriting
+            } else {
+                $physicalPath = str_replace('\\', '', dirname($scriptName)); // <-- With rewriting
+            }
+            $env['SCRIPT_NAME'] = rtrim($physicalPath, '/'); // <-- Remove trailing slashes
+
+            // Virtual path
+            $env['PATH_INFO'] = substr_replace($requestUri, '', 0, strlen($physicalPath)); // <-- Remove physical path
+            $env['PATH_INFO'] = str_replace('?' . $queryString, '', $env['PATH_INFO']); // <-- Remove query string
+            $env['PATH_INFO'] = '/' . ltrim($env['PATH_INFO'], '/'); // <-- Ensure leading slash
+
+            // Query string (without leading "?")
+            $env['QUERY_STRING'] = $queryString;
+
+            //Name of server host that is running the script
+            $env['SERVER_NAME'] = $_SERVER['SERVER_NAME'];
+
+            //Number of server port that is running the script
+            $env['SERVER_PORT'] = $_SERVER['SERVER_PORT'];
+
+            //HTTP request headers (retains HTTP_ prefix to match $_SERVER)
+            $headers = \Slim\Http\Headers::extract($_SERVER);
+            foreach ($headers as $key => $value) {
+                $env[$key] = $value;
+            }
+
+            //Is the application running under HTTPS or HTTP protocol?
+            $env['slim.url_scheme'] = empty($_SERVER['HTTPS']) || $_SERVER['HTTPS'] === 'off' ? 'http' : 'https';
+
+            //Input stream (readable one time only; not available for multipart/form-data requests)
+            $rawInput = @file_get_contents('php://input');
+            if (!$rawInput) {
+                $rawInput = '';
+            }
+            $env['slim.input'] = $rawInput;
+
+            //Error stream
+            $env['slim.errors'] = @fopen('php://stderr', 'w');
+
+            $this->properties = $env;
+        }
+    }
+
+    /**
+     * Array Access: Offset Exists
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->properties[$offset]);
+    }
+
+    /**
+     * Array Access: Offset Get
+     */
+    public function offsetGet($offset)
+    {
+        if (isset($this->properties[$offset])) {
+            return $this->properties[$offset];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Array Access: Offset Set
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->properties[$offset] = $value;
+    }
+
+    /**
+     * Array Access: Offset Unset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->properties[$offset]);
+    }
+
+    /**
+     * IteratorAggregate
+     *
+     * @return \ArrayIterator
+     */
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->properties);
+    }
+}

Slim/Exception/Pass.php

@@ -0,0 +1,49 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Exception;
+
+/**
+ * Pass Exception
+ *
+ * This Exception will cause the Router::dispatch method
+ * to skip the current matching route and continue to the next
+ * matching route. If no subsequent routes are found, a
+ * HTTP 404 Not Found response will be sent to the client.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Pass extends \Exception
+{
+}

Slim/Exception/Stop.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Exception;
+
+/**
+ * Stop Exception
+ *
+ * This Exception is thrown when the Slim application needs to abort
+ * processing and return control flow to the outer PHP script.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Stop extends \Exception
+{
+}

Slim/Helper/Set.php

@@ -0,0 +1,246 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Helper;
+
+class Set implements \ArrayAccess, \Countable, \IteratorAggregate
+{
+    /**
+     * Key-value array of arbitrary data
+     * @var array
+     */
+    protected $data = array();
+
+    /**
+     * Constructor
+     * @param array $items Pre-populate set with this key-value array
+     */
+    public function __construct($items = array())
+    {
+        $this->replace($items);
+    }
+
+    /**
+     * Normalize data key
+     *
+     * Used to transform data key into the necessary
+     * key format for this set. Used in subclasses
+     * like \Slim\Http\Headers.
+     *
+     * @param  string $key The data key
+     * @return mixed       The transformed/normalized data key
+     */
+    protected function normalizeKey($key)
+    {
+        return $key;
+    }
+
+    /**
+     * Set data key to value
+     * @param string $key   The data key
+     * @param mixed  $value The data value
+     */
+    public function set($key, $value)
+    {
+        $this->data[$this->normalizeKey($key)] = $value;
+    }
+
+    /**
+     * Get data value with key
+     * @param  string $key     The data key
+     * @param  mixed  $default The value to return if data key does not exist
+     * @return mixed           The data value, or the default value
+     */
+    public function get($key, $default = null)
+    {
+        if ($this->has($key)) {
+            $isInvokable = is_object($this->data[$this->normalizeKey($key)]) && method_exists($this->data[$this->normalizeKey($key)], '__invoke');
+
+            return $isInvokable ? $this->data[$this->normalizeKey($key)]($this) : $this->data[$this->normalizeKey($key)];
+        }
+
+        return $default;
+    }
+
+    /**
+     * Add data to set
+     * @param array $items Key-value array of data to append to this set
+     */
+    public function replace($items)
+    {
+        foreach ($items as $key => $value) {
+            $this->set($key, $value); // Ensure keys are normalized
+        }
+    }
+
+    /**
+     * Fetch set data
+     * @return array This set's key-value data array
+     */
+    public function all()
+    {
+        return $this->data;
+    }
+
+    /**
+     * Fetch set data keys
+     * @return array This set's key-value data array keys
+     */
+    public function keys()
+    {
+        return array_keys($this->data);
+    }
+
+    /**
+     * Does this set contain a key?
+     * @param  string  $key The data key
+     * @return boolean
+     */
+    public function has($key)
+    {
+        return array_key_exists($this->normalizeKey($key), $this->data);
+    }
+
+    /**
+     * Remove value with key from this set
+     * @param  string $key The data key
+     */
+    public function remove($key)
+    {
+        unset($this->data[$this->normalizeKey($key)]);
+    }
+
+    /**
+     * Property Overloading
+     */
+
+    public function __get($key)
+    {
+        return $this->get($key);
+    }
+
+    public function __set($key, $value)
+    {
+        $this->set($key, $value);
+    }
+
+    public function __isset($key)
+    {
+        return $this->has($key);
+    }
+
+    public function __unset($key)
+    {
+        return $this->remove($key);
+    }
+
+    /**
+     * Clear all values
+     */
+    public function clear()
+    {
+        $this->data = array();
+    }
+
+    /**
+     * Array Access
+     */
+
+    public function offsetExists($offset)
+    {
+        return $this->has($offset);
+    }
+
+    public function offsetGet($offset)
+    {
+        return $this->get($offset);
+    }
+
+    public function offsetSet($offset, $value)
+    {
+        $this->set($offset, $value);
+    }
+
+    public function offsetUnset($offset)
+    {
+        $this->remove($offset);
+    }
+
+    /**
+     * Countable
+     */
+
+    public function count()
+    {
+        return count($this->data);
+    }
+
+    /**
+     * IteratorAggregate
+     */
+
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->data);
+    }
+
+    /**
+     * Ensure a value or object will remain globally unique
+     * @param  string  $key   The value or object name
+     * @param  Closure        The closure that defines the object
+     * @return mixed
+     */
+    public function singleton($key, $value)
+    {
+        $this->set($key, function ($c) use ($value) {
+            static $object;
+
+            if (null === $object) {
+                $object = $value($c);
+            }
+
+            return $object;
+        });
+    }
+
+    /**
+     * Protect closure from being directly invoked
+     * @param  Closure $callable A closure to keep from being invoked and evaluated
+     * @return Closure
+     */
+    public function protect(\Closure $callable)
+    {
+        return function () use ($callable) {
+            return $callable;
+        };
+    }
+}

Slim/Http/Cookies.php

@@ -0,0 +1,91 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Http;
+
+class Cookies extends \Slim\Helper\Set
+{
+    /**
+     * Default cookie settings
+     * @var array
+     */
+    protected $defaults = array(
+        'value' => '',
+        'domain' => null,
+        'path' => null,
+        'expires' => null,
+        'secure' => false,
+        'httponly' => false
+    );
+
+    /**
+     * Set cookie
+     *
+     * The second argument may be a single scalar value, in which case
+     * it will be merged with the default settings and considered the `value`
+     * of the merged result.
+     *
+     * The second argument may also be an array containing any or all of
+     * the keys shown in the default settings above. This array will be
+     * merged with the defaults shown above.
+     *
+     * @param string $key   Cookie name
+     * @param mixed  $value Cookie settings
+     */
+    public function set($key, $value)
+    {
+        if (is_array($value)) {
+            $cookieSettings = array_replace($this->defaults, $value);
+        } else {
+            $cookieSettings = array_replace($this->defaults, array('value' => $value));
+        }
+        parent::set($key, $cookieSettings);
+    }
+
+    /**
+     * Remove cookie
+     *
+     * Unlike \Slim\Helper\Set, this will actually *set* a cookie with
+     * an expiration date in the past. This expiration date will force
+     * the client-side cache to remove its cookie with the given name
+     * and settings.
+     *
+     * @param  string $key      Cookie name
+     * @param  array  $settings Optional cookie settings
+     */
+    public function remove($key, $settings = array())
+    {
+        $settings['value'] = '';
+        $settings['expires'] = time() - 86400;
+        $this->set($key, array_replace($this->defaults, $settings));
+    }
+}

Slim/Http/Headers.php

@@ -0,0 +1,104 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Http;
+
+ /**
+  * HTTP Headers
+  *
+  * @package Slim
+  * @author  Josh Lockhart
+  * @since   1.6.0
+  */
+class Headers extends \Slim\Helper\Set
+{
+    /********************************************************************************
+    * Static interface
+    *******************************************************************************/
+
+    /**
+     * Special-case HTTP headers that are otherwise unidentifiable as HTTP headers.
+     * Typically, HTTP headers in the $_SERVER array will be prefixed with
+     * `HTTP_` or `X_`. These are not so we list them here for later reference.
+     *
+     * @var array
+     */
+    protected static $special = array(
+        'CONTENT_TYPE',
+        'CONTENT_LENGTH',
+        'PHP_AUTH_USER',
+        'PHP_AUTH_PW',
+        'PHP_AUTH_DIGEST',
+        'AUTH_TYPE'
+    );
+
+    /**
+     * Extract HTTP headers from an array of data (e.g. $_SERVER)
+     * @param  array $data
+     * @return array
+     */
+    public static function extract($data)
+    {
+        $results = array();
+        foreach ($data as $key => $value) {
+            $key = strtoupper($key);
+            if (strpos($key, 'X_') === 0 || strpos($key, 'HTTP_') === 0 || in_array($key, static::$special)) {
+                if ($key === 'HTTP_CONTENT_LENGTH') {
+                    continue;
+                }
+                $results[$key] = $value;
+            }
+        }
+
+        return $results;
+    }
+
+    /********************************************************************************
+    * Instance interface
+    *******************************************************************************/
+
+    /**
+     * Transform header name into canonical form
+     * @param  string $key
+     * @return string
+     */
+    protected function normalizeKey($key)
+    {
+        $key = strtolower($key);
+        $key = str_replace(array('-', '_'), ' ', $key);
+        $key = preg_replace('#^http #', '', $key);
+        $key = ucwords($key);
+        $key = str_replace(' ', '-', $key);
+
+        return $key;
+    }
+}

Slim/Http/Request.php

@@ -0,0 +1,617 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Http;
+
+/**
+ * Slim HTTP Request
+ *
+ * This class provides a human-friendly interface to the Slim environment variables;
+ * environment variables are passed by reference and will be modified directly.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Request
+{
+    const METHOD_HEAD = 'HEAD';
+    const METHOD_GET = 'GET';
+    const METHOD_POST = 'POST';
+    const METHOD_PUT = 'PUT';
+    const METHOD_PATCH = 'PATCH';
+    const METHOD_DELETE = 'DELETE';
+    const METHOD_OPTIONS = 'OPTIONS';
+    const METHOD_OVERRIDE = '_METHOD';
+
+    /**
+     * @var array
+     */
+    protected static $formDataMediaTypes = array('application/x-www-form-urlencoded');
+
+    /**
+     * Application Environment
+     * @var \Slim\Environment
+     */
+    protected $env;
+
+    /**
+     * HTTP Headers
+     * @var \Slim\Http\Headers
+     */
+    public $headers;
+
+    /**
+     * HTTP Cookies
+     * @var \Slim\Helper\Set
+     */
+    public $cookies;
+
+    /**
+     * Constructor
+     * @param \Slim\Environment $env
+     */
+    public function __construct(\Slim\Environment $env)
+    {
+        $this->env = $env;
+        $this->headers = new \Slim\Http\Headers(\Slim\Http\Headers::extract($env));
+        $this->cookies = new \Slim\Helper\Set(\Slim\Http\Util::parseCookieHeader($env['HTTP_COOKIE']));
+    }
+
+    /**
+     * Get HTTP method
+     * @return string
+     */
+    public function getMethod()
+    {
+        return $this->env['REQUEST_METHOD'];
+    }
+
+    /**
+     * Is this a GET request?
+     * @return bool
+     */
+    public function isGet()
+    {
+        return $this->getMethod() === self::METHOD_GET;
+    }
+
+    /**
+     * Is this a POST request?
+     * @return bool
+     */
+    public function isPost()
+    {
+        return $this->getMethod() === self::METHOD_POST;
+    }
+
+    /**
+     * Is this a PUT request?
+     * @return bool
+     */
+    public function isPut()
+    {
+        return $this->getMethod() === self::METHOD_PUT;
+    }
+
+    /**
+     * Is this a PATCH request?
+     * @return bool
+     */
+    public function isPatch()
+    {
+        return $this->getMethod() === self::METHOD_PATCH;
+    }
+
+    /**
+     * Is this a DELETE request?
+     * @return bool
+     */
+    public function isDelete()
+    {
+        return $this->getMethod() === self::METHOD_DELETE;
+    }
+
+    /**
+     * Is this a HEAD request?
+     * @return bool
+     */
+    public function isHead()
+    {
+        return $this->getMethod() === self::METHOD_HEAD;
+    }
+
+    /**
+     * Is this a OPTIONS request?
+     * @return bool
+     */
+    public function isOptions()
+    {
+        return $this->getMethod() === self::METHOD_OPTIONS;
+    }
+
+    /**
+     * Is this an AJAX request?
+     * @return bool
+     */
+    public function isAjax()
+    {
+        if ($this->params('isajax')) {
+            return true;
+        } elseif (isset($this->headers['X_REQUESTED_WITH']) && $this->headers['X_REQUESTED_WITH'] === 'XMLHttpRequest') {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Is this an XHR request? (alias of Slim_Http_Request::isAjax)
+     * @return bool
+     */
+    public function isXhr()
+    {
+        return $this->isAjax();
+    }
+
+    /**
+     * Fetch GET and POST data
+     *
+     * This method returns a union of GET and POST data as a key-value array, or the value
+     * of the array key if requested; if the array key does not exist, NULL is returned,
+     * unless there is a default value specified.
+     *
+     * @param  string           $key
+     * @param  mixed            $default
+     * @return array|mixed|null
+     */
+    public function params($key = null, $default = null)
+    {
+        $union = array_merge($this->get(), $this->post());
+        if ($key) {
+            return isset($union[$key]) ? $union[$key] : $default;
+        }
+
+        return $union;
+    }
+
+    /**
+     * Fetch GET data
+     *
+     * This method returns a key-value array of data sent in the HTTP request query string, or
+     * the value of the array key if requested; if the array key does not exist, NULL is returned.
+     *
+     * @param  string           $key
+     * @param  mixed            $default Default return value when key does not exist
+     * @return array|mixed|null
+     */
+    public function get($key = null, $default = null)
+    {
+        if (!isset($this->env['slim.request.query_hash'])) {
+            $output = array();
+            if (function_exists('mb_parse_str') && !isset($this->env['slim.tests.ignore_multibyte'])) {
+                mb_parse_str($this->env['QUERY_STRING'], $output);
+            } else {
+                parse_str($this->env['QUERY_STRING'], $output);
+            }
+            $this->env['slim.request.query_hash'] = Util::stripSlashesIfMagicQuotes($output);
+        }
+        if ($key) {
+            if (isset($this->env['slim.request.query_hash'][$key])) {
+                return $this->env['slim.request.query_hash'][$key];
+            } else {
+                return $default;
+            }
+        } else {
+            return $this->env['slim.request.query_hash'];
+        }
+    }
+
+    /**
+     * Fetch POST data
+     *
+     * This method returns a key-value array of data sent in the HTTP request body, or
+     * the value of a hash key if requested; if the array key does not exist, NULL is returned.
+     *
+     * @param  string           $key
+     * @param  mixed            $default Default return value when key does not exist
+     * @return array|mixed|null
+     * @throws \RuntimeException If environment input is not available
+     */
+    public function post($key = null, $default = null)
+    {
+        if (!isset($this->env['slim.input'])) {
+            throw new \RuntimeException('Missing slim.input in environment variables');
+        }
+        if (!isset($this->env['slim.request.form_hash'])) {
+            $this->env['slim.request.form_hash'] = array();
+            if ($this->isFormData() && is_string($this->env['slim.input'])) {
+                $output = array();
+                if (function_exists('mb_parse_str') && !isset($this->env['slim.tests.ignore_multibyte'])) {
+                    mb_parse_str($this->env['slim.input'], $output);
+                } else {
+                    parse_str($this->env['slim.input'], $output);
+                }
+                $this->env['slim.request.form_hash'] = Util::stripSlashesIfMagicQuotes($output);
+            } else {
+                $this->env['slim.request.form_hash'] = Util::stripSlashesIfMagicQuotes($_POST);
+            }
+        }
+        if ($key) {
+            if (isset($this->env['slim.request.form_hash'][$key])) {
+                return $this->env['slim.request.form_hash'][$key];
+            } else {
+                return $default;
+            }
+        } else {
+            return $this->env['slim.request.form_hash'];
+        }
+    }
+
+    /**
+     * Fetch PUT data (alias for \Slim\Http\Request::post)
+     * @param  string           $key
+     * @param  mixed            $default Default return value when key does not exist
+     * @return array|mixed|null
+     */
+    public function put($key = null, $default = null)
+    {
+        return $this->post($key, $default);
+    }
+
+    /**
+     * Fetch PATCH data (alias for \Slim\Http\Request::post)
+     * @param  string           $key
+     * @param  mixed            $default Default return value when key does not exist
+     * @return array|mixed|null
+     */
+    public function patch($key = null, $default = null)
+    {
+        return $this->post($key, $default);
+    }
+
+    /**
+     * Fetch DELETE data (alias for \Slim\Http\Request::post)
+     * @param  string           $key
+     * @param  mixed            $default Default return value when key does not exist
+     * @return array|mixed|null
+     */
+    public function delete($key = null, $default = null)
+    {
+        return $this->post($key, $default);
+    }
+
+    /**
+     * Fetch COOKIE data
+     *
+     * This method returns a key-value array of Cookie data sent in the HTTP request, or
+     * the value of a array key if requested; if the array key does not exist, NULL is returned.
+     *
+     * @param  string            $key
+     * @return array|string|null
+     */
+    public function cookies($key = null)
+    {
+        if ($key) {
+            return $this->cookies->get($key);
+        }
+
+        return $this->cookies;
+        // if (!isset($this->env['slim.request.cookie_hash'])) {
+        //     $cookieHeader = isset($this->env['COOKIE']) ? $this->env['COOKIE'] : '';
+        //     $this->env['slim.request.cookie_hash'] = Util::parseCookieHeader($cookieHeader);
+        // }
+        // if ($key) {
+        //     if (isset($this->env['slim.request.cookie_hash'][$key])) {
+        //         return $this->env['slim.request.cookie_hash'][$key];
+        //     } else {
+        //         return null;
+        //     }
+        // } else {
+        //     return $this->env['slim.request.cookie_hash'];
+        // }
+    }
+
+    /**
+     * Does the Request body contain parsed form data?
+     * @return bool
+     */
+    public function isFormData()
+    {
+        $method = isset($this->env['slim.method_override.original_method']) ? $this->env['slim.method_override.original_method'] : $this->getMethod();
+
+        return ($method === self::METHOD_POST && is_null($this->getContentType())) || in_array($this->getMediaType(), self::$formDataMediaTypes);
+    }
+
+    /**
+     * Get Headers
+     *
+     * This method returns a key-value array of headers sent in the HTTP request, or
+     * the value of a hash key if requested; if the array key does not exist, NULL is returned.
+     *
+     * @param  string $key
+     * @param  mixed  $default The default value returned if the requested header is not available
+     * @return mixed
+     */
+    public function headers($key = null, $default = null)
+    {
+        if ($key) {
+            return $this->headers->get($key, $default);
+        }
+
+        return $this->headers;
+        // if ($key) {
+        //     $key = strtoupper($key);
+        //     $key = str_replace('-', '_', $key);
+        //     $key = preg_replace('@^HTTP_@', '', $key);
+        //     if (isset($this->env[$key])) {
+        //         return $this->env[$key];
+        //     } else {
+        //         return $default;
+        //     }
+        // } else {
+        //     $headers = array();
+        //     foreach ($this->env as $key => $value) {
+        //         if (strpos($key, 'slim.') !== 0) {
+        //             $headers[$key] = $value;
+        //         }
+        //     }
+        //
+        //     return $headers;
+        // }
+    }
+
+    /**
+     * Get Body
+     * @return string
+     */
+    public function getBody()
+    {
+        return $this->env['slim.input'];
+    }
+
+    /**
+     * Get Content Type
+     * @return string|null
+     */
+    public function getContentType()
+    {
+        return $this->headers->get('CONTENT_TYPE');
+    }
+
+    /**
+     * Get Media Type (type/subtype within Content Type header)
+     * @return string|null
+     */
+    public function getMediaType()
+    {
+        $contentType = $this->getContentType();
+        if ($contentType) {
+            $contentTypeParts = preg_split('/\s*[;,]\s*/', $contentType);
+
+            return strtolower($contentTypeParts[0]);
+        }
+
+        return null;
+    }
+
+    /**
+     * Get Media Type Params
+     * @return array
+     */
+    public function getMediaTypeParams()
+    {
+        $contentType = $this->getContentType();
+        $contentTypeParams = array();
+        if ($contentType) {
+            $contentTypeParts = preg_split('/\s*[;,]\s*/', $contentType);
+            $contentTypePartsLength = count($contentTypeParts);
+            for ($i = 1; $i < $contentTypePartsLength; $i++) {
+                $paramParts = explode('=', $contentTypeParts[$i]);
+                $contentTypeParams[strtolower($paramParts[0])] = $paramParts[1];
+            }
+        }
+
+        return $contentTypeParams;
+    }
+
+    /**
+     * Get Content Charset
+     * @return string|null
+     */
+    public function getContentCharset()
+    {
+        $mediaTypeParams = $this->getMediaTypeParams();
+        if (isset($mediaTypeParams['charset'])) {
+            return $mediaTypeParams['charset'];
+        }
+
+        return null;
+    }
+
+    /**
+     * Get Content-Length
+     * @return int
+     */
+    public function getContentLength()
+    {
+        return $this->headers->get('CONTENT_LENGTH', 0);
+    }
+
+    /**
+     * Get Host
+     * @return string
+     */
+    public function getHost()
+    {
+        if (isset($this->env['HTTP_HOST'])) {
+            if (strpos($this->env['HTTP_HOST'], ':') !== false) {
+                $hostParts = explode(':', $this->env['HTTP_HOST']);
+
+                return $hostParts[0];
+            }
+
+            return $this->env['HTTP_HOST'];
+        }
+
+        return $this->env['SERVER_NAME'];
+    }
+
+    /**
+     * Get Host with Port
+     * @return string
+     */
+    public function getHostWithPort()
+    {
+        return sprintf('%s:%s', $this->getHost(), $this->getPort());
+    }
+
+    /**
+     * Get Port
+     * @return int
+     */
+    public function getPort()
+    {
+        return (int)$this->env['SERVER_PORT'];
+    }
+
+    /**
+     * Get Scheme (https or http)
+     * @return string
+     */
+    public function getScheme()
+    {
+        return $this->env['slim.url_scheme'];
+    }
+
+    /**
+     * Get Script Name (physical path)
+     * @return string
+     */
+    public function getScriptName()
+    {
+        return $this->env['SCRIPT_NAME'];
+    }
+
+    /**
+     * LEGACY: Get Root URI (alias for Slim_Http_Request::getScriptName)
+     * @return string
+     */
+    public function getRootUri()
+    {
+        return $this->getScriptName();
+    }
+
+    /**
+     * Get Path (physical path + virtual path)
+     * @return string
+     */
+    public function getPath()
+    {
+        return $this->getScriptName() . $this->getPathInfo();
+    }
+
+    /**
+     * Get Path Info (virtual path)
+     * @return string
+     */
+    public function getPathInfo()
+    {
+        return $this->env['PATH_INFO'];
+    }
+
+    /**
+     * LEGACY: Get Resource URI (alias for Slim_Http_Request::getPathInfo)
+     * @return string
+     */
+    public function getResourceUri()
+    {
+        return $this->getPathInfo();
+    }
+
+    /**
+     * Get URL (scheme + host [ + port if non-standard ])
+     * @return string
+     */
+    public function getUrl()
+    {
+        $url = $this->getScheme() . '://' . $this->getHost();
+        if (($this->getScheme() === 'https' && $this->getPort() !== 443) || ($this->getScheme() === 'http' && $this->getPort() !== 80)) {
+            $url .= sprintf(':%s', $this->getPort());
+        }
+
+        return $url;
+    }
+
+    /**
+     * Get IP
+     * @return string
+     */
+    public function getIp()
+    {
+        $keys = array('X_FORWARDED_FOR', 'HTTP_X_FORWARDED_FOR', 'CLIENT_IP', 'REMOTE_ADDR');
+        foreach ($keys as $key) {
+            if (isset($this->env[$key])) {
+                return $this->env[$key];
+            }
+        }
+
+        return $this->env['REMOTE_ADDR'];
+    }
+
+    /**
+     * Get Referrer
+     * @return string|null
+     */
+    public function getReferrer()
+    {
+        return $this->headers->get('HTTP_REFERER');
+    }
+
+    /**
+     * Get Referer (for those who can't spell)
+     * @return string|null
+     */
+    public function getReferer()
+    {
+        return $this->getReferrer();
+    }
+
+    /**
+     * Get User Agent
+     * @return string|null
+     */
+    public function getUserAgent()
+    {
+        return $this->headers->get('HTTP_USER_AGENT');
+    }
+}

Slim/Http/Response.php

@@ -0,0 +1,512 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Http;
+
+/**
+ * Response
+ *
+ * This is a simple abstraction over top an HTTP response. This
+ * provides methods to set the HTTP status, the HTTP headers,
+ * and the HTTP body.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Response implements \ArrayAccess, \Countable, \IteratorAggregate
+{
+    /**
+     * @var int HTTP status code
+     */
+    protected $status;
+
+    /**
+     * @var \Slim\Http\Headers
+     */
+    public $headers;
+
+    /**
+     * @var \Slim\Http\Cookies
+     */
+    public $cookies;
+
+    /**
+     * @var string HTTP response body
+     */
+    protected $body;
+
+    /**
+     * @var int Length of HTTP response body
+     */
+    protected $length;
+
+    /**
+     * @var array HTTP response codes and messages
+     */
+    protected static $messages = array(
+        //Informational 1xx
+        100 => '100 Continue',
+        101 => '101 Switching Protocols',
+        //Successful 2xx
+        200 => '200 OK',
+        201 => '201 Created',
+        202 => '202 Accepted',
+        203 => '203 Non-Authoritative Information',
+        204 => '204 No Content',
+        205 => '205 Reset Content',
+        206 => '206 Partial Content',
+        //Redirection 3xx
+        300 => '300 Multiple Choices',
+        301 => '301 Moved Permanently',
+        302 => '302 Found',
+        303 => '303 See Other',
+        304 => '304 Not Modified',
+        305 => '305 Use Proxy',
+        306 => '306 (Unused)',
+        307 => '307 Temporary Redirect',
+        //Client Error 4xx
+        400 => '400 Bad Request',
+        401 => '401 Unauthorized',
+        402 => '402 Payment Required',
+        403 => '403 Forbidden',
+        404 => '404 Not Found',
+        405 => '405 Method Not Allowed',
+        406 => '406 Not Acceptable',
+        407 => '407 Proxy Authentication Required',
+        408 => '408 Request Timeout',
+        409 => '409 Conflict',
+        410 => '410 Gone',
+        411 => '411 Length Required',
+        412 => '412 Precondition Failed',
+        413 => '413 Request Entity Too Large',
+        414 => '414 Request-URI Too Long',
+        415 => '415 Unsupported Media Type',
+        416 => '416 Requested Range Not Satisfiable',
+        417 => '417 Expectation Failed',
+        418 => '418 I\'m a teapot',
+        422 => '422 Unprocessable Entity',
+        423 => '423 Locked',
+        //Server Error 5xx
+        500 => '500 Internal Server Error',
+        501 => '501 Not Implemented',
+        502 => '502 Bad Gateway',
+        503 => '503 Service Unavailable',
+        504 => '504 Gateway Timeout',
+        505 => '505 HTTP Version Not Supported'
+    );
+
+    /**
+     * Constructor
+     * @param string                   $body   The HTTP response body
+     * @param int                      $status The HTTP response status
+     * @param \Slim\Http\Headers|array $headers The HTTP response headers
+     */
+    public function __construct($body = '', $status = 200, $headers = array())
+    {
+        $this->setStatus($status);
+        $this->headers = new \Slim\Http\Headers(array('Content-Type' => 'text/html'));
+        $this->headers->replace($headers);
+        $this->cookies = new \Slim\Http\Cookies();
+        $this->write($body);
+    }
+
+    public function getStatus()
+    {
+        return $this->status;
+    }
+
+    public function setStatus($status)
+    {
+        $this->status = (int)$status;
+    }
+
+    /**
+     * DEPRECATION WARNING! Use `getStatus` or `setStatus` instead.
+     *
+     * Get and set status
+     * @param  int|null $status
+     * @return int
+     */
+    public function status($status = null)
+    {
+        if (!is_null($status)) {
+            $this->status = (int) $status;
+        }
+
+        return $this->status;
+    }
+
+    /**
+     * DEPRECATION WARNING! Access `headers` property directly.
+     *
+     * Get and set header
+     * @param  string      $name  Header name
+     * @param  string|null $value Header value
+     * @return string      Header value
+     */
+    public function header($name, $value = null)
+    {
+        if (!is_null($value)) {
+            $this->headers->set($name, $value);
+        }
+
+        return $this->headers->get($name);
+    }
+
+    /**
+     * DEPRECATION WARNING! Access `headers` property directly.
+     *
+     * Get headers
+     * @return \Slim\Http\Headers
+     */
+    public function headers()
+    {
+        return $this->headers;
+    }
+
+    public function getBody()
+    {
+        return $this->body;
+    }
+
+    public function setBody($content)
+    {
+        $this->write($content, true);
+    }
+
+    /**
+     * DEPRECATION WARNING! use `getBody` or `setBody` instead.
+     *
+     * Get and set body
+     * @param  string|null $body Content of HTTP response body
+     * @return string
+     */
+    public function body($body = null)
+    {
+        if (!is_null($body)) {
+            $this->write($body, true);
+        }
+
+        return $this->body;
+    }
+
+    /**
+     * Append HTTP response body
+     * @param  string   $body       Content to append to the current HTTP response body
+     * @param  bool     $replace    Overwrite existing response body?
+     * @return string               The updated HTTP response body
+     */
+    public function write($body, $replace = false)
+    {
+        if ($replace) {
+            $this->body = $body;
+        } else {
+            $this->body .= (string)$body;
+        }
+        $this->length = strlen($this->body);
+
+        return $this->body;
+    }
+
+    public function getLength()
+    {
+        return $this->length;
+    }
+
+    /**
+     * DEPRECATION WARNING! Use `getLength` or `write` or `body` instead.
+     *
+     * Get and set length
+     * @param  int|null $length
+     * @return int
+     */
+    public function length($length = null)
+    {
+        if (!is_null($length)) {
+            $this->length = (int) $length;
+        }
+
+        return $this->length;
+    }
+
+    /**
+     * Finalize
+     *
+     * This prepares this response and returns an array
+     * of [status, headers, body]. This array is passed to outer middleware
+     * if available or directly to the Slim run method.
+     *
+     * @return array[int status, array headers, string body]
+     */
+    public function finalize()
+    {
+        // Prepare response
+        if (in_array($this->status, array(204, 304))) {
+            $this->headers->remove('Content-Type');
+            $this->headers->remove('Content-Length');
+            $this->setBody('');
+        }
+
+        return array($this->status, $this->headers, $this->body);
+    }
+
+    /**
+     * DEPRECATION WARNING! Access `cookies` property directly.
+     *
+     * Set cookie
+     *
+     * Instead of using PHP's `setcookie()` function, Slim manually constructs the HTTP `Set-Cookie`
+     * header on its own and delegates this responsibility to the `Slim_Http_Util` class. This
+     * response's header is passed by reference to the utility class and is directly modified. By not
+     * relying on PHP's native implementation, Slim allows middleware the opportunity to massage or
+     * analyze the raw header before the response is ultimately delivered to the HTTP client.
+     *
+     * @param string        $name    The name of the cookie
+     * @param string|array  $value   If string, the value of cookie; if array, properties for
+     *                               cookie including: value, expire, path, domain, secure, httponly
+     */
+    public function setCookie($name, $value)
+    {
+        // Util::setCookieHeader($this->header, $name, $value);
+        $this->cookies->set($name, $value);
+    }
+
+    /**
+     * DEPRECATION WARNING! Access `cookies` property directly.
+     *
+     * Delete cookie
+     *
+     * Instead of using PHP's `setcookie()` function, Slim manually constructs the HTTP `Set-Cookie`
+     * header on its own and delegates this responsibility to the `Slim_Http_Util` class. This
+     * response's header is passed by reference to the utility class and is directly modified. By not
+     * relying on PHP's native implementation, Slim allows middleware the opportunity to massage or
+     * analyze the raw header before the response is ultimately delivered to the HTTP client.
+     *
+     * This method will set a cookie with the given name that has an expiration time in the past; this will
+     * prompt the HTTP client to invalidate and remove the client-side cookie. Optionally, you may
+     * also pass a key/value array as the second argument. If the "domain" key is present in this
+     * array, only the Cookie with the given name AND domain will be removed. The invalidating cookie
+     * sent with this response will adopt all properties of the second argument.
+     *
+     * @param string $name     The name of the cookie
+     * @param array  $settings Properties for cookie including: value, expire, path, domain, secure, httponly
+     */
+    public function deleteCookie($name, $settings = array())
+    {
+        $this->cookies->remove($name, $settings);
+        // Util::deleteCookieHeader($this->header, $name, $value);
+    }
+
+    /**
+     * Redirect
+     *
+     * This method prepares this response to return an HTTP Redirect response
+     * to the HTTP client.
+     *
+     * @param string $url    The redirect destination
+     * @param int    $status The redirect HTTP status code
+     */
+    public function redirect ($url, $status = 302)
+    {
+        $this->setStatus($status);
+        $this->headers->set('Location', $url);
+    }
+
+    /**
+     * Helpers: Empty?
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return in_array($this->status, array(201, 204, 304));
+    }
+
+    /**
+     * Helpers: Informational?
+     * @return bool
+     */
+    public function isInformational()
+    {
+        return $this->status >= 100 && $this->status < 200;
+    }
+
+    /**
+     * Helpers: OK?
+     * @return bool
+     */
+    public function isOk()
+    {
+        return $this->status === 200;
+    }
+
+    /**
+     * Helpers: Successful?
+     * @return bool
+     */
+    public function isSuccessful()
+    {
+        return $this->status >= 200 && $this->status < 300;
+    }
+
+    /**
+     * Helpers: Redirect?
+     * @return bool
+     */
+    public function isRedirect()
+    {
+        return in_array($this->status, array(301, 302, 303, 307));
+    }
+
+    /**
+     * Helpers: Redirection?
+     * @return bool
+     */
+    public function isRedirection()
+    {
+        return $this->status >= 300 && $this->status < 400;
+    }
+
+    /**
+     * Helpers: Forbidden?
+     * @return bool
+     */
+    public function isForbidden()
+    {
+        return $this->status === 403;
+    }
+
+    /**
+     * Helpers: Not Found?
+     * @return bool
+     */
+    public function isNotFound()
+    {
+        return $this->status === 404;
+    }
+
+    /**
+     * Helpers: Client error?
+     * @return bool
+     */
+    public function isClientError()
+    {
+        return $this->status >= 400 && $this->status < 500;
+    }
+
+    /**
+     * Helpers: Server Error?
+     * @return bool
+     */
+    public function isServerError()
+    {
+        return $this->status >= 500 && $this->status < 600;
+    }
+
+    /**
+     * DEPRECATION WARNING! ArrayAccess interface will be removed from \Slim\Http\Response.
+     * Iterate `headers` or `cookies` properties directly.
+     */
+
+    /**
+     * Array Access: Offset Exists
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->headers[$offset]);
+    }
+
+    /**
+     * Array Access: Offset Get
+     */
+    public function offsetGet($offset)
+    {
+        return $this->headers[$offset];
+    }
+
+    /**
+     * Array Access: Offset Set
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->headers[$offset] = $value;
+    }
+
+    /**
+     * Array Access: Offset Unset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->headers[$offset]);
+    }
+
+    /**
+     * DEPRECATION WARNING! Countable interface will be removed from \Slim\Http\Response.
+     * Call `count` on `headers` or `cookies` properties directly.
+     *
+     * Countable: Count
+     */
+    public function count()
+    {
+        return count($this->headers);
+    }
+
+    /**
+     * DEPRECATION WARNING! IteratorAggregate interface will be removed from \Slim\Http\Response.
+     * Iterate `headers` or `cookies` properties directly.
+     *
+     * Get Iterator
+     *
+     * This returns the contained `\Slim\Http\Headers` instance which
+     * is itself iterable.
+     *
+     * @return \Slim\Http\Headers
+     */
+    public function getIterator()
+    {
+        return $this->headers->getIterator();
+    }
+
+    /**
+     * Get message for HTTP status code
+     * @param  int         $status
+     * @return string|null
+     */
+    public static function getMessageForCode($status)
+    {
+        if (isset(self::$messages[$status])) {
+            return self::$messages[$status];
+        } else {
+            return null;
+        }
+    }
+}

Slim/Http/Util.php

@@ -0,0 +1,434 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Http;
+
+/**
+ * Slim HTTP Utilities
+ *
+ * This class provides useful methods for handling HTTP requests.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Util
+{
+    /**
+     * Strip slashes from string or array
+     *
+     * This method strips slashes from its input. By default, this method will only
+     * strip slashes from its input if magic quotes are enabled. Otherwise, you may
+     * override the magic quotes setting with either TRUE or FALSE as the send argument
+     * to force this method to strip or not strip slashes from its input.
+     *
+     * @param  array|string    $rawData
+     * @param  bool            $overrideStripSlashes
+     * @return array|string
+     */
+    public static function stripSlashesIfMagicQuotes($rawData, $overrideStripSlashes = null)
+    {
+        $strip = is_null($overrideStripSlashes) ? get_magic_quotes_gpc() : $overrideStripSlashes;
+        if ($strip) {
+            return self::stripSlashes($rawData);
+        } else {
+            return $rawData;
+        }
+    }
+
+    /**
+     * Strip slashes from string or array
+     * @param  array|string $rawData
+     * @return array|string
+     */
+    protected static function stripSlashes($rawData)
+    {
+        return is_array($rawData) ? array_map(array('self', 'stripSlashes'), $rawData) : stripslashes($rawData);
+    }
+
+    /**
+     * Encrypt data
+     *
+     * This method will encrypt data using a given key, vector, and cipher.
+     * By default, this will encrypt data using the RIJNDAEL/AES 256 bit cipher. You
+     * may override the default cipher and cipher mode by passing your own desired
+     * cipher and cipher mode as the final key-value array argument.
+     *
+     * @param  string $data     The unencrypted data
+     * @param  string $key      The encryption key
+     * @param  string $iv       The encryption initialization vector
+     * @param  array  $settings Optional key-value array with custom algorithm and mode
+     * @return string
+     */
+    public static function encrypt($data, $key, $iv, $settings = array())
+    {
+        if ($data === '' || !extension_loaded('mcrypt')) {
+            return $data;
+        }
+
+        //Merge settings with defaults
+        $defaults = array(
+            'algorithm' => MCRYPT_RIJNDAEL_256,
+            'mode' => MCRYPT_MODE_CBC
+        );
+        $settings = array_merge($defaults, $settings);
+
+        //Get module
+        $module = mcrypt_module_open($settings['algorithm'], '', $settings['mode'], '');
+
+        //Validate IV
+        $ivSize = mcrypt_enc_get_iv_size($module);
+        if (strlen($iv) > $ivSize) {
+            $iv = substr($iv, 0, $ivSize);
+        }
+
+        //Validate key
+        $keySize = mcrypt_enc_get_key_size($module);
+        if (strlen($key) > $keySize) {
+            $key = substr($key, 0, $keySize);
+        }
+
+        //Encrypt value
+        mcrypt_generic_init($module, $key, $iv);
+        $res = @mcrypt_generic($module, $data);
+        mcrypt_generic_deinit($module);
+
+        return $res;
+    }
+
+    /**
+     * Decrypt data
+     *
+     * This method will decrypt data using a given key, vector, and cipher.
+     * By default, this will decrypt data using the RIJNDAEL/AES 256 bit cipher. You
+     * may override the default cipher and cipher mode by passing your own desired
+     * cipher and cipher mode as the final key-value array argument.
+     *
+     * @param  string $data     The encrypted data
+     * @param  string $key      The encryption key
+     * @param  string $iv       The encryption initialization vector
+     * @param  array  $settings Optional key-value array with custom algorithm and mode
+     * @return string
+     */
+    public static function decrypt($data, $key, $iv, $settings = array())
+    {
+        if ($data === '' || !extension_loaded('mcrypt')) {
+            return $data;
+        }
+
+        //Merge settings with defaults
+        $defaults = array(
+            'algorithm' => MCRYPT_RIJNDAEL_256,
+            'mode' => MCRYPT_MODE_CBC
+        );
+        $settings = array_merge($defaults, $settings);
+
+        //Get module
+        $module = mcrypt_module_open($settings['algorithm'], '', $settings['mode'], '');
+
+        //Validate IV
+        $ivSize = mcrypt_enc_get_iv_size($module);
+        if (strlen($iv) > $ivSize) {
+            $iv = substr($iv, 0, $ivSize);
+        }
+
+        //Validate key
+        $keySize = mcrypt_enc_get_key_size($module);
+        if (strlen($key) > $keySize) {
+            $key = substr($key, 0, $keySize);
+        }
+
+        //Decrypt value
+        mcrypt_generic_init($module, $key, $iv);
+        $decryptedData = @mdecrypt_generic($module, $data);
+        $res = rtrim($decryptedData, "\0");
+        mcrypt_generic_deinit($module);
+
+        return $res;
+    }
+
+    /**
+     * Serialize Response cookies into raw HTTP header
+     * @param  \Slim\Http\Headers $headers The Response headers
+     * @param  \Slim\Http\Cookies $cookies The Response cookies
+     * @param  array              $config  The Slim app settings
+     */
+    public static function serializeCookies(\Slim\Http\Headers &$headers, \Slim\Http\Cookies $cookies, array $config)
+    {
+        if ($config['cookies.encrypt']) {
+            foreach ($cookies as $name => $settings) {
+                if (is_string($settings['expires'])) {
+                    $expires = strtotime($settings['expires']);
+                } else {
+                    $expires = (int) $settings['expires'];
+                }
+
+                $settings['value'] = static::encodeSecureCookie(
+                    $settings['value'],
+                    $expires,
+                    $config['cookies.secret_key'],
+                    $config['cookies.cipher'],
+                    $config['cookies.cipher_mode']
+                );
+                static::setCookieHeader($headers, $name, $settings);
+            }
+        } else {
+            foreach ($cookies as $name => $settings) {
+                static::setCookieHeader($headers, $name, $settings);
+            }
+        }
+    }
+
+    /**
+     * Encode secure cookie value
+     *
+     * This method will create the secure value of an HTTP cookie. The
+     * cookie value is encrypted and hashed so that its value is
+     * secure and checked for integrity when read in subsequent requests.
+     *
+     * @param string $value     The insecure HTTP cookie value
+     * @param int    $expires   The UNIX timestamp at which this cookie will expire
+     * @param string $secret    The secret key used to hash the cookie value
+     * @param int    $algorithm The algorithm to use for encryption
+     * @param int    $mode      The algorithm mode to use for encryption
+     * @return string
+     */
+    public static function encodeSecureCookie($value, $expires, $secret, $algorithm, $mode)
+    {
+        $key = hash_hmac('sha1', (string) $expires, $secret);
+        $iv = self::getIv($expires, $secret);
+        $secureString = base64_encode(
+            self::encrypt(
+                $value,
+                $key,
+                $iv,
+                array(
+                    'algorithm' => $algorithm,
+                    'mode' => $mode
+                )
+            )
+        );
+        $verificationString = hash_hmac('sha1', $expires . $value, $key);
+
+        return implode('|', array($expires, $secureString, $verificationString));
+    }
+
+    /**
+     * Decode secure cookie value
+     *
+     * This method will decode the secure value of an HTTP cookie. The
+     * cookie value is encrypted and hashed so that its value is
+     * secure and checked for integrity when read in subsequent requests.
+     *
+     * @param string $value     The secure HTTP cookie value
+     * @param string $secret    The secret key used to hash the cookie value
+     * @param int    $algorithm The algorithm to use for encryption
+     * @param int    $mode      The algorithm mode to use for encryption
+     * @return bool|string
+     */
+    public static function decodeSecureCookie($value, $secret, $algorithm, $mode)
+    {
+        if ($value) {
+            $value = explode('|', $value);
+            if (count($value) === 3 && ((int) $value[0] === 0 || (int) $value[0] > time())) {
+                $key = hash_hmac('sha1', $value[0], $secret);
+                $iv = self::getIv($value[0], $secret);
+                $data = self::decrypt(
+                    base64_decode($value[1]),
+                    $key,
+                    $iv,
+                    array(
+                        'algorithm' => $algorithm,
+                        'mode' => $mode
+                    )
+                );
+                $verificationString = hash_hmac('sha1', $value[0] . $data, $key);
+                if ($verificationString === $value[2]) {
+                    return $data;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Set HTTP cookie header
+     *
+     * This method will construct and set the HTTP `Set-Cookie` header. Slim
+     * uses this method instead of PHP's native `setcookie` method. This allows
+     * more control of the HTTP header irrespective of the native implementation's
+     * dependency on PHP versions.
+     *
+     * This method accepts the Slim_Http_Headers object by reference as its
+     * first argument; this method directly modifies this object instead of
+     * returning a value.
+     *
+     * @param  array  $header
+     * @param  string $name
+     * @param  string $value
+     */
+    public static function setCookieHeader(&$header, $name, $value)
+    {
+        //Build cookie header
+        if (is_array($value)) {
+            $domain = '';
+            $path = '';
+            $expires = '';
+            $secure = '';
+            $httponly = '';
+            if (isset($value['domain']) && $value['domain']) {
+                $domain = '; domain=' . $value['domain'];
+            }
+            if (isset($value['path']) && $value['path']) {
+                $path = '; path=' . $value['path'];
+            }
+            if (isset($value['expires'])) {
+                if (is_string($value['expires'])) {
+                    $timestamp = strtotime($value['expires']);
+                } else {
+                    $timestamp = (int) $value['expires'];
+                }
+                if ($timestamp !== 0) {
+                    $expires = '; expires=' . gmdate('D, d-M-Y H:i:s e', $timestamp);
+                }
+            }
+            if (isset($value['secure']) && $value['secure']) {
+                $secure = '; secure';
+            }
+            if (isset($value['httponly']) && $value['httponly']) {
+                $httponly = '; HttpOnly';
+            }
+            $cookie = sprintf('%s=%s%s', urlencode($name), urlencode((string) $value['value']), $domain . $path . $expires . $secure . $httponly);
+        } else {
+            $cookie = sprintf('%s=%s', urlencode($name), urlencode((string) $value));
+        }
+
+        //Set cookie header
+        if (!isset($header['Set-Cookie']) || $header['Set-Cookie'] === '') {
+            $header['Set-Cookie'] = $cookie;
+        } else {
+            $header['Set-Cookie'] = implode("\n", array($header['Set-Cookie'], $cookie));
+        }
+    }
+
+    /**
+     * Delete HTTP cookie header
+     *
+     * This method will construct and set the HTTP `Set-Cookie` header to invalidate
+     * a client-side HTTP cookie. If a cookie with the same name (and, optionally, domain)
+     * is already set in the HTTP response, it will also be removed. Slim uses this method
+     * instead of PHP's native `setcookie` method. This allows more control of the HTTP header
+     * irrespective of PHP's native implementation's dependency on PHP versions.
+     *
+     * This method accepts the Slim_Http_Headers object by reference as its
+     * first argument; this method directly modifies this object instead of
+     * returning a value.
+     *
+     * @param  array  $header
+     * @param  string $name
+     * @param  array  $value
+     */
+    public static function deleteCookieHeader(&$header, $name, $value = array())
+    {
+        //Remove affected cookies from current response header
+        $cookiesOld = array();
+        $cookiesNew = array();
+        if (isset($header['Set-Cookie'])) {
+            $cookiesOld = explode("\n", $header['Set-Cookie']);
+        }
+        foreach ($cookiesOld as $c) {
+            if (isset($value['domain']) && $value['domain']) {
+                $regex = sprintf('@%s=.*domain=%s@', urlencode($name), preg_quote($value['domain']));
+            } else {
+                $regex = sprintf('@%s=@', urlencode($name));
+            }
+            if (preg_match($regex, $c) === 0) {
+                $cookiesNew[] = $c;
+            }
+        }
+        if ($cookiesNew) {
+            $header['Set-Cookie'] = implode("\n", $cookiesNew);
+        } else {
+            unset($header['Set-Cookie']);
+        }
+
+        //Set invalidating cookie to clear client-side cookie
+        self::setCookieHeader($header, $name, array_merge(array('value' => '', 'path' => null, 'domain' => null, 'expires' => time() - 100), $value));
+    }
+
+    /**
+     * Parse cookie header
+     *
+     * This method will parse the HTTP request's `Cookie` header
+     * and extract cookies into an associative array.
+     *
+     * @param  string
+     * @return array
+     */
+    public static function parseCookieHeader($header)
+    {
+        $cookies = array();
+        $header = rtrim($header, "\r\n");
+        $headerPieces = preg_split('@\s*[;,]\s*@', $header);
+        foreach ($headerPieces as $c) {
+            $cParts = explode('=', $c, 2);
+            if (count($cParts) === 2) {
+                $key = urldecode($cParts[0]);
+                $value = urldecode($cParts[1]);
+                if (!isset($cookies[$key])) {
+                    $cookies[$key] = $value;
+                }
+            }
+        }
+
+        return $cookies;
+    }
+
+    /**
+     * Generate a random IV
+     *
+     * This method will generate a non-predictable IV for use with
+     * the cookie encryption
+     *
+     * @param  int    $expires The UNIX timestamp at which this cookie will expire
+     * @param  string $secret  The secret key used to hash the cookie value
+     * @return string Hash
+     */
+    private static function getIv($expires, $secret)
+    {
+        $data1 = hash_hmac('sha1', 'a'.$expires.'b', $secret);
+        $data2 = hash_hmac('sha1', 'z'.$expires.'y', $secret);
+
+        return pack("h*", $data1.$data2);
+    }
+}

Slim/Log.php

@@ -0,0 +1,349 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * Log
+ *
+ * This is the primary logger for a Slim application. You may provide
+ * a Log Writer in conjunction with this Log to write to various output
+ * destinations (e.g. a file). This class provides this interface:
+ *
+ * debug( mixed $object, array $context )
+ * info( mixed $object, array $context )
+ * notice( mixed $object, array $context )
+ * warning( mixed $object, array $context )
+ * error( mixed $object, array $context )
+ * critical( mixed $object, array $context )
+ * alert( mixed $object, array $context )
+ * emergency( mixed $object, array $context )
+ * log( mixed $level, mixed $object, array $context )
+ *
+ * This class assumes only that your Log Writer has a public `write()` method
+ * that accepts any object as its one and only argument. The Log Writer
+ * class may write or send its argument anywhere: a file, STDERR,
+ * a remote web API, etc. The possibilities are endless.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Log
+{
+    const EMERGENCY = 1;
+    const ALERT     = 2;
+    const CRITICAL  = 3;
+    const FATAL     = 3; //DEPRECATED replace with CRITICAL
+    const ERROR     = 4;
+    const WARN      = 5;
+    const NOTICE    = 6;
+    const INFO      = 7;
+    const DEBUG     = 8;
+
+    /**
+     * @var array
+     */
+    protected static $levels = array(
+        self::EMERGENCY => 'EMERGENCY',
+        self::ALERT     => 'ALERT',
+        self::CRITICAL  => 'CRITICAL',
+        self::ERROR     => 'ERROR',
+        self::WARN      => 'WARNING',
+        self::NOTICE    => 'NOTICE',
+        self::INFO      => 'INFO',
+        self::DEBUG     => 'DEBUG'
+    );
+
+    /**
+     * @var mixed
+     */
+    protected $writer;
+
+    /**
+     * @var bool
+     */
+    protected $enabled;
+
+    /**
+     * @var int
+     */
+    protected $level;
+
+    /**
+     * Constructor
+     * @param  mixed $writer
+     */
+    public function __construct($writer)
+    {
+        $this->writer = $writer;
+        $this->enabled = true;
+        $this->level = self::DEBUG;
+    }
+
+    /**
+     * Is logging enabled?
+     * @return bool
+     */
+    public function getEnabled()
+    {
+        return $this->enabled;
+    }
+
+    /**
+     * Enable or disable logging
+     * @param  bool $enabled
+     */
+    public function setEnabled($enabled)
+    {
+        if ($enabled) {
+            $this->enabled = true;
+        } else {
+            $this->enabled = false;
+        }
+    }
+
+    /**
+     * Set level
+     * @param  int                          $level
+     * @throws \InvalidArgumentException    If invalid log level specified
+     */
+    public function setLevel($level)
+    {
+        if (!isset(self::$levels[$level])) {
+            throw new \InvalidArgumentException('Invalid log level');
+        }
+        $this->level = $level;
+    }
+
+    /**
+     * Get level
+     * @return int
+     */
+    public function getLevel()
+    {
+        return $this->level;
+    }
+
+    /**
+     * Set writer
+     * @param  mixed $writer
+     */
+    public function setWriter($writer)
+    {
+        $this->writer = $writer;
+    }
+
+    /**
+     * Get writer
+     * @return mixed
+     */
+    public function getWriter()
+    {
+        return $this->writer;
+    }
+
+    /**
+     * Is logging enabled?
+     * @return bool
+     */
+    public function isEnabled()
+    {
+        return $this->enabled;
+    }
+
+    /**
+     * Log debug message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function debug($object, $context = array())
+    {
+        return $this->log(self::DEBUG, $object, $context);
+    }
+
+    /**
+     * Log info message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function info($object, $context = array())
+    {
+        return $this->log(self::INFO, $object, $context);
+    }
+
+    /**
+     * Log notice message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function notice($object, $context = array())
+    {
+        return $this->log(self::NOTICE, $object, $context);
+    }
+
+    /**
+     * Log warning message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function warning($object, $context = array())
+    {
+        return $this->log(self::WARN, $object, $context);
+    }
+
+    /**
+     * DEPRECATED for function warning
+     * Log warning message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function warn($object, $context = array())
+    {
+        return $this->log(self::WARN, $object, $context);
+    }
+
+    /**
+     * Log error message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function error($object, $context = array())
+    {
+        return $this->log(self::ERROR, $object, $context);
+    }
+
+    /**
+     * Log critical message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function critical($object, $context = array())
+    {
+        return $this->log(self::CRITICAL, $object, $context);
+    }
+
+    /**
+     * DEPRECATED for function critical
+     * Log fatal message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function fatal($object, $context = array())
+    {
+        return $this->log(self::CRITICAL, $object, $context);
+    }
+
+    /**
+     * Log alert message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function alert($object, $context = array())
+    {
+        return $this->log(self::ALERT, $object, $context);
+    }
+
+    /**
+     * Log emergency message
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     */
+    public function emergency($object, $context = array())
+    {
+        return $this->log(self::EMERGENCY, $object, $context);
+    }
+
+    /**
+     * Log message
+     * @param  mixed       $level
+     * @param  mixed       $object
+     * @param  array       $context
+     * @return mixed|bool What the Logger returns, or false if Logger not set or not enabled
+     * @throws \InvalidArgumentException If invalid log level
+     */
+    public function log($level, $object, $context = array())
+    {
+        if (!isset(self::$levels[$level])) {
+            throw new \InvalidArgumentException('Invalid log level supplied to function');
+        } else if ($this->enabled && $this->writer && $level <= $this->level) {
+            $message = (string)$object;
+            if (count($context) > 0) {
+                if (isset($context['exception']) && $context['exception'] instanceof \Exception) {
+                    $message .= ' - ' . $context['exception'];
+                    unset($context['exception']);
+                }
+                $message = $this->interpolate($message, $context);
+            }
+            return $this->writer->write($message, $level);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * DEPRECATED for function log
+     * Log message
+     * @param   mixed    $object The object to log
+     * @param   int      $level  The message level
+     * @return  int|bool
+     */
+    protected function write($object, $level)
+    {
+        return $this->log($level, $object);
+    }
+
+    /**
+     * Interpolate log message
+     * @param  mixed     $message               The log message
+     * @param  array     $context               An array of placeholder values
+     * @return string    The processed string
+     */
+    protected function interpolate($message, $context = array())
+    {
+        $replace = array();
+        foreach ($context as $key => $value) {
+            $replace['{' . $key . '}'] = $value;
+        }
+        return strtr($message, $replace);
+    }
+}

Slim/LogWriter.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * Log Writer
+ *
+ * This class is used by Slim_Log to write log messages to a valid, writable
+ * resource handle (e.g. a file or STDERR).
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.6.0
+ */
+class LogWriter
+{
+    /**
+     * @var resource
+     */
+    protected $resource;
+
+    /**
+     * Constructor
+     * @param  resource                  $resource
+     * @throws \InvalidArgumentException If invalid resource
+     */
+    public function __construct($resource)
+    {
+        if (!is_resource($resource)) {
+            throw new \InvalidArgumentException('Cannot create LogWriter. Invalid resource handle.');
+        }
+        $this->resource = $resource;
+    }
+
+    /**
+     * Write message
+     * @param  mixed     $message
+     * @param  int       $level
+     * @return int|bool
+     */
+    public function write($message, $level = null)
+    {
+        return fwrite($this->resource, (string) $message . PHP_EOL);
+    }
+}

Slim/Middleware.php

@@ -0,0 +1,114 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * Middleware
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.6.0
+ */
+abstract class Middleware
+{
+    /**
+     * @var \Slim\Slim Reference to the primary application instance
+     */
+    protected $app;
+
+    /**
+     * @var mixed Reference to the next downstream middleware
+     */
+    protected $next;
+
+    /**
+     * Set application
+     *
+     * This method injects the primary Slim application instance into
+     * this middleware.
+     *
+     * @param  \Slim\Slim $application
+     */
+    final public function setApplication($application)
+    {
+        $this->app = $application;
+    }
+
+    /**
+     * Get application
+     *
+     * This method retrieves the application previously injected
+     * into this middleware.
+     *
+     * @return \Slim\Slim
+     */
+    final public function getApplication()
+    {
+        return $this->app;
+    }
+
+    /**
+     * Set next middleware
+     *
+     * This method injects the next downstream middleware into
+     * this middleware so that it may optionally be called
+     * when appropriate.
+     *
+     * @param \Slim|\Slim\Middleware
+     */
+    final public function setNextMiddleware($nextMiddleware)
+    {
+        $this->next = $nextMiddleware;
+    }
+
+    /**
+     * Get next middleware
+     *
+     * This method retrieves the next downstream middleware
+     * previously injected into this middleware.
+     *
+     * @return \Slim\Slim|\Slim\Middleware
+     */
+    final public function getNextMiddleware()
+    {
+        return $this->next;
+    }
+
+    /**
+     * Call
+     *
+     * Perform actions specific to this middleware and optionally
+     * call the next downstream middleware.
+     */
+    abstract public function call();
+}

Slim/Middleware/ContentTypes.php

@@ -0,0 +1,174 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Middleware;
+
+ /**
+  * Content Types
+  *
+  * This is middleware for a Slim application that intercepts
+  * the HTTP request body and parses it into the appropriate
+  * PHP data structure if possible; else it returns the HTTP
+  * request body unchanged. This is particularly useful
+  * for preparing the HTTP request body for an XML or JSON API.
+  *
+  * @package    Slim
+  * @author     Josh Lockhart
+  * @since      1.6.0
+  */
+class ContentTypes extends \Slim\Middleware
+{
+    /**
+     * @var array
+     */
+    protected $contentTypes;
+
+    /**
+     * Constructor
+     * @param array $settings
+     */
+    public function __construct($settings = array())
+    {
+        $defaults = array(
+            'application/json' => array($this, 'parseJson'),
+            'application/xml' => array($this, 'parseXml'),
+            'text/xml' => array($this, 'parseXml'),
+            'text/csv' => array($this, 'parseCsv')
+        );
+        $this->contentTypes = array_merge($defaults, $settings);
+    }
+
+    /**
+     * Call
+     */
+    public function call()
+    {
+        $mediaType = $this->app->request()->getMediaType();
+        if ($mediaType) {
+            $env = $this->app->environment();
+            $env['slim.input_original'] = $env['slim.input'];
+            $env['slim.input'] = $this->parse($env['slim.input'], $mediaType);
+        }
+        $this->next->call();
+    }
+
+    /**
+     * Parse input
+     *
+     * This method will attempt to parse the request body
+     * based on its content type if available.
+     *
+     * @param  string $input
+     * @param  string $contentType
+     * @return mixed
+     */
+    protected function parse ($input, $contentType)
+    {
+        if (isset($this->contentTypes[$contentType]) && is_callable($this->contentTypes[$contentType])) {
+            $result = call_user_func($this->contentTypes[$contentType], $input);
+            if ($result) {
+                return $result;
+            }
+        }
+
+        return $input;
+    }
+
+    /**
+     * Parse JSON
+     *
+     * This method converts the raw JSON input
+     * into an associative array.
+     *
+     * @param  string       $input
+     * @return array|string
+     */
+    protected function parseJson($input)
+    {
+        if (function_exists('json_decode')) {
+            $result = json_decode($input, true);
+            if ($result) {
+                return $result;
+            }
+        }
+    }
+
+    /**
+     * Parse XML
+     *
+     * This method creates a SimpleXMLElement
+     * based upon the XML input. If the SimpleXML
+     * extension is not available, the raw input
+     * will be returned unchanged.
+     *
+     * @param  string                  $input
+     * @return \SimpleXMLElement|string
+     */
+    protected function parseXml($input)
+    {
+        if (class_exists('SimpleXMLElement')) {
+            try {
+                $backup = libxml_disable_entity_loader(true);
+                $result = new \SimpleXMLElement($input);
+                libxml_disable_entity_loader($backup);
+                return $result;
+            } catch (\Exception $e) {
+                // Do nothing
+            }
+        }
+
+        return $input;
+    }
+
+    /**
+     * Parse CSV
+     *
+     * This method parses CSV content into a numeric array
+     * containing an array of data for each CSV line.
+     *
+     * @param  string $input
+     * @return array
+     */
+    protected function parseCsv($input)
+    {
+        $temp = fopen('php://memory', 'rw');
+        fwrite($temp, $input);
+        fseek($temp, 0);
+        $res = array();
+        while (($data = fgetcsv($temp)) !== false) {
+            $res[] = $data;
+        }
+        fclose($temp);
+
+        return $res;
+    }
+}

Slim/Middleware/Flash.php

@@ -0,0 +1,212 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Middleware;
+
+ /**
+  * Flash
+  *
+  * This is middleware for a Slim application that enables
+  * Flash messaging between HTTP requests. This allows you
+  * set Flash messages for the current request, for the next request,
+  * or to retain messages from the previous request through to
+  * the next request.
+  *
+  * @package    Slim
+  * @author     Josh Lockhart
+  * @since      1.6.0
+  */
+class Flash extends \Slim\Middleware implements \ArrayAccess, \IteratorAggregate, \Countable
+{
+    /**
+     * @var array
+     */
+    protected $settings;
+
+    /**
+     * @var array
+     */
+    protected $messages;
+
+    /**
+     * Constructor
+     * @param  array  $settings
+     */
+    public function __construct($settings = array())
+    {
+        $this->settings = array_merge(array('key' => 'slim.flash'), $settings);
+        $this->messages = array(
+            'prev' => array(), //flash messages from prev request (loaded when middleware called)
+            'next' => array(), //flash messages for next request
+            'now' => array() //flash messages for current request
+        );
+    }
+
+    /**
+     * Call
+     */
+    public function call()
+    {
+        //Read flash messaging from previous request if available
+        $this->loadMessages();
+
+        //Prepare flash messaging for current request
+        $env = $this->app->environment();
+        $env['slim.flash'] = $this;
+        $this->next->call();
+        $this->save();
+    }
+
+    /**
+     * Now
+     *
+     * Specify a flash message for a given key to be shown for the current request
+     *
+     * @param  string $key
+     * @param  string $value
+     */
+    public function now($key, $value)
+    {
+        $this->messages['now'][(string) $key] = $value;
+    }
+
+    /**
+     * Set
+     *
+     * Specify a flash message for a given key to be shown for the next request
+     *
+     * @param  string $key
+     * @param  string $value
+     */
+    public function set($key, $value)
+    {
+        $this->messages['next'][(string) $key] = $value;
+    }
+
+    /**
+     * Keep
+     *
+     * Retain flash messages from the previous request for the next request
+     */
+    public function keep()
+    {
+        foreach ($this->messages['prev'] as $key => $val) {
+            $this->messages['next'][$key] = $val;
+        }
+    }
+
+    /**
+     * Save
+     */
+    public function save()
+    {
+        $_SESSION[$this->settings['key']] = $this->messages['next'];
+    }
+
+    /**
+     * Load messages from previous request if available
+     */
+    public function loadMessages()
+    {
+        if (isset($_SESSION[$this->settings['key']])) {
+            $this->messages['prev'] = $_SESSION[$this->settings['key']];
+        }
+    }
+
+    /**
+     * Return array of flash messages to be shown for the current request
+     *
+     * @return array
+     */
+    public function getMessages()
+    {
+        return array_merge($this->messages['prev'], $this->messages['now']);
+    }
+
+    /**
+     * Array Access: Offset Exists
+     */
+    public function offsetExists($offset)
+    {
+        $messages = $this->getMessages();
+
+        return isset($messages[$offset]);
+    }
+
+    /**
+     * Array Access: Offset Get
+     */
+    public function offsetGet($offset)
+    {
+        $messages = $this->getMessages();
+
+        return isset($messages[$offset]) ? $messages[$offset] : null;
+    }
+
+    /**
+     * Array Access: Offset Set
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->now($offset, $value);
+    }
+
+    /**
+     * Array Access: Offset Unset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->messages['prev'][$offset], $this->messages['now'][$offset]);
+    }
+
+    /**
+     * Iterator Aggregate: Get Iterator
+     * @return \ArrayIterator
+     */
+    public function getIterator()
+    {
+        $messages = $this->getMessages();
+
+        return new \ArrayIterator($messages);
+    }
+
+    /**
+     * Countable: Count
+     */
+    public function count()
+    {
+        return count($this->getMessages());
+    }
+
+
+
+}

Slim/Middleware/MethodOverride.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Middleware;
+
+ /**
+  * HTTP Method Override
+  *
+  * This is middleware for a Slim application that allows traditional
+  * desktop browsers to submit pseudo PUT and DELETE requests by relying
+  * on a pre-determined request parameter. Without this middleware,
+  * desktop browsers are only able to submit GET and POST requests.
+  *
+  * This middleware is included automatically!
+  *
+  * @package    Slim
+  * @author     Josh Lockhart
+  * @since      1.6.0
+  */
+class MethodOverride extends \Slim\Middleware
+{
+    /**
+     * @var array
+     */
+    protected $settings;
+
+    /**
+     * Constructor
+     * @param  array  $settings
+     */
+    public function __construct($settings = array())
+    {
+        $this->settings = array_merge(array('key' => '_METHOD'), $settings);
+    }
+
+    /**
+     * Call
+     *
+     * Implements Slim middleware interface. This method is invoked and passed
+     * an array of environment variables. This middleware inspects the environment
+     * variables for the HTTP method override parameter; if found, this middleware
+     * modifies the environment settings so downstream middleware and/or the Slim
+     * application will treat the request with the desired HTTP method.
+     *
+     * @return array[status, header, body]
+     */
+    public function call()
+    {
+        $env = $this->app->environment();
+        if (isset($env['HTTP_X_HTTP_METHOD_OVERRIDE'])) {
+            // Header commonly used by Backbone.js and others
+            $env['slim.method_override.original_method'] = $env['REQUEST_METHOD'];
+            $env['REQUEST_METHOD'] = strtoupper($env['HTTP_X_HTTP_METHOD_OVERRIDE']);
+        } elseif (isset($env['REQUEST_METHOD']) && $env['REQUEST_METHOD'] === 'POST') {
+            // HTML Form Override
+            $req = new \Slim\Http\Request($env);
+            $method = $req->post($this->settings['key']);
+            if ($method) {
+                $env['slim.method_override.original_method'] = $env['REQUEST_METHOD'];
+                $env['REQUEST_METHOD'] = strtoupper($method);
+            }
+        }
+        $this->next->call();
+    }
+}

Slim/Middleware/PrettyExceptions.php

@@ -0,0 +1,116 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Middleware;
+
+/**
+ * Pretty Exceptions
+ *
+ * This middleware catches any Exception thrown by the surrounded
+ * application and displays a developer-friendly diagnostic screen.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class PrettyExceptions extends \Slim\Middleware
+{
+    /**
+     * @var array
+     */
+    protected $settings;
+
+    /**
+     * Constructor
+     * @param array $settings
+     */
+    public function __construct($settings = array())
+    {
+        $this->settings = $settings;
+    }
+
+    /**
+     * Call
+     */
+    public function call()
+    {
+        try {
+            $this->next->call();
+        } catch (\Exception $e) {
+            $log = $this->app->getLog(); // Force Slim to append log to env if not already
+            $env = $this->app->environment();
+            $env['slim.log'] = $log;
+            $env['slim.log']->error($e);
+            $this->app->contentType('text/html');
+            $this->app->response()->status(500);
+            $this->app->response()->body($this->renderBody($env, $e));
+        }
+    }
+
+    /**
+     * Render response body
+     * @param  array      $env
+     * @param  \Exception $exception
+     * @return string
+     */
+    protected function renderBody(&$env, $exception)
+    {
+        $title = 'Slim Application Error';
+        $code = $exception->getCode();
+        $message = $exception->getMessage();
+        $file = $exception->getFile();
+        $line = $exception->getLine();
+        $trace = str_replace(array('#', '\n'), array('<div>#', '</div>'), $exception->getTraceAsString());
+        $html = sprintf('<h1>%s</h1>', $title);
+        $html .= '<p>The application could not run because of the following error:</p>';
+        $html .= '<h2>Details</h2>';
+        $html .= sprintf('<div><strong>Type:</strong> %s</div>', get_class($exception));
+        if ($code) {
+            $html .= sprintf('<div><strong>Code:</strong> %s</div>', $code);
+        }
+        if ($message) {
+            $html .= sprintf('<div><strong>Message:</strong> %s</div>', $message);
+        }
+        if ($file) {
+            $html .= sprintf('<div><strong>File:</strong> %s</div>', $file);
+        }
+        if ($line) {
+            $html .= sprintf('<div><strong>Line:</strong> %s</div>', $line);
+        }
+        if ($trace) {
+            $html .= '<h2>Trace</h2>';
+            $html .= sprintf('<pre>%s</pre>', $trace);
+        }
+
+        return sprintf("<html><head><title>%s</title><style>body{margin:0;padding:30px;font:12px/1.5 Helvetica,Arial,Verdana,sans-serif;}h1{margin:0;font-size:48px;font-weight:normal;line-height:48px;}strong{display:inline-block;width:65px;}</style></head><body>%s</body></html>", $title, $html);
+    }
+}

Slim/Middleware/SessionCookie.php

@@ -0,0 +1,210 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim\Middleware;
+
+/**
+ * Session Cookie
+ *
+ * This class provides an HTTP cookie storage mechanism
+ * for session data. This class avoids using a PHP session
+ * and instead serializes/unserializes the $_SESSION global
+ * variable to/from an HTTP cookie.
+ *
+ * You should NEVER store sensitive data in a client-side cookie
+ * in any format, encrypted (with cookies.encrypt) or not. If you
+ * need to store sensitive user information in a session, you should
+ * rely on PHP's native session implementation, or use other middleware
+ * to store session data in a database or alternative server-side cache.
+ *
+ * Because this class stores serialized session data in an HTTP cookie,
+ * you are inherently limited to 4 Kb. If you attempt to store
+ * more than this amount, serialization will fail.
+ *
+ * @package     Slim
+ * @author     Josh Lockhart
+ * @since      1.6.0
+ */
+class SessionCookie extends \Slim\Middleware
+{
+    /**
+     * @var array
+     */
+    protected $settings;
+
+    /**
+     * Constructor
+     *
+     * @param array $settings
+     */
+    public function __construct($settings = array())
+    {
+        $defaults = array(
+            'expires' => '20 minutes',
+            'path' => '/',
+            'domain' => null,
+            'secure' => false,
+            'httponly' => false,
+            'name' => 'slim_session',
+        );
+        $this->settings = array_merge($defaults, $settings);
+        if (is_string($this->settings['expires'])) {
+            $this->settings['expires'] = strtotime($this->settings['expires']);
+        }
+
+        /**
+         * Session
+         *
+         * We must start a native PHP session to initialize the $_SESSION superglobal.
+         * However, we won't be using the native session store for persistence, so we
+         * disable the session cookie and cache limiter. We also set the session
+         * handler to this class instance to avoid PHP's native session file locking.
+         */
+        ini_set('session.use_cookies', 0);
+        session_cache_limiter(false);
+        session_set_save_handler(
+            array($this, 'open'),
+            array($this, 'close'),
+            array($this, 'read'),
+            array($this, 'write'),
+            array($this, 'destroy'),
+            array($this, 'gc')
+        );
+    }
+
+    /**
+     * Call
+     */
+    public function call()
+    {
+        $this->loadSession();
+        $this->next->call();
+        $this->saveSession();
+    }
+
+    /**
+     * Load session
+     */
+    protected function loadSession()
+    {
+        if (session_id() === '') {
+            session_start();
+        }
+
+        $value = $this->app->getCookie($this->settings['name']);
+
+        if ($value) {
+            try {
+                $_SESSION = unserialize($value);
+            } catch (\Exception $e) {
+                $this->app->getLog()->error('Error unserializing session cookie value! ' . $e->getMessage());
+            }
+        } else {
+            $_SESSION = array();
+        }
+    }
+
+    /**
+     * Save session
+     */
+    protected function saveSession()
+    {
+        $value = serialize($_SESSION);
+
+        if (strlen($value) > 4096) {
+            $this->app->getLog()->error('WARNING! Slim\Middleware\SessionCookie data size is larger than 4KB. Content save failed.');
+        } else {
+            $this->app->setCookie(
+                $this->settings['name'],
+                $value,
+                $this->settings['expires'],
+                $this->settings['path'],
+                $this->settings['domain'],
+                $this->settings['secure'],
+                $this->settings['httponly']
+            );
+        }
+        // session_destroy();
+    }
+
+    /********************************************************************************
+    * Session Handler
+    *******************************************************************************/
+
+    /**
+     * @codeCoverageIgnore
+     */
+    public function open($savePath, $sessionName)
+    {
+        return true;
+    }
+
+    /**
+     * @codeCoverageIgnore
+     */
+    public function close()
+    {
+        return true;
+    }
+
+    /**
+     * @codeCoverageIgnore
+     */
+    public function read($id)
+    {
+        return '';
+    }
+
+    /**
+     * @codeCoverageIgnore
+     */
+    public function write($id, $data)
+    {
+        return true;
+    }
+
+    /**
+     * @codeCoverageIgnore
+     */
+    public function destroy($id)
+    {
+        return true;
+    }
+
+    /**
+     * @codeCoverageIgnore
+     */
+    public function gc($maxlifetime)
+    {
+        return true;
+    }
+}

Slim/Route.php

@@ -0,0 +1,465 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * Route
+ * @package Slim
+ * @author  Josh Lockhart, Thomas Bley
+ * @since   1.0.0
+ */
+class Route
+{
+    /**
+     * @var string The route pattern (e.g. "/books/:id")
+     */
+    protected $pattern;
+
+    /**
+     * @var mixed The route callable
+     */
+    protected $callable;
+
+    /**
+     * @var array Conditions for this route's URL parameters
+     */
+    protected $conditions = array();
+
+    /**
+     * @var array Default conditions applied to all route instances
+     */
+    protected static $defaultConditions = array();
+
+    /**
+     * @var string The name of this route (optional)
+     */
+    protected $name;
+
+    /**
+     * @var array Key-value array of URL parameters
+     */
+    protected $params = array();
+
+    /**
+     * @var array value array of URL parameter names
+     */
+    protected $paramNames = array();
+
+    /**
+     * @var array key array of URL parameter names with + at the end
+     */
+    protected $paramNamesPath = array();
+
+    /**
+     * @var array HTTP methods supported by this Route
+     */
+    protected $methods = array();
+
+    /**
+     * @var array[Callable] Middleware to be run before only this route instance
+     */
+    protected $middleware = array();
+
+    /**
+     * @var bool Whether or not this route should be matched in a case-sensitive manner
+     */
+    protected $caseSensitive;
+
+    /**
+     * Constructor
+     * @param string $pattern The URL pattern (e.g. "/books/:id")
+     * @param mixed $callable Anything that returns TRUE for is_callable()
+     * @param bool $caseSensitive Whether or not this route should be matched in a case-sensitive manner
+     */
+    public function __construct($pattern, $callable, $caseSensitive = true)
+    {
+        $this->setPattern($pattern);
+        $this->setCallable($callable);
+        $this->setConditions(self::getDefaultConditions());
+        $this->caseSensitive = $caseSensitive;
+    }
+
+    /**
+     * Set default route conditions for all instances
+     * @param  array $defaultConditions
+     */
+    public static function setDefaultConditions(array $defaultConditions)
+    {
+        self::$defaultConditions = $defaultConditions;
+    }
+
+    /**
+     * Get default route conditions for all instances
+     * @return array
+     */
+    public static function getDefaultConditions()
+    {
+        return self::$defaultConditions;
+    }
+
+    /**
+     * Get route pattern
+     * @return string
+     */
+    public function getPattern()
+    {
+        return $this->pattern;
+    }
+
+    /**
+     * Set route pattern
+     * @param  string $pattern
+     */
+    public function setPattern($pattern)
+    {
+        $this->pattern = $pattern;
+    }
+
+    /**
+     * Get route callable
+     * @return mixed
+     */
+    public function getCallable()
+    {
+        return $this->callable;
+    }
+
+    /**
+     * Set route callable
+     * @param  mixed $callable
+     * @throws \InvalidArgumentException If argument is not callable
+     */
+    public function setCallable($callable)
+    {
+        $matches = array();
+        if (is_string($callable) && preg_match('!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!', $callable, $matches)) {
+            $class = $matches[1];
+            $method = $matches[2];
+            $callable = function() use ($class, $method) {
+                static $obj = null;
+                if ($obj === null) {
+                    $obj = new $class;
+                }
+                return call_user_func_array(array($obj, $method), func_get_args());
+            };
+        }
+
+        if (!is_callable($callable)) {
+            throw new \InvalidArgumentException('Route callable must be callable');
+        }
+
+        $this->callable = $callable;
+    }
+
+    /**
+     * Get route conditions
+     * @return array
+     */
+    public function getConditions()
+    {
+        return $this->conditions;
+    }
+
+    /**
+     * Set route conditions
+     * @param  array $conditions
+     */
+    public function setConditions(array $conditions)
+    {
+        $this->conditions = $conditions;
+    }
+
+    /**
+     * Get route name
+     * @return string|null
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Set route name
+     * @param  string $name
+     */
+    public function setName($name)
+    {
+        $this->name = (string)$name;
+    }
+
+    /**
+     * Get route parameters
+     * @return array
+     */
+    public function getParams()
+    {
+        return $this->params;
+    }
+
+    /**
+     * Set route parameters
+     * @param  array $params
+     */
+    public function setParams($params)
+    {
+        $this->params = $params;
+    }
+
+    /**
+     * Get route parameter value
+     * @param  string $index Name of URL parameter
+     * @return string
+     * @throws \InvalidArgumentException If route parameter does not exist at index
+     */
+    public function getParam($index)
+    {
+        if (!isset($this->params[$index])) {
+            throw new \InvalidArgumentException('Route parameter does not exist at specified index');
+        }
+
+        return $this->params[$index];
+    }
+
+    /**
+     * Set route parameter value
+     * @param  string $index Name of URL parameter
+     * @param  mixed $value The new parameter value
+     * @throws \InvalidArgumentException If route parameter does not exist at index
+     */
+    public function setParam($index, $value)
+    {
+        if (!isset($this->params[$index])) {
+            throw new \InvalidArgumentException('Route parameter does not exist at specified index');
+        }
+        $this->params[$index] = $value;
+    }
+
+    /**
+     * Add supported HTTP method(s)
+     */
+    public function setHttpMethods()
+    {
+        $args = func_get_args();
+        $this->methods = $args;
+    }
+
+    /**
+     * Get supported HTTP methods
+     * @return array
+     */
+    public function getHttpMethods()
+    {
+        return $this->methods;
+    }
+
+    /**
+     * Append supported HTTP methods
+     */
+    public function appendHttpMethods()
+    {
+        $args = func_get_args();
+        $this->methods = array_merge($this->methods, $args);
+    }
+
+    /**
+     * Append supported HTTP methods (alias for Route::appendHttpMethods)
+     * @return \Slim\Route
+     */
+    public function via()
+    {
+        $args = func_get_args();
+        $this->methods = array_merge($this->methods, $args);
+
+        return $this;
+    }
+
+    /**
+     * Detect support for an HTTP method
+     * @param  string $method
+     * @return bool
+     */
+    public function supportsHttpMethod($method)
+    {
+        return in_array($method, $this->methods);
+    }
+
+    /**
+     * Get middleware
+     * @return array[Callable]
+     */
+    public function getMiddleware()
+    {
+        return $this->middleware;
+    }
+
+    /**
+     * Set middleware
+     *
+     * This method allows middleware to be assigned to a specific Route.
+     * If the method argument `is_callable` (including callable arrays!),
+     * we directly append the argument to `$this->middleware`. Else, we
+     * assume the argument is an array of callables and merge the array
+     * with `$this->middleware`.  Each middleware is checked for is_callable()
+     * and an InvalidArgumentException is thrown immediately if it isn't.
+     *
+     * @param  Callable|array[Callable]
+     * @return \Slim\Route
+     * @throws \InvalidArgumentException If argument is not callable or not an array of callables.
+     */
+    public function setMiddleware($middleware)
+    {
+        if (is_callable($middleware)) {
+            $this->middleware[] = $middleware;
+        } elseif (is_array($middleware)) {
+            foreach ($middleware as $callable) {
+                if (!is_callable($callable)) {
+                    throw new \InvalidArgumentException('All Route middleware must be callable');
+                }
+            }
+            $this->middleware = array_merge($this->middleware, $middleware);
+        } else {
+            throw new \InvalidArgumentException('Route middleware must be callable or an array of callables');
+        }
+
+        return $this;
+    }
+
+    /**
+     * Matches URI?
+     *
+     * Parse this route's pattern, and then compare it to an HTTP resource URI
+     * This method was modeled after the techniques demonstrated by Dan Sosedoff at:
+     *
+     * http://blog.sosedoff.com/2009/09/20/rails-like-php-url-router/
+     *
+     * @param  string $resourceUri A Request URI
+     * @return bool
+     */
+    public function matches($resourceUri)
+    {
+        //Convert URL params into regex patterns, construct a regex for this route, init params
+        $patternAsRegex = preg_replace_callback(
+            '#:([\w]+)\+?#',
+            array($this, 'matchesCallback'),
+            str_replace(')', ')?', (string)$this->pattern)
+        );
+        if (substr($this->pattern, -1) === '/') {
+            $patternAsRegex .= '?';
+        }
+
+        $regex = '#^' . $patternAsRegex . '$#';
+
+        if ($this->caseSensitive === false) {
+            $regex .= 'i';
+        }
+
+        //Cache URL params' names and values if this route matches the current HTTP request
+        if (!preg_match($regex, $resourceUri, $paramValues)) {
+            return false;
+        }
+        foreach ($this->paramNames as $name) {
+            if (isset($paramValues[$name])) {
+                if (isset($this->paramNamesPath[$name])) {
+                    $this->params[$name] = explode('/', urldecode($paramValues[$name]));
+                } else {
+                    $this->params[$name] = urldecode($paramValues[$name]);
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Convert a URL parameter (e.g. ":id", ":id+") into a regular expression
+     * @param  array $m URL parameters
+     * @return string       Regular expression for URL parameter
+     */
+    protected function matchesCallback($m)
+    {
+        $this->paramNames[] = $m[1];
+        if (isset($this->conditions[$m[1]])) {
+            return '(?P<' . $m[1] . '>' . $this->conditions[$m[1]] . ')';
+        }
+        if (substr($m[0], -1) === '+') {
+            $this->paramNamesPath[$m[1]] = 1;
+
+            return '(?P<' . $m[1] . '>.+)';
+        }
+
+        return '(?P<' . $m[1] . '>[^/]+)';
+    }
+
+    /**
+     * Set route name
+     * @param  string $name The name of the route
+     * @return \Slim\Route
+     */
+    public function name($name)
+    {
+        $this->setName($name);
+
+        return $this;
+    }
+
+    /**
+     * Merge route conditions
+     * @param  array $conditions Key-value array of URL parameter conditions
+     * @return \Slim\Route
+     */
+    public function conditions(array $conditions)
+    {
+        $this->conditions = array_merge($this->conditions, $conditions);
+
+        return $this;
+    }
+
+    /**
+     * Dispatch route
+     *
+     * This method invokes the route object's callable. If middleware is
+     * registered for the route, each callable middleware is invoked in
+     * the order specified.
+     *
+     * @return bool
+     */
+    public function dispatch()
+    {
+        foreach ($this->middleware as $mw) {
+            call_user_func_array($mw, array($this));
+        }
+
+        $return = call_user_func_array($this->getCallable(), array_values($this->getParams()));
+        return ($return === false) ? false : true;
+    }
+}

Slim/Router.php

@@ -0,0 +1,257 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * Router
+ *
+ * This class organizes, iterates, and dispatches \Slim\Route objects.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class Router
+{
+    /**
+     * @var Route The current route (most recently dispatched)
+     */
+    protected $currentRoute;
+
+    /**
+     * @var array Lookup hash of all route objects
+     */
+    protected $routes;
+
+    /**
+     * @var array Lookup hash of named route objects, keyed by route name (lazy-loaded)
+     */
+    protected $namedRoutes;
+
+    /**
+     * @var array Array of route objects that match the request URI (lazy-loaded)
+     */
+    protected $matchedRoutes;
+
+    /**
+     * @var array Array containing all route groups
+     */
+    protected $routeGroups;
+
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+        $this->routes = array();
+        $this->routeGroups = array();
+    }
+
+    /**
+     * Get Current Route object or the first matched one if matching has been performed
+     * @return \Slim\Route|null
+     */
+    public function getCurrentRoute()
+    {
+        if ($this->currentRoute !== null) {
+            return $this->currentRoute;
+        }
+
+        if (is_array($this->matchedRoutes) && count($this->matchedRoutes) > 0) {
+            return $this->matchedRoutes[0];
+        }
+
+        return null;
+    }
+
+    /**
+     * Return route objects that match the given HTTP method and URI
+     * @param  string               $httpMethod   The HTTP method to match against
+     * @param  string               $resourceUri  The resource URI to match against
+     * @param  bool                 $reload       Should matching routes be re-parsed?
+     * @return array[\Slim\Route]
+     */
+    public function getMatchedRoutes($httpMethod, $resourceUri, $reload = false)
+    {
+        if ($reload || is_null($this->matchedRoutes)) {
+            $this->matchedRoutes = array();
+            foreach ($this->routes as $route) {
+                if (!$route->supportsHttpMethod($httpMethod) && !$route->supportsHttpMethod("ANY")) {
+                    continue;
+                }
+
+                if ($route->matches($resourceUri)) {
+                    $this->matchedRoutes[] = $route;
+                }
+            }
+        }
+
+        return $this->matchedRoutes;
+    }
+
+    /**
+     * Add a route object to the router
+     * @param  \Slim\Route     $route      The Slim Route
+     */
+    public function map(\Slim\Route $route)
+    {
+        list($groupPattern, $groupMiddleware) = $this->processGroups();
+
+        $route->setPattern($groupPattern . $route->getPattern());
+        $this->routes[] = $route;
+
+
+        foreach ($groupMiddleware as $middleware) {
+            $route->setMiddleware($middleware);
+        }
+    }
+
+    /**
+     * A helper function for processing the group's pattern and middleware
+     * @return array Returns an array with the elements: pattern, middlewareArr
+     */
+    protected function processGroups()
+    {
+        $pattern = "";
+        $middleware = array();
+        foreach ($this->routeGroups as $group) {
+            $k = key($group);
+            $pattern .= $k;
+            if (is_array($group[$k])) {
+                $middleware = array_merge($middleware, $group[$k]);
+            }
+        }
+        return array($pattern, $middleware);
+    }
+
+    /**
+     * Add a route group to the array
+     * @param  string     $group      The group pattern (ie. "/books/:id")
+     * @param  array|null $middleware Optional parameter array of middleware
+     * @return int        The index of the new group
+     */
+    public function pushGroup($group, $middleware = array())
+    {
+        return array_push($this->routeGroups, array($group => $middleware));
+    }
+
+    /**
+     * Removes the last route group from the array
+     * @return bool    True if successful, else False
+     */
+    public function popGroup()
+    {
+        return (array_pop($this->routeGroups) !== null);
+    }
+
+    /**
+     * Get URL for named route
+     * @param  string               $name   The name of the route
+     * @param  array                $params Associative array of URL parameter names and replacement values
+     * @throws \RuntimeException            If named route not found
+     * @return string                       The URL for the given route populated with provided replacement values
+     */
+    public function urlFor($name, $params = array())
+    {
+        if (!$this->hasNamedRoute($name)) {
+            throw new \RuntimeException('Named route not found for name: ' . $name);
+        }
+        $search = array();
+        foreach ($params as $key => $value) {
+            $search[] = '#:' . preg_quote($key, '#') . '\+?(?!\w)#';
+        }
+        $pattern = preg_replace($search, $params, $this->getNamedRoute($name)->getPattern());
+
+        //Remove remnants of unpopulated, trailing optional pattern segments, escaped special characters
+        return preg_replace('#\(/?:.+\)|\(|\)|\\\\#', '', $pattern);
+    }
+
+    /**
+     * Add named route
+     * @param  string            $name   The route name
+     * @param  \Slim\Route       $route  The route object
+     * @throws \RuntimeException         If a named route already exists with the same name
+     */
+    public function addNamedRoute($name, \Slim\Route $route)
+    {
+        if ($this->hasNamedRoute($name)) {
+            throw new \RuntimeException('Named route already exists with name: ' . $name);
+        }
+        $this->namedRoutes[(string) $name] = $route;
+    }
+
+    /**
+     * Has named route
+     * @param  string   $name   The route name
+     * @return bool
+     */
+    public function hasNamedRoute($name)
+    {
+        $this->getNamedRoutes();
+
+        return isset($this->namedRoutes[(string) $name]);
+    }
+
+    /**
+     * Get named route
+     * @param  string           $name
+     * @return \Slim\Route|null
+     */
+    public function getNamedRoute($name)
+    {
+        $this->getNamedRoutes();
+        if ($this->hasNamedRoute($name)) {
+            return $this->namedRoutes[(string) $name];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Get named routes
+     * @return \ArrayIterator
+     */
+    public function getNamedRoutes()
+    {
+        if (is_null($this->namedRoutes)) {
+            $this->namedRoutes = array();
+            foreach ($this->routes as $route) {
+                if ($route->getName() !== null) {
+                    $this->addNamedRoute($route->getName(), $route);
+                }
+            }
+        }
+
+        return new \ArrayIterator($this->namedRoutes);
+    }
+}

Slim/View.php

@@ -0,0 +1,282 @@
+<?php
+/**
+ * Slim - a micro PHP 5 framework
+ *
+ * @author      Josh Lockhart <[email protected]>
+ * @copyright   2011 Josh Lockhart
+ * @link        http://www.slimframework.com
+ * @license     http://www.slimframework.com/license
+ * @version     2.4.2
+ * @package     Slim
+ *
+ * MIT LICENSE
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+namespace Slim;
+
+/**
+ * View
+ *
+ * The view is responsible for rendering a template. The view
+ * should subclass \Slim\View and implement this interface:
+ *
+ * public render(string $template);
+ *
+ * This method should render the specified template and return
+ * the resultant string.
+ *
+ * @package Slim
+ * @author  Josh Lockhart
+ * @since   1.0.0
+ */
+class View
+{
+    /**
+     * Data available to the view templates
+     * @var \Slim\Helper\Set
+     */
+    protected $data;
+
+    /**
+     * Path to templates base directory (without trailing slash)
+     * @var string
+     */
+    protected $templatesDirectory;
+
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+        $this->data = new \Slim\Helper\Set();
+    }
+
+    /********************************************************************************
+     * Data methods
+     *******************************************************************************/
+
+    /**
+     * Does view data have value with key?
+     * @param  string  $key
+     * @return boolean
+     */
+    public function has($key)
+    {
+        return $this->data->has($key);
+    }
+
+    /**
+     * Return view data value with key
+     * @param  string $key
+     * @return mixed
+     */
+    public function get($key)
+    {
+        return $this->data->get($key);
+    }
+
+    /**
+     * Set view data value with key
+     * @param string $key
+     * @param mixed $value
+     */
+    public function set($key, $value)
+    {
+        $this->data->set($key, $value);
+    }
+
+    /**
+     * Set view data value as Closure with key
+     * @param string $key
+     * @param mixed $value
+     */
+    public function keep($key, Closure $value)
+    {
+        $this->data->keep($key, $value);
+    }
+
+    /**
+     * Return view data
+     * @return array
+     */
+    public function all()
+    {
+        return $this->data->all();
+    }
+
+    /**
+     * Replace view data
+     * @param  array  $data
+     */
+    public function replace(array $data)
+    {
+        $this->data->replace($data);
+    }
+
+    /**
+     * Clear view data
+     */
+    public function clear()
+    {
+        $this->data->clear();
+    }
+
+    /********************************************************************************
+     * Legacy data methods
+     *******************************************************************************/
+
+    /**
+     * DEPRECATION WARNING! This method will be removed in the next major point release
+     *
+     * Get data from view
+     */
+    public function getData($key = null)
+    {
+        if (!is_null($key)) {
+            return isset($this->data[$key]) ? $this->data[$key] : null;
+        } else {
+            return $this->data->all();
+        }
+    }
+
+    /**
+     * DEPRECATION WARNING! This method will be removed in the next major point release
+     *
+     * Set data for view
+     */
+    public function setData()
+    {
+        $args = func_get_args();
+        if (count($args) === 1 && is_array($args[0])) {
+            $this->data->replace($args[0]);
+        } elseif (count($args) === 2) {
+            // Ensure original behavior is maintained. DO NOT invoke stored Closures.
+            if (is_object($args[1]) && method_exists($args[1], '__invoke')) {
+                $this->data->set($args[0], $this->data->protect($args[1]));
+            } else {
+                $this->data->set($args[0], $args[1]);
+            }
+        } else {
+            throw new \InvalidArgumentException('Cannot set View data with provided arguments. Usage: `View::setData( $key, $value );` or `View::setData([ key => value, ... ]);`');
+        }
+    }
+
+    /**
+     * DEPRECATION WARNING! This method will be removed in the next major point release
+     *
+     * Append data to view
+     * @param  array $data
+     */
+    public function appendData($data)
+    {
+        if (!is_array($data)) {
+            throw new \InvalidArgumentException('Cannot append view data. Expected array argument.');
+        }
+        $this->data->replace($data);
+    }
+
+    /********************************************************************************
+     * Resolve template paths
+     *******************************************************************************/
+
+    /**
+     * Set the base directory that contains view templates
+     * @param   string $directory
+     * @throws  \InvalidArgumentException If directory is not a directory
+     */
+    public function setTemplatesDirectory($directory)
+    {
+        $this->templatesDirectory = rtrim($directory, DIRECTORY_SEPARATOR);
+    }
+
+    /**
+     * Get templates base directory
+     * @return string
+     */
+    public function getTemplatesDirectory()
+    {
+        return $this->templatesDirectory;
+    }
+
+    /**
+     * Get fully qualified path to template file using templates base directory
+     * @param  string $file The template file pathname relative to templates base directory
+     * @return string
+     */
+    public function getTemplatePathname($file)
+    {
+        return $this->templatesDirectory . DIRECTORY_SEPARATOR . ltrim($file, DIRECTORY_SEPARATOR);
+    }
+
+    /********************************************************************************
+     * Rendering
+     *******************************************************************************/
+
+    /**
+     * Display template
+     *
+     * This method echoes the rendered template to the current output buffer
+     *
+     * @param  string   $template   Pathname of template file relative to templates directory
+     * @param  array    $data       Any additonal data to be passed to the template.
+     */
+    public function display($template, $data = null)
+    {
+        echo $this->fetch($template, $data);
+    }
+
+    /**
+     * Return the contents of a rendered template file
+     *
+     * @param    string $template   The template pathname, relative to the template base directory
+     * @param    array  $data       Any additonal data to be passed to the template.
+     * @return string               The rendered template
+     */
+    public function fetch($template, $data = null)
+    {
+        return $this->render($template, $data);
+    }
+
+    /**
+     * Render a template file
+     *
+     * NOTE: This method should be overridden by custom view subclasses
+     *
+     * @param  string $template     The template pathname, relative to the template base directory
+     * @param  array  $data         Any additonal data to be passed to the template.
+     * @return string               The rendered template
+     * @throws \RuntimeException    If resolved template pathname is not a valid file
+     */
+    protected function render($template, $data = null)
+    {
+        $templatePathname = $this->getTemplatePathname($template);
+        if (!is_file($templatePathname)) {
+            throw new \RuntimeException("View cannot render `$template` because the template does not exist");
+        }
+
+        $data = array_merge($this->data->all(), (array) $data);
+        extract($data);
+        ob_start();
+        require $templatePathname;
+
+        return ob_get_clean();
+    }
+}

config.inc.php

@@ -0,0 +1,8 @@
+<?php
+
+$allowedHost = array(
+    "localhost",
+    "app.gruppolapastamadre.it",
+    "dev.gruppolapastamadre.it",
+	"management.gruppolapastamadre.it"
+);

image.php

@@ -0,0 +1,103 @@
+<?php
+// inclusione del file contenente la classe
+require_once "./include.php";
+use PHPImageWorkshop\ImageWorkshop;
+require_once('PHPImageWorkshop/ImageWorkshop.php'); // Be sure of the path to the class
+
+//include "./SimpleImage.php";
+
+$app->get('/photos/thumbnail/:imageID(/:createImgTag)', function ($imageID, $createImgTag = 0) use ($app) {    
+    $mysqlconnetion = new MysqlClass;
+    
+    $retObj = $mysqlconnetion->queryToObject("select type_format, image_thumbnail from immagini where id=" . $imageID, false);
+    $mysqlconnetion->disconnetti();
+
+    if($createImgTag)
+        echo '<img src="data:' . $retObj["type_format"] . ';base64,' . base64_encode($retObj['image_thumbnail']) . '"/>';
+    else
+    {
+        $app->contentType($retObj["type_format"]);
+        echo $retObj['image_thumbnail'];
+    }
+});
+
+$app->get('/photos/:imageID(/:createImgTag)', function ($imageID, $createImgTag = 0) use ($app) {    
+    $mysqlconnetion = new MysqlClass;
+    
+    $retObj = $mysqlconnetion->queryToObject("select type_format, image from immagini where id=" . $imageID, false);
+    $mysqlconnetion->disconnetti();
+
+    if($createImgTag)
+        echo '<img src="';
+    echo 'data:' . $retObj["type_format"] . ';base64,'.base64_encode( $retObj['image'] );
+    if($createImgTag)
+        echo '"/>';
+});
+
+$app->put('/photos/publish/:imageID', function ($imageID) use ($app) {    
+    $mysqlconnetion = new MysqlClass;
+    
+    $query = "update immagini set published = 1, published_date = NOW() where ProfiloID = " . $imageID;
+    $mysqlconnetion->disconnetti();
+    $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+});
+
+$app->post('/photos', function () use ($app) {    
+    $idRicette = $app->request()->post('ricetta_id');
+    $profileID = $app->request()->post('keyStore');
+    $imageFileName = $_FILES['image']["tmp_name"];
+        
+    $layer = ImageWorkshop::initFromPath($imageFileName);
+    $layer->resizeByLargestSideInPixel(640, true);
+    
+    $layer->save(dirname($imageFileName), basename($imageFileName));
+    
+    $imgData = addslashes(file_get_contents($imageFileName));
+    
+    $layer->resizeByLargestSideInPixel(300, true);
+        
+    $layer->save(dirname($imageFileName), basename($imageFileName));
+    
+    $ThumbImageData = addslashes(file_get_contents($imageFileName));
+
+// istanza della classe
+    $mysqlconnetion = new MysqlClass;
+//$mysqlconneti	on->connetti();
+    $query = "insert into immagini(id_ricette, type_format, image_thumbnail, image, from_profile_id, uploaded_date) " .
+            "values(" . $idRicette . ", '" . image_type_to_mime_type($image->image_type) .
+            "', '" . $ThumbImageData . "', '" . $imgData . "', '" . $profileID . "', NOW())";
+    $newID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+
+    echo $newID;
+});
+
+$app->put('/photos/:imageID', function ($imageID) use ($app) {    
+    $imageFileName = $_FILES['image']["tmp_name"];
+    
+    $layer = ImageWorkshop::initFromPath($imageFileName);
+    $layer->resizeByLargestSideInPixel(640, true);
+    
+    $layer->save(dirname($imageFileName), basename($imageFileName));
+    
+    $imgData = addslashes(file_get_contents($imageFileName));
+    
+    $layer->resizeByLargestSideInPixel(300, true);
+        
+    $layer->save(dirname($imageFileName), basename($imageFileName));
+    
+    $ThumbImageData = addslashes(file_get_contents($imageFileName));
+
+// istanza della classe
+    $mysqlconnetion = new MysqlClass;
+//$mysqlconneti	on->connetti();
+    $query = "update immagini set (type_format = '" . image_type_to_mime_type($image->image_type) . "', " . 
+            "image_thumbnail = '" . $ThumbImageData . "', " .
+            "image = '" . $imgData . "' where id=" . $imageID;
+    
+    $newID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+
+    return $newID;
+});

include.php

@@ -0,0 +1,31 @@
+<?php
+
+require_once "./config.inc.php";
+
+// inclusione del file contenente la classe
+require_once "./MySqlClass.php";
+require_once "./utility.php";
+
+require_once 'Slim/Slim.php';
+
+\Slim\Slim::registerAutoloader();
+
+$app = new \Slim\Slim();
+
+$app->hook('slim.before.router', function () use ($app, $allowedHost) {
+    $currentRefererRequest = $app->request()->getReferer();
+    $currentRefererRequest = substr(substr($currentRefererRequest, 7), 0, strpos(substr($currentRefererRequest, 7), '/'));
+    if(!in_array($currentRefererRequest, $allowedHost))
+    {
+    	$app->halt(500, "Generic error occurred");
+    }
+	
+    $currentHostRequest = $app->request()->getHost();
+    if(!in_array($currentHostRequest, $allowedHost))
+    {
+        $app->halt(403, "Request arrive from host not allowed " . $currentHostRequest );
+    }
+});
+
+
+?>

management.php

@@ -0,0 +1,165 @@
+<?php
+
+$app->get('/categories', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconneti	on->connetti();
+    $retObj = $mysqlconnetion->queryToObject("select ID as category_id, NAME as name from categorie order by name");
+    $mysqlconnetion->disconnetti();
+
+    returnJsonWithDecode($app, $callbackFn, $retObj);
+});
+
+$app->get('/typeingredients', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $retObj = $mysqlconnetion->queryToObject("select ID as tipo_ingredienti_id, name from tipo_ingredienti order by name");
+    $mysqlconnetion->disconnetti();
+
+    returnJsonWithDecode($app, $callbackFn, $retObj);
+});
+
+$app->get('/typeqtys', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $retObj = $mysqlconnetion->queryToObject("select ID as tipo_quantita_id, name from tipo_quantita");
+    $mysqlconnetion->disconnetti();
+
+    returnJsonWithDecode($app, $callbackFn, $retObj);
+});
+
+$app->get('/categoryitems/:catID', function ($categoryID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $query = "select ID as ricetta_id, titolo, autore, valutazione, difficolta from ricette where ID_CATEGORIA = " . $categoryID . " order by titolo, autore";
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/ricetta/body/:itemID', function ($itemID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    // istanza della classe
+    $mysqlconnetion = new MysqlClass;
+    $query = "SELECT id_categoria, categorie.name AS categoria_name, ricette.ID AS ricetta_id, titolo, procedimento, autore, link_fonte, link_youtube, valutazione, difficolta FROM ricette INNER JOIN categorie ON categorie.ID = ricette.id_categoria WHERE ricette.ID = " . $itemID;
+    $retObj = $mysqlconnetion->queryToObject($query);
+
+    $query2 = "select ingredienti.id_tipo_ingredienti, tipo_ingredienti.name as nome_ingrediente, quantita, ingredienti.id_tipo_quantita, tipo_quantita.Name as unita, note, posizione from ingredienti " .
+            "inner join tipo_ingredienti on ingredienti.ID_TIPO_INGREDIENTI = tipo_ingredienti.ID " .
+            "left outer join tipo_quantita on ingredienti.ID_TIPO_QUANTITA = tipo_quantita.ID " .
+            "where ingredienti.ID_RICETTE = " . $itemID . " order by ingredienti.posizione";
+
+    $retObj2 = $mysqlconnetion->queryToObject($query2);
+
+    $retObj[0]["titolo"] = html_entity_decode($retObj[0]["titolo"],ENT_COMPAT | ENT_HTML401,'ISO-8859-1');
+    $retObj[0]["procedimento"] = html_entity_decode($retObj[0]["procedimento"],ENT_COMPAT | ENT_HTML401,'ISO-8859-1');
+    $retObj[0]["ingredienti"] = $retObj2;
+
+    $mysqlconnetion->disconnetti();
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->post('/typeingredients', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $json_data_body = json_decode($app->request()->post('bodydata'));
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $query = "insert into tipo_ingredienti(Name) values ('" . $json_data_body->name . "')";
+
+    $retNewID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retNewID);
+});
+
+$app->post('/ricetta/body', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $json_data_body = json_decode($app->request()->post('bodydata'));
+    $retValue["result"] = true;
+    $retValue["message"] = "";
+    $mysqlconnetion = new MysqlClass;
+    // istanza della classe
+    try {
+        $retNewID = 0;
+        if ($json_data_body->ricettaID != "") {
+            $query = "update ricette SET ID_CATEGORIA = " . $json_data_body->categoria_id .
+                    ", titolo = '" . htmlentities($json_data_body->titolo, null, "UTF-8") .
+                    "', procedimento = '" . str_replace("'", "''", htmlentities($json_data_body->preparazione, null, "UTF-8")) .
+                    "', autore = '" . str_replace("'", "''", $json_data_body->autore) .
+                    "', link_fonte = '" . $json_data_body->linkFonte .
+                    "', Link_youtube = '" . $json_data_body->linkVideo .
+                    "', Difficolta = '" . $json_data_body->difficolta .
+                    "' where ID = " . $json_data_body->ricettaID;
+
+            $mysqlconnetion->executeQuery($query);
+            $queryDelete = "DELETE FROM ingredienti where ID_RICETTE = " . $json_data_body->ricettaID;
+            $mysqlconnetion->executeQuery($queryDelete);
+            $retNewID = $json_data_body->ricettaID;
+        } else {
+
+            $query = "insert into ricette(ID_CATEGORIA, titolo, procedimento, autore, link_fonte, Link_youtube,Difficolta) values (" .
+                    $json_data_body->categoria_id . ",'" . htmlentities($json_data_body->titolo, null, "UTF-8") . "','" . str_replace("'", "''", htmlentities($json_data_body->preparazione, null, "UTF-8")) .
+                    "','" . str_replace("'", "''", $json_data_body->autore) . "','" .
+                    $json_data_body->linkFonte . "','" . $json_data_body->linkVideo . "', " . $json_data_body->difficolta . ")";
+
+            $retNewID = $mysqlconnetion->insertRecord($query);
+        }
+
+        $pos = 0;
+        foreach ($json_data_body->ingredienti as $arr) {
+            $note = "";
+            if ($arr->note != "") {
+                $note = str_replace("'", "''", htmlentities($arr->note));
+            }
+
+            $query = "insert into ingredienti(ID_TIPO_INGREDIENTI, ID_RICETTE, Quantita, ID_TIPO_QUANTITA, Note, Posizione) values (" .
+                    $arr->ingrediente_id . "," . $retNewID . "," . ($arr->quantita == "" ? "0" : $arr->quantita) . "," . ($arr->tipo_quantita_id == "" ? "NULL" : $arr->tipo_quantita_id) . ",'" . $note . "'," . $pos . ")";
+
+            $mysqlconnetion->insertRecord($query);
+            $pos = $pos + 1;
+        }
+
+        $retValue["message"] = "Ricetta inserita con successo";
+    } catch (Exception $e) {
+        $retValue["message"] = $e->getMessage();
+    }
+
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retValue);
+});
+
+$app->get('/photos/', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    
+    $query = "SELECT * from ( SELECT id as ricetta_id, `titolo`,`autore`, ".
+    "   (select COUNT(*) from immagini where immagini.id_ricette = `ricette`.id) as num_img,".
+    "   (select COUNT(*) from immagini where immagini.id_ricette = `ricette`.id and immagini.published = 1) as num_img_pub".
+    " FROM `ricette`".
+    "   ) as tmp".
+    " WHERE tmp.num_img> 0";
+    
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/ricetta/:itemID/photos', function ($itemID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    
+    $query = "SELECT id as id_photo, type_format, from_profile_id, uploaded_date, profilo.Name as profile_name, published from immagini" .
+            " INNER JOIN profilo ON profilo.ProfiloID = immagini.from_profile_id".
+            " WHERE id_ricette = " . $itemID;
+    
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+    returnJson($app, $callbackFn, $retObj);
+});

profile.php

@@ -0,0 +1,111 @@
+<?php
+
+// inclusione del file contenente la classe
+//include "./MySqlClass.php";
+//include "./utility.php";
+
+$app->get('/profile/:keyStore/ricetta/:ricetta_id', function ($keyStore, $ricetta_id) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query = "select COUNT(*) as Exist FROM blocco_note where ricetta_id = " . $ricetta_id . " AND ProfiloID = '" . $keyStore . "'";
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj[0]["Exist"]);
+});
+
+$app->post('/profile/ricetta', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $json_data_body = json_decode($app->request()->post('dataPair'));
+    $mysqlconnetion = new MysqlClass;
+    $query = "insert into blocco_note(ricetta_id, ProfiloID) values (" . $json_data_body->ricetta_id . ", '" . $json_data_body->keyStore . "')";
+    $retNewID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+    
+    returnJson($app, $callbackFn, $retNewID);
+});
+
+$app->delete('/profile/:keyStore/ricetta/:ricetta_id', function ($keyStore, $ricetta_id) use ($app) {
+    //$callbackFn = $app->request()->params('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query = "delete from blocco_note where ricetta_id = " . $ricetta_id . " AND ProfiloID = '" . $keyStore . "'";
+
+    $retNewID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+
+    echo $retNewID;
+    //returnJson($app, $callbackFn, $retNewID);
+});
+
+$app->delete('/profile/:keyStore/ricette', function ($keyStore) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query = "delete from blocco_note where ProfiloID = '" . $keyStore . "'";
+
+    $retNewID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retNewID);
+});
+
+$app->get('/profile/:keyStore/ricette', function ($keyStore) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query = "select ID as ricetta_id, titolo, autore, valutazione, difficolta from ricette" .
+            " INNER JOIN blocco_note ON blocco_note.ricetta_id = ricette.id" .
+            " where blocco_note.ProfiloID = '" . $keyStore . "' order by titolo, autore";
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    foreach ($retObj as $ele) {
+        $ele["titolo"] = html_entity_decode($ele["titolo"]);
+    }
+    
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/profile/:keyStore', function ($keyStore) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query = "select ProfiloID, TipoAccesso, RisultatiRicerca, TemaUI, Name, Gender, 0 as NumRicette from profilo" .
+            " where ProfiloID = '" . $keyStore . "'";
+    $retObj = $mysqlconnetion->queryToObject($query);
+    
+    $query = "update profilo set PenultimoAccesso = UltimoAccesso, UltimoAccesso = NOW() where ProfiloID = '" . $keyStore . "'";
+    $mysqlconnetion->insertRecord($query);
+    
+    $query = "SELECT COUNT( * ) as NumRicette FROM ricette WHERE data_creazione > ( SELECT  PenultimoAccesso FROM profilo " .
+            "WHERE  `ProfiloID` =  '" . $keyStore . "' )";
+    
+    $retObj2 = $mysqlconnetion->queryToObject($query);
+    
+    $retObj[0]["NumRicette"] = $retObj2[0]["NumRicette"];
+    
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->post('/profile', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $json_data_body = json_decode($app->request()->post('dataPair'));
+    $mysqlconnetion = new MysqlClass;
+    $query = "insert into profilo(ProfiloID, Name, Email, Gender, TipoAccesso, RisultatiRicerca, TemaUI, UltimoAccesso, CreatoIl) values ('" . $json_data_body->keyStore . "', '" . $json_data_body->name . "', '" . $json_data_body->email . "', '" . $json_data_body->gender . "', '" . $json_data_body->type . "', '" . $json_data_body->risRic . "', '" . $json_data_body->tema . "', NOW(), NOW())";
+
+    $retNewID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+    
+    returnJson($app, $callbackFn, $retNewID);
+});
+
+$app->put('/profile', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $json_data_body = json_decode($app->request()->post('dataPair'));
+    $mysqlconnetion = new MysqlClass;
+    $query = "update profilo set RisultatiRicerca = '" . $json_data_body->risRic . "', TemaUI = '" . $json_data_body->tema . "' where ProfiloID = '" . $json_data_body->keyStore . "'";
+
+    $retNewID = $mysqlconnetion->insertRecord($query);
+    $mysqlconnetion->disconnetti();
+    
+    returnJson($app, $callbackFn, $retNewID);
+});
+
+?>

ricette.php

@@ -0,0 +1,178 @@
+<?php
+
+// inclusione del file contenente la classe
+require_once "./include.php";
+
+$app->get('/categories', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconneti	on->connetti();
+    $retObj = $mysqlconnetion->queryToObject("select ID as category_id, NAME as name from categorie order by name");
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/typeingredients', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $retObj = $mysqlconnetion->queryToObject("select ID as tipo_ingredienti_id, name from tipo_ingredienti order by name");
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/typeqtys', function () use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $retObj = $mysqlconnetion->queryToObject("select ID as tipo_quantita_id, name from tipo_quantita");
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/categoryitems/:catID', function ($categoryID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $query = "select ID as ricetta_id, titolo, autore, valutazione, difficolta from ricette where ID_CATEGORIA = " . $categoryID . " order by titolo, autore";
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    foreach ($retObj as $ele) {
+        $ele["titolo"] = html_entity_decode($ele["titolo"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    }
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/categoryitems/:categoryID/mostvote(/:numItems)', function ($categoryID, $numItems = 10) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $query = "select ID as ricetta_id, titolo, autore from ricette where ID_CATEGORIA = " . $categoryID . " order by Valutazione desc, titolo, autore LIMIT " . $numItems;
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    foreach ($retObj as $ele) {
+        $ele["titolo"] = html_entity_decode($ele["titolo"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    }
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/categoryitems/:categoryID/lastinserted(/:numItems)', function ($categoryID, $numItems = 10) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    //$mysqlconnetion->connetti();
+    $query = "select ID as ricetta_id, titolo, autore from ricette where ID_CATEGORIA = " . $categoryID . " order by Data_creazione desc, titolo, autore LIMIT " . $numItems;
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    foreach ($retObj as $ele) {
+        $ele["titolo"] = html_entity_decode($ele["titolo"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    }
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/categoryitems/search/:numItems(/:categoryId(/:difficolta(/:titolo)))', 
+        function ($numItems = 10, $categoryId = 0, $difficolta = 0, $titolo = "") use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    //$filterItem = json_decode($app->request()->post('post'));
+    $mysqlconnetion = new MysqlClass;
+    $query = "select ricette.ID as ricetta_id, categorie.name AS categoria_name, titolo, autore, valutazione, difficolta from ricette"
+            . " INNER JOIN categorie ON categorie.ID = ricette.id_categoria"
+            . " where 1 = 1";
+    if ($categoryId > 0) {
+        $query = $query . " AND ID_CATEGORIA = " . $categoryId;
+    }
+    if ($titolo != null && $titolo != "") {
+        foreach (explode(" ", $titolo) as $ele)
+			$query = $query . " AND titolo like '%" . $ele . "%'";
+    }
+    if ($difficolta > 0) {
+        $query = $query . " AND difficolta = " . $difficolta;
+    }
+    $query = $query . " order by titolo, autore LIMIT " . $numItems;    
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $mysqlconnetion->disconnetti();
+
+    foreach ($retObj as $ele) {
+        $ele["titolo"] = html_entity_decode($ele["titolo"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    }
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/ricetta/body/:itemID', function ($itemID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+
+    $query = "UPDATE ricette Set valutazione = valutazione + 1 WHERE ricette.ID = " . $itemID;
+    $mysqlconnetion->executeQuery($query);
+
+    $query = "SELECT id_categoria, categorie.name AS categoria_name, ricette.ID AS ricetta_id, titolo, procedimento, autore, link_fonte, link_youtube, valutazione FROM ricette INNER JOIN categorie ON categorie.ID = ricette.id_categoria WHERE ricette.ID = " . $itemID;
+    $retObj = $mysqlconnetion->queryToObject($query);
+
+    $query2 = "select ingredienti.id_tipo_ingredienti, tipo_ingredienti.name as nome_ingrediente, quantita, ingredienti.id_tipo_quantita, tipo_quantita.Name as unita, note, posizione from ingredienti " .
+            "inner join tipo_ingredienti on ingredienti.ID_TIPO_INGREDIENTI = tipo_ingredienti.ID " .
+            "left outer join tipo_quantita on ingredienti.ID_TIPO_QUANTITA = tipo_quantita.ID " .
+            "where ingredienti.ID_RICETTE = " . $itemID . " order by ingredienti.posizione";
+
+    $retObj2 = $mysqlconnetion->queryToObject($query2);
+
+    $retObj[0]["titolo"] = html_entity_decode($retObj[0]["titolo"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    $retObj[0]["procedimento"] = html_entity_decode($retObj[0]["procedimento"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    $retObj[0]["ingredienti"] = $retObj2;
+
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/ricetta/header/:itemID', function ($itemID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query = "UPDATE ricette Set valutazione = valutazione + 1 WHERE ricette.ID = " . $itemID;
+    $mysqlconnetion->executeQuery($query);
+    $query = "SELECT id_categoria, categorie.name AS categoria_name, ricette.ID AS ricetta_id, titolo, procedimento, autore, link_fonte, link_youtube, valutazione FROM ricette INNER JOIN categorie ON categorie.ID = ricette.id_categoria WHERE ricette.ID = " . $itemID;
+    $retObj = $mysqlconnetion->queryToObject($query);
+    $retObj[0]["titolo"] = html_entity_decode($retObj[0]["titolo"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    $retObj[0]["procedimento"] = html_entity_decode($retObj[0]["procedimento"], ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    $data = $retObj[0]["link_youtube"];
+    $output = array();
+    if ($data != "") {
+        $d = explode(";", $data);
+        $index = 0;
+        foreach ($d as $ele) {
+            $obj["VideoID"] = $ele;
+            $output[$index] = $obj;
+            $index++;
+        }
+    }
+    $retObj[0]["link_youtube"] = $output;
+    $mysqlconnetion->disconnetti();
+    returnJson($app, $callbackFn, $retObj);
+});
+
+$app->get('/ricetta/ingredienti/:itemID', function ($itemID) use ($app) {
+    $callbackFn = $app->request()->get('callback');
+    $mysqlconnetion = new MysqlClass;
+    $query2 = "select ingredienti.id_tipo_ingredienti, tipo_ingredienti.name as nome_ingrediente, quantita, ingredienti.id_tipo_quantita, tipo_quantita.Name as unita, note, posizione from ingredienti " .
+            "inner join tipo_ingredienti on ingredienti.ID_TIPO_INGREDIENTI = tipo_ingredienti.ID " .
+            "left outer join tipo_quantita on ingredienti.ID_TIPO_QUANTITA = tipo_quantita.ID " .
+            "where ingredienti.ID_RICETTE = " . $itemID . " order by ingredienti.posizione";
+
+    $retObj2 = $mysqlconnetion->queryToObject($query2);
+
+    //$retObj[0]["titolo"] = html_entity_decode($retObj[0]["titolo"]);
+    //$retObj[0]["procedimento"] = html_entity_decode($retObj[0]["procedimento"]);
+    //$retObj[0]["ingredienti"] = $retObj2;
+
+    $mysqlconnetion->disconnetti();
+
+    returnJson($app, $callbackFn, $retObj2);
+});
+?>

serviceapp.php

@@ -0,0 +1,16 @@
+<?php
+
+include_once "./include.php";
+
+$app->group('/api', function () use ($app) {
+    include "./ricette.php";
+    include "./profile.php";
+    include "./image.php";
+});
+
+$app->group('/backend', function () use ($app) {
+    include "./management.php";
+});
+//include "./image.php";
+
+$app->run();

utility.php

@@ -0,0 +1,78 @@
+<?php
+
+function utf8json($inArray) {
+
+    if (is_array($inArray)) {
+        static $depth = 0;
+
+        /* our return object */
+        $newArray = array();
+
+        /* safety recursion limit */
+        $depth ++;
+        if ($depth >= '300000') {
+            return false;
+        }
+
+        /* step through inArray */
+        foreach ($inArray as $key => $val) {
+            if (is_array($val)) {
+                /* recurse on array elements */
+                $newArray[$key] = utf8json($val);
+            } else {
+                /* encode string values */
+                $newArray[$key] = utf8_encode($val);
+            }
+        }
+        /* return utf8 encoded array */
+        return $newArray;
+    }
+    /* return utf8 encoded array */
+    return $inArray;
+}
+
+function returnJsonWithDecode($app, $callbackFn, $retObj) {
+    if ($callbackFn) {
+        $app->contentType('application/javascript; Charset=UTF-8');
+        echo $callbackFn . "(" . html_entity_decode(json_encode(utf8json($retObj)), ENT_COMPAT | ENT_HTML401, 'ISO-8859-1') . ")";
+    } else {
+        $app->contentType('application/x-json; Charset=UTF-8');
+        echo html_entity_decode(json_encode(utf8json($retObj)), ENT_COMPAT | ENT_HTML401, 'ISO-8859-1');
+    }
+}
+
+function returnJson($app, $callbackFn, $retObj) {
+    if ($callbackFn) {
+        $app->contentType('application/javascript; Charset=UTF-8');
+        echo $callbackFn . "(" . (json_encode(utf8json($retObj))) . ")";
+    } else {
+        $app->contentType('application/x-json; Charset=UTF-8');
+        echo (json_encode(utf8json($retObj)));
+    }
+}
+
+function makeThumbnail($im) {
+    $final_width_of_image = 300;
+    $ox = imagesx($im);
+    $oy = imagesy($im);
+
+    $nx = $final_width_of_image;
+    $ny = floor($oy * ($final_width_of_image / $ox));
+
+    $nm = imagecreatetruecolor($nx, $ny);
+
+    imagecopyresized($nm, $im, 0, 0, 0, 0, $nx, $ny, $ox, $oy);
+
+    return $nm;
+}
+
+function getContentFromResources($res) {
+    ob_start(); //Start output buffer.
+    imagejpeg($res); //This will normally output the image, but because of ob_start(), it won't.
+    $contents = ob_get_contents(); //Instead, output above is saved to $contents
+    ob_end_clean(); //End the output buffer.
+
+    return $contents;
+}
+
+?>