public function afterFetch() { // dodawanie pól json if (empty($this->template_id) === false) { $jsonable = Cache::get("template{$this->template_id}_jsonable", function () { $jsonable = []; foreach ($this->template->field->toArray() as $key => $value) { $code = \Yaml::parse($value['code']); if (isset($code['jsonable']) && $code['jsonable'] == true) { $jsonable[] = $value['name']; } } Cache::put("template{$this->template_id}_jsonable", $jsonable, 3); return $jsonable; }); foreach ($jsonable as $value) { $this->jsonable[] = $value; } } if (empty($this->additional) === false) { // wstrzykiwanie wartości pól do modelu foreach ($this->additional as $key => $value) { $this->{$key} = in_array($key, $this->jsonable) ? json_decode($value) : $value; } } }
public static function getConfig($key = null) { if (!static::$config) { $file = static::getConfigJson(); if (!file_exists($file)) { file_put_contents($file, json_encode(Yaml::parse(static::getConfigYml()))); } static::$config = json_decode(file_get_contents($file), true); static::_bindConfig(self::$config); static::_bindConfig(self::$config); } if (!$key) { return static::$config; } if (array_key_exists($key, static::$config)) { return static::$config[$key]; } if (strpos($key, '.') !== false) { $parts = explode('.', $key, 2); $data = static::getConfig($parts[0]); $data = UtilArray::cascadeGet($data, $parts[1]); if ($data) { return $data; } } throw new Exception("Config '{$key}' not found"); }
/** * Loads the routes of a bundle. * * @param string $name Bundle name * * @return bool */ public function loadBundleRoutes($name) { $routes_path = BUNDLE . $name . '/routing.yml'; if (file_exists($routes_path)) { $content = file_get_contents($routes_path); $this->bundle_routes = Yaml::parse($content); return true; } else { return false; } }
/** * Parses a YAML file or string * @param string $input The YAML file path or YAML string * @param bool $isString Switch to true for string input instead of file * @return array * @throws \InvalidArgumentException when config cannot be parsed */ public static function fromYaml($input, $isString = false) { $contents = $isString ? $input : file_get_contents($input); $yaml = Yaml::parse(trim($contents)); if (null === $yaml) { // empty file $yaml = []; } if (!is_array($yaml)) { // not an array throw new \InvalidArgumentException(sprintf('The input "%s" must ' . 'contain or be a valid YAML structure.', $input)); } return $yaml; }
/** * {@inheritdoc} */ public function load(SetInterface $files) : MapInterface { if ((string) $files->type() !== 'string') { throw new InvalidArgumentException(); } $config = (new Processor())->processConfiguration(new Configuration(), $files->reduce([], function (array $carry, string $file) { $carry[] = Yaml::parse(file_get_contents($file)); return $carry; })); $directories = new Map('string', Directory::class); foreach ($config as $key => $value) { $directories = $directories->put($key, $this->loadDirectory($key, $value)); } return $directories; }
/** * Opens a translation file, and stores its content. * * @param string $file_path The path of the file to open */ private function openFile($file_path, $stop = false) { if (file_exists($file_path)) { $this->file_content = Yaml::parse(file_get_contents($file_path)); if (!empty($this->file_content)) { $this->file_path = $file_path; } return true; } else { if (ENVIRONMENT == 'production') { $this->file_content = ''; return true; } else { if ($stop == false) { $this->setVar('file_path', $file_path); App::translate("translation_file_missing", $this, ['bundle' => false, 'theme' => 'sybil', 'domain' => 'debug'], true); die; } else { App::debug('[TRANSLATION_ERROR: File "' . $file_path . '" is missing.]'); die; } } } }
/** */ private function loadPluginFiles() { $dir = $this->sitePath . '/config/plugins'; if (is_readable($dir)) { $files = scandir($dir); foreach ($files as $file) { if ($file == '.' || $file == '..') { continue; } $basename = pathinfo($file, PATHINFO_FILENAME); $content = $this->loadFile($dir . '/' . $file); $this->set('plugins.config.' . $basename, Yaml::parse($content)); } } }
/** * Get page * * <code> * $page = Pages::getPage('downloads'); * </code> * * @access public * @param string $url Url * @return array */ public static function getPage($url) { // If url is empty that its a homepage if ($url) { $file = STORAGE_PATH . '/pages/' . $url; } else { $file = STORAGE_PATH . '/pages/' . 'index'; } // Select the file if (is_dir($file)) { $file = STORAGE_PATH . '/pages/' . $url . '/index.md'; } else { $file .= '.md'; } // Get 404 page if file not exists if (!file_exists($file)) { $file = STORAGE_PATH . '/pages/' . '404.md'; Response::status(404); } // Create Unique Cache ID for requested page $page_cache_id = md5('page' . ROOT_DIR . $file . filemtime($file)); if (Cache::driver()->contains($page_cache_id) && Config::get('system.pages.flush_cache') == false) { return Cache::driver()->fetch($page_cache_id); } else { $content = file_get_contents($file); $_page = explode('---', $content, 3); $page = Yaml::parse($_page[1]); $url = str_replace(STORAGE_PATH . '/pages', Url::getBase(), $file); $url = str_replace('index.md', '', $url); $url = str_replace('.md', '', $url); $url = str_replace('\\', '/', $url); $url = rtrim($url, '/'); $page['url'] = $url; $_content = $_page[2]; // Parse page for summary <!--more--> if (($pos = strpos($_content, "<!--more-->")) === false) { $_content = Filter::apply('content', $_content); } else { $_content = explode("<!--more-->", $_content); $_content['summary'] = Filter::apply('content', $_content[0]); $_content['content'] = Filter::apply('content', $_content[0] . $_content[1]); } if (is_array($_content)) { $page['summary'] = $_content['summary']; $page['content'] = $_content['content']; } else { $page['content'] = $_content; } $page['slug'] = basename($file, '.md'); // Overload page title, keywords and description if needed empty($page['title']) and $page['title'] = Config::get('site.title'); empty($page['keywords']) and $page['keywords'] = Config::get('site.keywords'); empty($page['description']) and $page['description'] = Config::get('site.description'); Cache::driver()->save($page_cache_id, $page); return $page; } }
/** * Process a form submission * * @return void */ private function process() { /* |-------------------------------------------------------------------------- | Prep form and handler variables |-------------------------------------------------------------------------- | | We're going to assume success = true here to simplify code readability. | Checks already exist for require and validation so we simply flip the | switch there. | */ $success = true; $errors = array(); /* |-------------------------------------------------------------------------- | Hidden fields and $_POST hand off |-------------------------------------------------------------------------- | | We slide the hidden key out of the POST data and assign the rest to a | cleaner $submission variable. | */ $hidden = $_POST['hidden']; unset($_POST['hidden']); $submission = $_POST; /* |-------------------------------------------------------------------------- | Grab formset and collapse settings |-------------------------------------------------------------------------- | | Formset settings are merged on top of the default raven.yaml config file | to allow per-form overrides. | */ $formset_name = array_get($hidden, 'formset'); $formset = $formset_name . '.yaml'; if (File::exists('_config/add-ons/raven/formsets/' . $formset)) { $formset = Yaml::parse('_config/add-ons/raven/formsets/' . $formset); } elseif (File::exists('_config/formsets/' . $formset)) { $formset = Yaml::parse('_config/formsets/' . $formset); } else { $formset = array(); } if (!is_array($this->config)) { $this->log->warn('Could not find the config file.'); $this->config = array(); } $config = array_merge($this->config, $formset, array('formset' => $hidden['formset'])); /* |-------------------------------------------------------------------------- | Prep filters |-------------------------------------------------------------------------- | | We jump through some PHP hoops here to filter, sanitize and validate | our form inputs. | */ $allowed_fields = array_flip(array_get($formset, 'allowed', array())); $required_fields = array_flip(array_get($formset, 'required', array())); $validation_rules = isset($formset['validate']) ? $formset['validate'] : array(); $messages = isset($formset['messages']) ? $formset['messages'] : array(); $referrer = Request::getReferrer(); $return = array_get($hidden, 'return', $referrer); $error_return = array_get($hidden, 'error_return', $referrer); /* |-------------------------------------------------------------------------- | Allowed fields |-------------------------------------------------------------------------- | | It's best to only allow a set of predetermined fields to cut down on | spam and misuse. | */ if (count($allowed_fields) > 0) { $submission = array_intersect_key($submission, $allowed_fields); } /* |-------------------------------------------------------------------------- | Required fields |-------------------------------------------------------------------------- | | Requiring fields isn't required (ironic-five!), but if any are specified | and missing from the POST, we'll be squashing this submission right here | and sending back an array of missing fields. | */ if (count($required_fields) > 0) { $missing = array_flip(array_diff_key($required_fields, array_filter($submission))); if (count($missing) > 0) { foreach ($missing as $key => $field) { $errors['missing'][] = array('field' => $field); } $success = false; } } /* |-------------------------------------------------------------------------- | Validation |-------------------------------------------------------------------------- | | Run optional per-field validation. Any data failing the specified | validation rule will squash the submission and send back error messages | as specified in the formset. | */ $invalid = $this->validate($submission, $validation_rules); // Prepare a data array of fields and error messages use for template display if (count($invalid) > 0) { $errors['invalid'] = array(); foreach ($invalid as $field) { $errors['invalid'][] = array('field' => $field, 'message' => isset($messages[$field]) ? $messages[$field] : null); } $success = false; } /* |-------------------------------------------------------------------------- | Upload Files |-------------------------------------------------------------------------- | | Upload any files to their specified destination. | */ if (count($_FILES) > 0) { $files = array_intersect_key($_FILES, $allowed_fields); $upload_destination = array_get($config, 'upload_destination'); foreach ($files as $name => $file) { $submission[$name] = File::upload($file, $upload_destination); } } /* |-------------------------------------------------------------------------- | Hook: Pre Process |-------------------------------------------------------------------------- | | Allow pre-processing by other add-ons with the ability to kill the | success of the submission. Has access to the submission and config. | */ $success = Hook::run('raven', 'pre_process', 'replace', $success, compact('submission', 'config', 'success')); /* |-------------------------------------------------------------------------- | Form Identifier |-------------------------------------------------------------------------- | | In the event of multiple forms on a page, we'll be able to determine | which one was the one that had been triggered. | */ $this->flash->set('form_id', $hidden['raven']); /* |-------------------------------------------------------------------------- | Finalize & determine action |-------------------------------------------------------------------------- | | Send back the errors if validation or require fields are missing. | If successful, save to file (if enabled) and send notification | emails (if enabled). | */ if ($success) { // Akismet? $is_spam = false; if ($akismet = array_get($config, 'akismet') && array_get($config, 'akismet_api_key')) { $is_spam = $this->tasks->akismetCheck(array('permalink' => URL::makeFull(URL::getCurrent()), 'comment_type' => $formset_name, 'comment_author' => array_get($submission, array_get($akismet, 'author')), 'comment_author_email' => array_get($submission, array_get($akismet, 'email')), 'comment_author_url' => array_get($submission, array_get($akismet, 'url')), 'comment_content' => array_get($submission, array_get($akismet, 'content')))); } // Shall we save? if (array_get($config, 'submission_save_to_file', false) === true) { $file_prefix = Parse::template(array_get($config, 'file_prefix', ''), $submission); $file_suffix = Parse::template(array_get($config, 'file_suffix', ''), $submission); $file_prefix = $is_spam ? '_' . $file_prefix : $file_prefix; $this->save($submission, $config, $config['submission_save_path'], $is_spam); } // Shall we send? if (!$is_spam && array_get($config, 'send_notification_email', false) === true) { $this->send($submission, $config); } /* |-------------------------------------------------------------------------- | Hook: On Success |-------------------------------------------------------------------------- | | Allow events after the form as been processed. Has access to the | submission and config. | */ Hook::run('raven', 'on_success', null, null, array('submission' => $submission, 'config' => $config)); $this->flash->set('success', true); URL::redirect(URL::format($return)); } else { $this->flash->set('success', false); $this->flash->set('errors', $errors); $this->flash->set('old_values', $_POST); URL::redirect(URL::format($error_return)); } }
public function testIncludeFiles() { $data = $this->parser->parse(__DIR__ . '/../../../support/fixtures/include.yml'); $expectedData = array('Nelmio\\Alice\\fixtures\\Product' => array('product_base (template)' => array('status' => 'in_stock', 'site' => '<word()>', 'changed' => 'n', 'locked' => '<word()>', 'cancelled' => '<word()>', 'canBuy' => 'y', 'package' => 'n', 'price' => '<randomFloat()>', 'amount' => 1, 'markDeleted' => '<word()>', 'paid' => 'y'), 'product1' => array('amount' => 45, 'paid' => 'n', 'user' => '@user0'), 'product0' => array('changed' => 'y', 'user' => '@user1')), 'Nelmio\\Alice\\fixtures\\Shop' => array('shop2' => array('domain' => 'amazon.com'), 'shop1' => array('domain' => 'ebay.com')), 'Nelmio\\Alice\\fixtures\\User' => array('user_base (template)' => array('email' => '<email()>'))); $this->assertEquals($expectedData, $data); }
/** * Is the task ticker running? * * @return boolean */ public static function areTasksRunning() { $ticks_path = BASE_PATH . "/_cache/_add-ons/tasks/ticks.yaml"; // check that the file exists if (!File::exists($ticks_path)) { return false; } // parse the ticks file $ticks = Yaml::parse($ticks_path); // check that last-tick exists if (!is_array($ticks) || !isset($ticks['last-tick'])) { return false; } // return whether the last tick was less than 5 minutes ago return time() - $ticks['last-tick'] < 60; }
/** * Loads a YAML file. * * @param string $file * * @return array The file content */ private function loadFile($file) { return $this->validate(Yaml::parse($file), $file); }
private function getRoutes() { $this->routes = \Yaml::parse(file_get_contents(_THEME_DIR_ . 'landing/' . $this->routesFile)); error_log(print_r($this->routes)); }