PHP Fluent::get方法代码示例

 /**
  * Deactivate an extension.
  *
  * @param  \Orchestra\Contracts\Extension\Listener\Deactivator  $listener
  * @param  \Illuminate\Support\Fluent  $extension
  *
  * @return mixed
  */
 public function deactivate(Listener $listener, Fluent $extension)
 {
     if (!$this->factory->started($extension->get('name')) && !$this->factory->activated($extension->get('name'))) {
         return $listener->abortWhenRequirementMismatched();
     }
     $this->factory->deactivate($extension->get('name'));
     return $listener->deactivationHasSucceed($extension);
 }

 /**
  * Determing if it is just an empty directory
  *
  * @return bool
  */
 public function isEmptyDir()
 {
     $emptyDir = $this->ingredient->get('empty-dir');
     if (is_null($emptyDir)) {
         return false;
     }
     return $emptyDir;
 }

 public function get($key, $default = null)
 {
     if ($key === 'date') {
         return $this->dateTime();
     }
     return parent::get($key, $default);
 }

 /**
  * Update/migrate an extension.
  *
  * @param  \Orchestra\Contracts\Extension\Listener\Migrator  $listener
  * @param  \Illuminate\Support\Fluent  $extension
  *
  * @return mixed
  */
 public function migrate(Listener $listener, Fluent $extension)
 {
     if (!$this->factory->started($extension->get('name'))) {
         return $listener->abortWhenRequirementMismatched();
     }
     return $this->execute($listener, 'migration', $extension, $this->getMigrationClosure());
 }

 /**
  * Magic method to get items by key.
  *
  * @param  string  $key
  *
  * @return mixed
  */
 public function __get($key)
 {
     if (!isset($this->items->{$key})) {
         return;
     }
     return $this->items->get($key);
 }

 /**
  * Vaildate if expression contains the reserve keys
  *
  * @param  array $expression
  * @return boolean
  * @throws  \Elepunk\Evaluator\Exceptions\MissingKeyException
  */
 protected function verifyExpression(Fluent $expression)
 {
     foreach ($this->reservedKeys as $key) {
         if (is_null($expression->get($key))) {
             throw new MissingKeyException("Expression is missing {$key}");
         }
     }
     return true;
 }

 /**
  * Execute extension processing.
  *
  * @param  object  $listener
  * @param  string  $type
  * @param  \Illuminate\Support\Fluent  $extension
  * @param  \Closure  $callback
  *
  * @return mixed
  */
 protected function execute($listener, $type, Fluent $extension, Closure $callback)
 {
     $name = $extension->get('name');
     try {
         // Check if folder is writable via the web instance, this would
         // avoid issue running Orchestra Platform with debug as true where
         // creating/copying the directory would throw an ErrorException.
         if (!$this->factory->permission($name)) {
             throw new FilePermissionException("[{$name}] is not writable.");
         }
         call_user_func($callback, $this->factory, $name);
     } catch (FilePermissionException $e) {
         return call_user_func([$listener, "{$type}HasFailed"], $extension, ['error' => $e->getMessage()]);
     }
     return call_user_func([$listener, "{$type}HasSucceed"], $extension);
 }

 /**
  * Update an extension configuration.
  *
  * @param  \Orchestra\Contracts\Extension\Listener\Configure  $listener
  * @param  \Illuminate\Support\Fluent  $extension
  * @param  array  $input
  *
  * @return mixed
  */
 public function update(Listener $listener, Fluent $extension, array $input)
 {
     if (!Extension::started($extension->get('name'))) {
         return $listener->suspend(404);
     }
     $validation = $this->validator->with($input, ["orchestra.validate: extension.{$extension->get('name')}"]);
     if ($validation->fails()) {
         return $listener->updateConfigurationFailedValidation($validation->getMessageBag(), $extension->uid);
     }
     $memory = Foundation::memory();
     $config = (array) $memory->get("extension.active.{$extension->get('name')}.config", []);
     $input = new Fluent(array_merge($config, $input));
     unset($input['_token']);
     Event::fire("orchestra.saving: extension.{$extension->get('name')}", [&$input]);
     $memory->put("extensions.active.{$extension->get('name')}.config", $input->getAttributes());
     $memory->put("extension_{$extension->get('name')}", $input->getAttributes());
     Event::fire("orchestra.saved: extension.{$extension->get('name')}", [$input]);
     return $listener->configurationUpdated($extension);
 }

 /**
  * Queue publishing asset to publisher.
  *
  * @param  \Illuminate\Support\Fluent  $extension
  *
  * @return mixed
  */
 protected function queueToPublisher(Fluent $extension)
 {
     Publisher::queue($extension->get('name'));
     return $this->redirect(handles('orchestra::publisher'));
 }

 /**
  * Response when sync roles succeed.
  *
  * @param  \Illuminate\Support\Fluent   $acl
  *
  * @return mixed
  */
 public function syncSucceed(Fluent $acl)
 {
     $message = trans('orchestra/control::response.acls.sync-roles', ['name' => $acl->get('name')]);
     return $this->redirectWithMessage(handles("orchestra::control/acl?name={$acl->get('name')}"), $message);
 }

 /**
  * @param string $key
  * @param mixed|null $default
  * @return mixed
  */
 public function get($key, $default = null)
 {
     $value = parent::get($key, $default);
     return $this->hasGetMutator($key) ? $this->mutateAttribute($key, $value) : $value;
 }

 /**
  * Response when extension migration has succeed.
  *
  * @param  \Illuminate\Support\Fluent  $extension
  *
  * @return mixed
  */
 public function migrationHasSucceed(Fluent $extension)
 {
     $this->info("Extension [{$extension->get('name')}] updated.");
 }

 /**
  * Response when extension deactivation has succeed.
  *
  * @param  \Illuminate\Support\Fluent  $extension
  *
  * @return mixed
  */
 public function deactivationHasSucceed(Fluent $extension)
 {
     $this->refreshRouteCache();
     $this->info("Extension [{$extension->get('name')}] deactivated.");
 }

 /**
  * Resolve field value.
  *
  * @param  string  $name
  * @param  mixed  $row
  * @param  \Illuminate\Support\Fluent  $control
  *
  * @return mixed
  */
 protected function resolveFieldValue($name, $row, Fluent $control)
 {
     // Set the value from old input, followed by row value.
     $value = $this->request->old($name);
     $model = data_get($row, $name);
     if (!is_null($model) && is_null($value)) {
         $value = $model;
     }
     if (is_null($control->get('value'))) {
         return $value;
     }
     $value = $control->get('value');
     // If the value is set from the closure, we should use it instead of
     // value retrieved from attached data. Should also check if it's a
     // closure, when this happen run it.
     if ($value instanceof Closure) {
         $value = $value($row, $control);
     }
     return $value;
 }

 /**
  * @param $value
  * @param Fluent $ruleArgs
  * @return Carbon
  */
 public function buildTimestamp($value, $ruleArgs)
 {
     if (is_null($value)) {
         return $this->newDateObject();
     }
     if ($value instanceof \DateTime) {
         return $this->newDateFromTimestamp($value->getTimestamp(), $value->getTimezone());
     }
     if (is_numeric($value)) {
         return $this->newDateFromTimestamp($value);
     } elseif (is_string($value) && preg_match('/^(\\d{4})-(\\d{2})-(\\d{2})$/', $value)) {
         return $this->newDateObject($value, 'Y-m-d');
     } else {
         return $this->newDateObject($value, $ruleArgs->get('format'));
     }
 }