/** * @param $view_name string the view name is the associated data class name * @param $feature_names string[] feature and inherited feature which view will be searched * @param $template string if a specific template is set, the view named with it will be * searched into the view / feature namespace first * @return callable */ private static function getView($view_name, $feature_names, $template = null) { $view_engine_name = get_class(View::current()); $view_engine_name = Namespaces::shortClassName(Namespaces::of($view_engine_name)); if (isset($template)) { foreach ([$view_engine_name . '_View', 'View'] as $suffix) { foreach ($feature_names as $feature_name) { list($class, $method) = Getter::get($view_name, $feature_name, Names::methodToClass($template) . '_' . $suffix, 'php'); if (isset($class)) { break 2; } } } } if (!isset($class)) { foreach ([$view_engine_name . '_View', 'View'] as $suffix) { foreach ($feature_names as $feature_name) { list($class, $method) = Getter::get($view_name, $feature_name, $suffix, 'php'); if (isset($class)) { break 2; } } } } if (!isset($class)) { list($class, $method) = [__CLASS__ . BS . $view_engine_name . BS . 'Default_View', 'run']; } /** @noinspection PhpUndefinedVariableInspection if $class is set, then $method is set too */ return [$class, $method]; }
/** * @param $result Table */ public function afterHtmlBuilderMultipleBuild(Table $result) { if ($this->in_multiple == 'build') { $table = $result; $length = count($table->body->rows) - 1; if ($this->count->count > $length) { // vertical scrollbar $vertical_scroll_bar = new Standard_Cell(); $vertical_scroll_bar->addClass('vertical'); $vertical_scroll_bar->addClass('scrollbar'); $vertical_scroll_bar->setAttribute('rowspan', 1000000); $vertical_scroll_bar->setData('start', 0); $vertical_scroll_bar->setData('length', $length); $vertical_scroll_bar->setData('total', $this->count->count); $link = '/Html_Edit_Multiple/output/' . Namespaces::shortClassName($this->property->getDeclaringClass()) . SL . Dao::getObjectIdentifier($this->property->getObject()) . SL . $this->property->name . SL . '?move='; $up = new Anchor($link . 'up'); $up->addClass('up'); $position = new Anchor($link . 1); $position->addClass('position'); $down = new Anchor($link . 'down'); $down->addClass('down'); $vertical_scroll_bar->setContent($up . $position . $down); // add vertical scrollbar cells to multiple (collection or map) table $table->head->rows[0]->addCell(new Header_Cell(), 0); $table->body->rows[0]->addCell($vertical_scroll_bar, 0); } $this->in_multiple = ''; } }
/** * @param $source Reflection_Source the PHP source file object * @param $compiler PHP\Compiler the main compiler * @return boolean true if compilation process did something, else false */ public function compile(Reflection_Source $source, PHP\Compiler $compiler = null) { $compiled = false; foreach ($source->getClasses() as $class) { // replace extends with the built replacement class if (!Builder::isBuilt($class->name)) { $parent_class_name = $class->getParentName(); if ($parent_class_name) { $replacement_class_name = Builder::className($parent_class_name); if ($replacement_class_name != $parent_class_name) { $class_exists = class_exists($replacement_class_name, false); if ($class_exists && is_a($replacement_class_name, $parent_class_name) || !$class_exists && Reflection_Source::of($replacement_class_name)->getClass($replacement_class_name)->isA($class->name)) { $replacement_class_name = $parent_class_name; } } if (is_array($replacement_class_name)) { trigger_error("Replacement classes should all be compiled", E_USER_ERROR); $compiler->addSource($source); } elseif ($replacement_class_name !== $parent_class_name && Builder::isBuilt($replacement_class_name)) { $extended = null; $buffer = $source->getSource(); $short_class_name = Namespaces::shortClassName($class->name); $buffer = preg_replace_callback('%(\\s+class\\s+' . $short_class_name . '\\s+extends\\s+)([\\\\\\w]+)(\\s+)%', function ($match) use(&$extended, $replacement_class_name) { $extended = $match[2]; return $match[1] . BS . $replacement_class_name . $match[3]; }, $buffer); if ($extended) { $buffer = preg_replace_callback('%(\\n\\s+\\*\\s+@link\\s+)(' . str_replace(BS, BS . BS, $extended) . ')(\\s+)%', function ($match) use($replacement_class_name) { return $match[1] . BS . $replacement_class_name . $match[3]; }, $buffer); } $source->setSource($buffer); $compiled = true; } } } } return $compiled; }
/** * Create a table in database, which has no associated class, using fields names * * @param $mysqli mysqli * @param $table_name string * @param $column_names string[] * @return boolean * @todo mysqli context should contain sql builder (ie Select) in order to know if this was * an implicit link table. If then : only one unique index should be built */ private function createImplicitTable(mysqli $mysqli, $table_name, $column_names) { $only_ids = true; $table = new Table($table_name); $ids_index = new Index(); $ids_index->setType(Index::UNIQUE); $indexes = []; foreach ($column_names as $column_name) { $table->addColumn($column_name === 'id' ? Column::buildId() : Column::buildLink($column_name)); if (substr($column_name, 0, 3) === 'id_') { if ($mysqli instanceof Contextual_Mysqli && is_array($mysqli->context)) { $ids_index->addKey($column_name); $index = Index::buildLink($column_name); foreach ($mysqli->context as $context_class) { $id_context_property = 'id_' . Names::classToProperty(Names::setToSingle(Dao::storeNameOf($context_class))); $id_context_property_2 = 'id_' . Names::classToProperty(Names::setToSingle(Namespaces::shortClassName($context_class))); if (in_array($column_name, [$id_context_property, $id_context_property_2])) { $table->addForeignKey(Foreign_Key::buildLink($table_name, $column_name, $context_class)); break; } } $indexes[] = $index; } } else { $only_ids = false; } } if ($only_ids) { $table->addIndex($ids_index); } else { foreach ($indexes as $index) { $table->addIndex($index); } } $mysqli->query((new Create_Table($table))->build()); return true; }
/** * @param $content string * @param $i integer * @param $j integer */ protected function parseUse(&$content, &$i, $j) { $class_name = substr($content, $i + 4, $j - $i - 4); $this->use[Namespaces::shortClassName($class_name)] = $class_name; $content = substr($content, 0, $i - 4) . substr($content, $j + 3); }
/** * Replace code before <!--BEGIN--> and after <!--END--> by the html main container's code * * @param $content string * @return string updated content */ protected function parseContainer($content) { $i = strpos($content, '<!--BEGIN-->'); if ($i !== false) { $i += 12; $j = strrpos($content, '<!--END-->', $i); $short_class = Namespaces::shortClassName(get_class(reset($this->objects))); $short_form_id = strtolower($short_class) . '_edit'; $this->form_id = $short_form_id . '_' . $this->nextFormCounter(); $action = SL . $short_class . '/write'; $content = substr($content, 0, $i) . $this->replaceSectionByForm(substr($content, $i, $j - $i), $action) . substr($content, $j); } return parent::parseContainer($content); }
/** * Gets the store name for records typed as $class_name * * @param $class_name string * @return string */ public function storeNameOf($class_name) { return strtolower(Namespaces::shortClassName(Names::classToSet($class_name))); }
/** * @return string */ protected static function customId() { return lParse(strtolower(Namespaces::shortClassName(get_called_class())), '_settings'); }
/** * @param $search array|object * @param $row array * @param $class Import_Class * @param $class_properties_column integer[] * @return object */ public function importSearchObject($search, $row, Import_Class $class, $class_properties_column) { if ($this->simulation && isset($search)) { $this->simulateSearch($class, $search, $class->class_name); } $found = isset($search) ? Dao::search($search, $class->class_name) : null; if (!isset($found)) { $object = null; } elseif (count($found) == 1) { $object = $this->updateExistingObject(reset($found), $row, $class, $class_properties_column); } elseif (!count($found)) { if ($class->object_not_found_behaviour === 'create_new_value') { $object = $this->writeNewObject($row, $class, $class_properties_column); } elseif ($class->object_not_found_behaviour === 'tell_it_and_stop_import') { trigger_error('Not found ' . $class->class_name . SP . print_r($search, true), E_USER_ERROR); $object = null; } else { $object = null; } } else { echo '<pre class="error">SEARCH = ' . print_r($search, true) . '</pre>'; echo '<pre class="error">FOUND = ' . print_r($found, true) . '</pre>'; trigger_error('Multiple ' . Namespaces::shortClassName($class->class_name) . ' found', E_USER_ERROR); $object = null; } return $object; }
/** * Gets annotation name (the displayable root of the annotation class name, when set) * * @return string */ public function getAnnotationName() { return Names::classToDisplay(lLastParse(Namespaces::shortClassName(get_class($this)), '_Annotation')); }
/** * Gets built name space for a class name * * @param $class_name string ie 'SAF\Framework\Module\Class_Name' * @return string ie 'Vendor\Application\Built\SAF\Framework\Module\Class_Name' */ public static function builtClassName($class_name) { $namespace = array_slice(explode(BS, Namespaces::of($class_name)), 1); $left = Application::current()->getNamespace(); $namespace = $left . BS . 'Built' . BS . join(BS, $namespace); $built_class = $namespace . BS . Namespaces::shortClassName($class_name); return $built_class; }
/** * Gets the constructor of the reflected class * * @return Reflection_Method */ public function getConstructor() { $methods = $this->getMethods(); if (isset($methods['__construct'])) { return $methods['__construct']; } else { $short_class_name = Namespaces::shortClassName($this->name); if (isset($methods[$short_class_name])) { return $methods[$short_class_name]; } } return null; }
/** * Changes 'A\Namespace\Class_Names' into 'A\Namespace\Class_Name' * * @param $class_name string * @param $check_class boolean false if you don't want to check for existing classes * @return string */ public static function setToClass($class_name, $check_class = true) { $set_class_name = $class_name; $class_name = Namespaces::shortClassName($class_name); $right = ''; do { $class_name = self::setToSingle($class_name); $full_class_name = Namespaces::defaultFullClassName($class_name . $right, $set_class_name); if (@class_exists($full_class_name) || trait_exists($full_class_name, false)) { return $full_class_name; } $i = strrpos($class_name, '_'); if (strrpos($class_name, BS) > $i) { $i = false; } if ($i === false) { if ((@class_exists($set_class_name) || trait_exists($set_class_name, false)) && (new Reflection_Class($set_class_name))->getAnnotation('set')->value == $set_class_name) { return $set_class_name; } elseif ($check_class && error_reporting()) { trigger_error('No class found for set ' . $set_class_name, E_USER_ERROR); } else { $right = substr($class_name, $i) . $right; $class_name = substr($class_name, 0, $i); } } else { $right = substr($class_name, $i) . $right; $class_name = substr($class_name, 0, $i); } } while (!empty($class_name)); $class_name .= $right; if (class_exists($class_name, false) || trait_exists($class_name, false)) { return $class_name; } elseif (strrpos($set_class_name, '_') > strrpos($set_class_name, BS)) { $namespace = Namespaces::of($set_class_name); $class_name = substr($set_class_name, strpos($set_class_name, '_', strlen($namespace)) + 1); return self::setToClass($namespace . BS . $class_name, $check_class); } else { return $set_class_name; } }
/** * @param $class_name string * @return string */ private function addClassPath($class_name) { $result = ''; foreach ($this->filesFor(Namespaces::shortClassName($class_name)) as $file_name) { $in_class_name = $this->fileToClassName($file_name); if ($in_class_name) { $this->changes = true; $this->class_paths[$in_class_name] = $file_name; if ($in_class_name == $class_name) { $result = $file_name; break; } } } return $result; }