File vendor/phpixie/http/src/PHPixie/HTTP/Builder.php

  1: <?php
  2: 
  3: namespace PHPixie\HTTP;
  4: 
  5: use PHPixie\Slice;
  6: 
  7: /**
  8:  * HTTP factory
  9:  */
 10: class Builder
 11: {
 12:     /**
 13:      * @var Slice
 14:      */
 15:     protected $slice;
 16: 
 17:     /**
 18:      * @var array
 19:      */
 20:     protected $instances = array();
 21: 
 22:     /**
 23:      * Builder constructor
 24:      * @param Slice $slice
 25:      */
 26:     public function __construct($slice) {
 27:         $this->slice = $slice;
 28:     }
 29: 
 30:     /**
 31:      * Message factory
 32:      * @return Messages
 33:      */
 34:     public function messages()
 35:     {
 36:         return $this->instance('messages');
 37:     }
 38: 
 39:     /**
 40:      * Response factory
 41:      * @return Responses
 42:      */
 43:     public function responses()
 44:     {
 45:         return $this->instance('responses');
 46:     }
 47: 
 48:     /**
 49:      * Output
 50:      * @return Output
 51:      */
 52:     public function output()
 53:     {
 54:         return $this->instance('output');
 55:     }
 56: 
 57:     /**
 58:      * Build PHPixie request from PSR-7 ServerRequest
 59:      * @param $serverRequest
 60:      * @return Request
 61:      */
 62:     public function request($serverRequest)
 63:     {
 64:         return new Request($this, $serverRequest);
 65:     }
 66: 
 67:     /**
 68:      * Proxy for building slice data
 69:      * @param array $array
 70:      * @return Slice\Type\ArrayData
 71:      */
 72:     public function data($array = array())
 73:     {
 74:         return $this->slice->arrayData($array);
 75:     }
 76: 
 77:     /**
 78:      * Build headers storage
 79:      * @param array $headerArray
 80:      * @return Data\Headers
 81:      */
 82:     public function headers($headerArray = array())
 83:     {
 84:         return new Data\Headers($headerArray);
 85:     }
 86: 
 87:     /**
 88:      * Build editable headers storage
 89:      * @param array $headerArray
 90:      * @return Data\Headers\Editable
 91:      */
 92:     public function editableHeaders($headerArray = array())
 93:     {
 94:         return new Data\Headers\Editable($headerArray);
 95:     }
 96: 
 97:     /**
 98:      * Build server data storage
 99:      * @param array $serverData
100:      * @return Data\Server
101:      */
102:     public function serverData($serverData = array())
103:     {
104:         return new Data\Server($serverData);
105:     }
106: 
107:     /**
108:      * Build HTTP context
109:      * @param Request $request
110:      * @param Context\Cookies $cookies
111:      * @param Context\Session\SAPI $session
112:      * @return Context
113:      */
114:     public function context($request, $cookies, $session)
115:     {
116:         return new Context($request, $cookies, $session);
117:     }
118: 
119:     /**
120:      * Build cookie storage
121:      * @param array $cookieArray
122:      * @return Context\Cookies
123:      */
124:     public function cookies($cookieArray = array())
125:     {
126:         return new Context\Cookies($this, $cookieArray);
127:     }
128: 
129:     /**
130:      * Build default session storage
131:      * @return Context\Session\SAPI
132:      */
133:     public function sapiSession()
134:     {
135:         return new Context\Session\SAPI();
136:     }
137: 
138:     /**
139:      * Build a single cookie update
140:      * @param            $name
141:      * @param            $value
142:      * @param null       $expires
143:      * @param string     $path
144:      * @param null       $domain
145:      * @param bool       $secure
146:      * @param bool       $httpOnly
147:      * @return Context\Cookies\Update
148:      */
149:     public function cookiesUpdate(
150:         $name,
151:         $value,
152:         $expires = null,
153:         $path = '/',
154:         $domain = null,
155:         $secure = false,
156:         $httpOnly = false
157:     )
158:     {
159:         return new Context\Cookies\Update(
160:             $name,
161:             $value,
162:             $expires,
163:             $path,
164:             $domain,
165:             $secure,
166:             $httpOnly
167:         );    
168:     }
169: 
170:     /**
171:      * Build context container
172:      * @param $context
173:      * @return Context\Container\Implementation
174:      */
175:     public function contextContainer($context)
176:     {
177:         return new Context\Container\Implementation($context);
178:     }
179: 
180:     /**
181:      * @param $name
182:      * @return mixed
183:      */
184:     protected function instance($name)
185:     {
186:         if(!array_key_exists($name, $this->instances)) {
187:             $method = 'build'.ucfirst($name);
188:             $this->instances[$name] = $this->$method();
189:         }
190:         
191:         return $this->instances[$name];
192:     }
193: 
194:     /**
195:      * @return Messages
196:      */
197:     protected function buildMessages()
198:     {
199:         return new Messages();
200:     }
201: 
202:     /**
203:      * @return Responses
204:      */
205:     protected function buildResponses()
206:     {
207:         return new Responses($this);
208:     }
209: 
210:     /**
211:      * @return Output
212:      */
213:     protected function buildOutput()
214:     {
215:         return new Output();
216:     }
217: }
Namespaces

Classes

Interfaces

Exceptions
