1: <?php
  2: 
  3: /**
  4:  * Container class that implements a container.
  5:  */
  6: class Papi_Container implements ArrayAccess {
  7: 
  8:     /**
  9:      * The classes holder.
 10:      *
 11:      * @var array
 12:      */
 13:     protected $classes = [];
 14: 
 15:     /**
 16:      * The keys holder.
 17:      *
 18:      * @var array
 19:      */
 20:     protected $keys = [];
 21: 
 22:     /**
 23:      * The values holder.
 24:      *
 25:      * @var array
 26:      */
 27:     protected $values = [];
 28: 
 29:     /**
 30:      * Set a parameter or an object.
 31:      *
 32:      * @param string $id
 33:      * @param mixed  $value
 34:      * @param bool   $singleton
 35:      *
 36:      * @throws Exception when singleton cannot be rebind.
 37:      *
 38:      * @return mixed
 39:      */
 40:     public function bind( $id, $value = null, $singleton = false ) {
 41:         if ( is_string( $id ) && $this->is_singleton( $id ) ) {
 42:             throw new Exception( sprintf(
 43:                 'Identifier `%s` is a singleton and cannot be rebind',
 44:                 $id
 45:             ) );
 46:         }
 47: 
 48:         if ( is_object( $id ) && get_class( $id ) !== false ) {
 49:             $value = $id;
 50:             $id    = $this->get_class_prefix( get_class( $id ), false );
 51:             $this->classes[$id] = true;
 52:         }
 53: 
 54:         if ( $value instanceof Closure ) {
 55:             $closure = $value;
 56:         } else {
 57:             $closure = $this->get_closure( $value, $singleton );
 58:         }
 59: 
 60:         $this->values[$id] = compact( 'closure', 'singleton' );
 61:         $this->keys[$id] = true;
 62: 
 63:         return $value;
 64:     }
 65: 
 66:     /**
 67:      * Call closure.
 68:      *
 69:      * @param mixed $closure
 70:      * @param array $parameters
 71:      *
 72:      * @return Closure
 73:      */
 74:     protected function call_closure( $closure, array $parameters = [] ) {
 75:         if ( $closure instanceof Closure ) {
 76:             $rc      = new ReflectionFunction( $closure );
 77:             $args    = $rc->getParameters();
 78:             $params  = $parameters;
 79:             $classes = [
 80:                 $this->get_class_prefix( get_class( $this ) ),
 81:                 get_class( $this ),
 82:                 get_parent_class( $this )
 83:             ];
 84: 
 85:             foreach ( $args as $index => $arg ) {
 86:                 if ( $arg->getClass() === null ) {
 87:                     continue;
 88:                 }
 89: 
 90:                 if ( in_array( $arg->getClass()->name, $classes ) ) {
 91:                     $parameters[$index] = $this;
 92:                 } else if ( $this->exists( $arg->getClass()->name ) ) {
 93:                     $parameters[$index] = $this->make( $arg->getClass()->name );
 94:                 }
 95:             }
 96: 
 97:             if ( ! empty( $args ) && empty( $parameters ) ) {
 98:                 $parameters[0] = $this;
 99:             }
100: 
101:             if ( count( $args ) > count( $parameters ) ) {
102:                 $parameters = array_merge( $parameters, $params );
103:             }
104: 
105:             return $this->call_closure(
106:                 call_user_func_array( $closure, $parameters ),
107:                 $parameters
108:             );
109:         }
110: 
111:         return $closure;
112:     }
113: 
114:     /**
115:      * Check if identifier is set or not.
116:      *
117:      * @param string $id
118:      *
119:      * @return bool
120:      */
121:     public function exists( $id ) {
122:         return isset( $this->keys[$this->get_class_prefix( $id )] );
123:     }
124: 
125:     /**
126:      * Get closure function.
127:      *
128:      * @param mixed $value
129:      * @param bool $singleton
130:      *
131:      * @return Closure
132:      */
133:     protected function get_closure( $value, $singleton = false ) {
134:         return function () use ( $value, $singleton ) {
135:             return $value;
136:         };
137:     }
138: 
139:     /**
140:      * Get class prefix.
141:      *
142:      * @param string $id
143:      * @param bool   $check
144:      *
145:      * @return string
146:      */
147:     protected function get_class_prefix( $id, $check = true ) {
148:         if ( strpos( $id, '\\' ) !== false && $id[0] !== '\\' ) {
149:             $class = '\\' . $id;
150: 
151:             if ( $check ) {
152:                 return isset( $this->classes[$class] ) ? $class : $id;
153:             }
154: 
155:             return $class;
156:         }
157: 
158:         return $id;
159:     }
160: 
161:     /**
162:      * Determine if a given type is a singleton or not.
163:      *
164:      * @param string $id
165:      *
166:      * @throws InvalidArgumentException if argument is not string.
167:      *
168:      * @return bool
169:      */
170:     public function is_singleton( $id ) {
171:         if ( ! is_string( $id ) ) {
172:             throw new InvalidArgumentException( 'Invalid argument. Must be string.' );
173:         }
174: 
175:         if ( ! $this->exists( $id ) ) {
176:             return false;
177:         }
178: 
179:         $id = $this->get_class_prefix( $id );
180: 
181:         return $this->values[$id]['singleton'] === true;
182:     }
183: 
184:     /**
185:      * Resolve the given type from the container.
186:      *
187:      * @param string $id
188:      * @param array $parameters
189:      *
190:      * @throws Exception if identifier is not defined.
191:      *
192:      * @return Closure
193:      */
194:     public function make( $id, array $parameters = [] ) {
195:         if ( ! $this->exists( $id ) ) {
196:             throw new Exception( sprintf(
197:                 'Identifier `%s` is not defined',
198:                 $id
199:             ) );
200:         }
201: 
202:         $id      = $this->get_class_prefix( $id );
203:         $value   = $this->values[$id];
204:         $closure = $value['closure'];
205: 
206:         return $this->call_closure( $closure, $parameters );
207:     }
208: 
209:     /**
210:      * Unset value by identifier.
211:      *
212:      * @param string $id
213:      */
214:     public function remove( $id ) {
215:         $id = $this->get_class_prefix( $id );
216:         unset( $this->keys[$id], $this->values[$id] );
217:     }
218: 
219:     /**
220:      * Set a parameter or an object.
221:      *
222:      * @param string $id
223:      * @param mixed $value
224:      *
225:      * @return mixed
226:      */
227:     public function singleton( $id, $value = null ) {
228:         return $this->bind( $id, $value, true );
229:     }
230: 
231:     /**
232:      * Check if identifier is set or not.
233:      *
234:      * @codeCoverageIgnore
235:      *
236:      * @param string $id
237:      *
238:      * @return bool
239:      */
240:     public function offsetExists( $id ) {
241:         return $this->exists( $id );
242:     }
243: 
244:     /**
245:      * Get value by identifier.
246:      *
247:      * @codeCoverageIgnore
248:      *
249:      * @param string $id
250:      *
251:      * @return mixed
252:      */
253:     public function offsetGet( $id ) {
254:         return $this->make( $id );
255:     }
256: 
257:     /**
258:      * Set a parameter or an object.
259:      *
260:      * @codeCoverageIgnore
261:      *
262:      * @param string $id
263:      * @param mixed $value
264:      */
265:     public function offsetSet( $id, $value ) {
266:         $this->bind( $id, $value );
267:     }
268: 
269:     /**
270:      * Unset value by identifier.
271:      *
272:      * @codeCoverageIgnore
273:      *
274:      * @param string $id
275:      */
276:     public function offsetUnset( $id ) {
277:         $this->remove( $id );
278:     }
279: }
280: