Beispiel #1
0
/**
 * Returns the part of the string left to the last occurrence of the separator
 *
 * @param $str string
 * @param $sep string
 * @param $cnt int
 * @param $complete_if_not bool
 * @return string
 */
function lLastParse($str, $sep, $cnt = 1, $complete_if_not = true)
{
    if ($cnt > 1) {
        $str = lLastParse($str, $sep, $cnt - 1);
    }
    $i = strrpos($str, $sep);
    if ($i === false) {
        return $complete_if_not ? $str : '';
    } else {
        return substr($str, 0, $i);
    }
}
 /**
  * @param $property Reflection_Property
  * @param $value    mixed
  * @param $preprop  string
  */
 public function __construct(Reflection_Property $property = null, $value = null, $preprop = null)
 {
     if (isset($property)) {
         $name = $property->pathAsField();
         if (strpos($name, '[')) {
             $preprop2 = lLastParse($name, '[');
             $preprop = $preprop ? $preprop . '[' . lParse($preprop2, '[') . '[' . rParse($preprop2, '[') : $preprop2;
             $name = lParse(rLastParse($name, '['), ']');
         }
         parent::__construct($name, $property->getType(), $value, $preprop);
         $this->null = $property->getAnnotation('null')->value;
         $this->property = $property;
         $this->readonly = $property->getListAnnotation('user')->has(User_Annotation::READONLY);
     } else {
         parent::__construct(null, null, $value, $preprop);
     }
 }
Beispiel #3
0
 /**
  * Parse a variable / function / include and returns its return value
  *
  * @param $property_name string can be an unique var or path.of.vars
  * @param $format_value  boolean
  * @return string var value after reading value / executing specs (can be an object)
  */
 protected function parseSingleValue($property_name, $format_value = true)
 {
     $property = $source_object = reset($this->objects);
     if ($property instanceof Reflection_Property_Value && $property_name == 'value') {
         if (($builder = $property->getAnnotation('widget')->value) && is_a($builder, Property::class, true)) {
             $builder = Builder::create($builder, [$property, $property->value(), $this]);
             /** @var $builder Property */
             $builder->parameters[Feature::F_EDIT] = Feature::F_EDIT;
             $value = $builder->buildHtml();
             if ($builder instanceof Value_Widget) {
                 $value = (new Html_Builder_Property($property, $value))->setTemplate($this)->build();
             }
         } else {
             $value = $property->getType()->isBoolean() ? $property->value() : parent::parseSingleValue($property_name, false);
             if (($preprop = lLastParse($property->pathAsField(), '[', 1, false)) && (!isset($this->cache[self::PARSED_ID]) || !isset($this->cache[self::PARSED_ID][$this->getFormId()]) || !isset($this->cache[self::PARSED_ID][$this->getFormId()][$preprop]))) {
                 $this->cache[self::PARSED_ID][$this->getFormId()][$preprop] = true;
                 if ($property instanceof Reflection_Property_Value) {
                     $parent_object = $property->getObject();
                     $id = isset($parent_object) ? Dao::getObjectIdentifier($parent_object) : null;
                     $html_builder_type = new Html_Builder_Type('id', null, $id, $preprop);
                     $id_value = $html_builder_type->setTemplate($this)->build();
                 } else {
                     $id_value = '';
                 }
             } else {
                 $id_value = '';
             }
             if ($property->getAnnotation('output')->value == 'string') {
                 $property->setAnnotationLocal('var')->value = 'string';
                 $value = isset($value) ? strval($value) : null;
                 $id_value = '';
             }
             $value = $id_value . (new Html_Builder_Property($property, $value))->setTemplate($this)->build();
         }
     } else {
         $value = parent::parseSingleValue($property_name);
     }
     return $value;
 }
Beispiel #4
0
 /**
  * Gets temporary file name, or write content into a temporary file name and get this name if not
  * set or file does not exist
  *
  * @return string
  */
 private function getTemporaryFileName()
 {
     if (isset($this->content) && (empty($this->temporary_file_name) || !file_exists($this->temporary_file_name))) {
         if (empty($this->temporary_file_name)) {
             $this->temporary_file_name = Application::current()->getTemporaryFilesPath() . SL . uniqid() . '_' . $this->name;
         }
         if (strpos($this->temporary_file_name, SL) !== false) {
             Files::mkdir(lLastParse($this->temporary_file_name, SL));
         }
         file_put_contents($this->temporary_file_name, $this->content);
     }
     return $this->temporary_file_name;
 }
Beispiel #5
0
include_once __DIR__ . '/saf/framework/functions/string_functions.php';
if ($argc < 3) {
    die('Arguments attendus : nickname helloworld' . LF);
}
$nickname = str_replace('.', '_', $argv[1]);
$project_name = str_replace('.', '_', $argv[2]);
$database = strtolower($nickname . '_' . $project_name);
$username = substr($database, 0, 16);
$project_password = uniqid();
$project_dir = __DIR__ . SL . strtolower($nickname . SL . $project_name);
$application_file = $project_dir . SL . 'Application.php';
$config_file = __DIR__ . SL . strtolower($project_name) . '.php';
$namespace = ucfirst($nickname) . BS . ucfirst($project_name);
$config_name = str_replace(BS, SL, $namespace);
$helloworld_template = $project_dir . SL . 'Application_home.html';
$alias_script = lLastParse(__DIR__, SL) . SL . strtolower($project_name) . '.php';
$application_dir = rLastParse(__DIR__, SL);
$local_file = __DIR__ . SL . 'loc.php';
$password_file = __DIR__ . SL . 'pwd.php';
$cache_dir = __DIR__ . SL . 'cache';
$tmp_dir = __DIR__ . SL . 'tmp';
$update_file = __DIR__ . SL . 'update';
$vendor_dir = __DIR__ . SL . 'vendor';
echo 'Initialization of your project ' . $namespace . '...' . LF;
echo '- Create directory ' . $project_dir . LF;
// /$nickname/$project/
if (!is_dir($project_dir)) {
    mkdir($project_dir, 0755, true);
}
echo '- Create application class file ' . $application_file . LF;
// /$nickname/$project/Application.php
Beispiel #6
0
 /**
  * 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'));
 }
Beispiel #7
0
 /**
  * @param $filter integer[] what to you want to get
  */
 private function get($filter)
 {
     $filter = array_flip($filter);
     $f_classes = isset($filter[self::CLASSES]);
     $f_dependencies = isset($filter[self::DEPENDENCIES]);
     $f_instantiates = isset($filter[self::INSTANTIATES]);
     $f_namespaces = isset($filter[self::NAMESPACES]);
     $f_requires = isset($filter[self::REQUIRES]);
     $f_uses = isset($filter[self::USES]);
     if ($f_classes) {
         $this->classes = [];
     }
     if ($f_dependencies) {
         $this->dependencies = [];
     }
     if ($f_instantiates) {
         $this->instantiates = [];
     }
     if ($f_namespaces) {
         $this->namespaces = [];
     }
     if ($f_requires) {
         $this->requires = [];
     }
     if ($f_uses) {
         $this->use = [];
     }
     // the current namespace
     $this->namespace = '';
     if ($this->internal) {
         return;
     }
     // a blank class to have a valid scan beginning, but has no any other use
     $class = new Reflection_Class($this, '');
     // how deep is the current class
     $class_depth = -1;
     // how deep we are in {
     $depth = 0;
     // where did the last } come
     $last_stop = null;
     // level for the T_USE clause : T_NAMESPACE, T_CLASS or T_FUNCTION (T_NULL if outside any level)
     $use_what = null;
     // what namespaces or class names does the current namespace use (key = val)
     $use = [];
     // scan tokens
     $this->getTokens();
     $tokens_count = count($this->tokens);
     for ($this->token_key = 0; $this->token_key < $tokens_count; $this->token_key++) {
         $token = $this->tokens[$this->token_key];
         $token_id = $token[0];
         if (isset($class_end) && is_array($token)) {
             $class->stop = $token[2] - 1;
             unset($class_end);
         }
         // stop
         if ($token_id === '{') {
             $depth++;
             $token = $this->tokens[++$this->token_key];
         }
         if ($token_id === '}') {
             $depth--;
             if ($depth === $class_depth) {
                 $class_end = true;
             }
             while ($this->token_key + 1 < $tokens_count && !is_array($token)) {
                 $token = $this->tokens[++$this->token_key];
             }
         }
         // namespace
         if ($token_id === T_NAMESPACE) {
             $use_what = T_NAMESPACE;
             $this->namespace = $this->scanClassName($this->token_key);
             $use = [];
             if ($f_namespaces) {
                 $this->namespaces[$this->namespace] = $token[2];
             }
         }
         // require_once
         if (in_array($token_id, [T_INCLUDE, T_INCLUDE_ONCE, T_REQUIRE, T_REQUIRE_ONCE])) {
             $eval = str_replace(['__DIR__', '__FILE__'], [Q . lLastParse($this->file_name, SL) . Q, Q . $this->file_name . Q], $this->scanRequireFilePath());
             if (strpos($eval, '$') !== false) {
                 $require_name = $eval;
             } elseif (strpos($eval, '::') === false && strpos($eval, '->') === false) {
                 /** @var $require_name string */
                 eval('$require_name = ' . $eval . ';');
                 if (!isset($require_name)) {
                     trigger_error('Bad $require_name ' . $eval . ' into ' . $this->file_name . ' line ' . $token[2], E_USER_ERROR);
                 }
                 $guard = 10;
                 while (strpos($require_name, '/../') && $guard--) {
                     $require_name = preg_replace('%\\w+/../%', '', $require_name);
                 }
                 if (!$guard) {
                     trigger_error('Guard woke up on ' . $require_name . ' into ' . $this->file_name . ' line ' . $token[2], E_USER_NOTICE);
                 }
             } else {
                 unset($require_name);
             }
             if (isset($require_name)) {
                 if ($class->name) {
                     $class->requires[$require_name] = $token[2];
                 } else {
                     $this->requires[$require_name] = $token[2];
                 }
             }
         } elseif ($token_id === T_USE) {
             // namespace use
             if ($use_what == T_NAMESPACE) {
                 foreach ($this->scanClassNames($this->token_key) as $used => $line) {
                     $use[$used] = $used;
                     if ($f_uses) {
                         $this->use[$used] = $line;
                     }
                 }
             } elseif ($use_what === T_CLASS) {
                 if ($f_dependencies) {
                     foreach ($this->scanTraitNames($this->token_key) as $trait_name => $line) {
                         $trait_name = $this->fullClassName($trait_name);
                         $dependency = new Dependency();
                         $dependency->class_name = $class->name;
                         $dependency->dependency_name = $trait_name;
                         $dependency->file_name = $this->file_name;
                         $dependency->line = $line;
                         $dependency->type = Dependency::T_USE;
                         $this->dependencies[] = $dependency;
                     }
                 }
             } elseif ($use_what == T_FUNCTION) {
                 // ...
             }
         } elseif (in_array($token_id, [T_CLASS, T_INTERFACE, T_TRAIT])) {
             $use_what = T_CLASS;
             $class_name = $this->fullClassName($this->scanClassName(), false);
             $class = new Reflection_Class($this, $class_name);
             $class->line = $token[2];
             $class->type = $token_id;
             $class_depth = $depth;
             if ($f_classes) {
                 $this->classes[$class_name] = $class;
             }
             $dependency = new Dependency();
             $dependency->class_name = $class->name;
             $dependency->declaration = self::$token_id_to_dependency_declaration[$token_id];
             $dependency->dependency_name = $class->name;
             $dependency->file_name = $this->file_name;
             $dependency->line = $token[2];
             $dependency->type = Dependency::T_DECLARATION;
             $this->dependencies[] = $dependency;
         } elseif ($token_id === T_FUNCTION) {
             $use_what = T_FUNCTION;
         } elseif (in_array($token_id, [T_EXTENDS, T_IMPLEMENTS])) {
             if ($f_dependencies) {
                 foreach ($this->scanClassNames() as $class_name => $line) {
                     $class_name = $this->fullClassName($class_name);
                     $dependency = new Dependency();
                     $dependency->class_name = $class->name;
                     $dependency->dependency_name = $class_name;
                     $dependency->file_name = $this->file_name;
                     $dependency->line = $line;
                     $dependency->type = $this->nameOf($token_id);
                     $this->dependencies[] = $dependency;
                 }
             }
         } elseif ($token_id === T_DOC_COMMENT) {
             if ($f_instantiates) {
                 $doc_comment = $token[1];
                 // 0 : everything until var name, 1 : type, 2 : Class_Name / $param, 3 : Class_Name
                 preg_match_all('%\\*\\s+@(param|return|var)\\s+([\\w\\$\\[\\]\\|\\\\]+)(?:\\s+([\\w\\$\\[\\]\\|\\\\]+))?%', $doc_comment, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
                 foreach ($matches as $match) {
                     list($class_name, $pos) = $match[2];
                     if ($class_name[0] === '$') {
                         list($class_name, $pos) = isset($match[3]) ? $match[3] : 'null';
                     }
                     foreach (explode('|', $class_name) as $class_name) {
                         if (ctype_upper($class_name[0])) {
                             $class_name = str_replace(['[', ']'], '', $class_name);
                             $line = $token[2] + substr_count(substr($doc_comment, 0, $pos), LF);
                             $type = $match[1][0];
                             $class_name = $this->fullClassName($class_name);
                             $dependency = new Dependency();
                             $dependency->class_name = $class->name;
                             $dependency->dependency_name = $class_name;
                             $dependency->file_name = $this->file_name;
                             $dependency->line = $line;
                             $dependency->type = $type;
                             $this->instantiates[] = $dependency;
                         }
                     }
                 }
             }
         } elseif ($token_id === T_DOUBLE_COLON) {
             if ($f_instantiates) {
                 $token = $this->tokens[$this->token_key - 1];
                 if ($token[1][0] !== '$' && !in_array($token[1], ['self', 'static', '__CLASS__'])) {
                     $tk = $this->token_key - 1;
                     $class_name = '';
                     do {
                         $class_name = $this->tokens[$tk][1] . $class_name;
                         $tk--;
                     } while (in_array($this->tokens[$tk][0], [T_NS_SEPARATOR, T_STRING]));
                     $type = $this->tokens[++$this->token_key];
                     $type = is_array($type) && $type[1] === 'class' ? Dependency::T_CLASS : Dependency::T_STATIC;
                     $class_name = $this->fullClassName($class_name);
                     $dependency = new Dependency();
                     $dependency->class_name = $class->name;
                     $dependency->dependency_name = $class_name;
                     $dependency->file_name = $this->file_name;
                     $dependency->line = $token[2];
                     $dependency->type = $type;
                     $this->instantiates[] = $dependency;
                 }
             } else {
                 $this->token_key++;
             }
         } elseif ($token_id === T_NEW) {
             if ($f_instantiates) {
                 $class_name = $this->scanClassName();
                 // $class_name is empty when 'new $class_name' (dynamic class name) : then ignore
                 if ($class_name) {
                     $class_name = $this->fullClassName($class_name);
                     $dependency = new Dependency();
                     $dependency->class_name = $class->name;
                     $dependency->dependency_name = $class_name;
                     $dependency->file_name = $this->file_name;
                     $dependency->line = $token[2];
                     $dependency->type = Dependency::T_NEW;
                     $this->instantiates[] = $dependency;
                 }
             }
         }
     }
 }
 /**
  * @param $parameters Parameters
  * @param $form       array
  * @param $files      array
  * @param $class_name string
  * @return mixed
  * @todo factorize
  */
 public function run(Parameters $parameters, $form, $files, $class_name)
 {
     // convert form files to worksheets and session files
     if ($files) {
         /** @var $import Import */
         $import = $parameters->getMainObject(Import::class);
         $import->class_name = $class_name;
         $form = (new Post_Files())->appendToForm($form, $files);
         foreach ($form as $file) {
             if ($file instanceof File) {
                 if (!isset($session_files)) {
                     /** @var $session_files Files */
                     $session_files = Builder::create(Files::class);
                 }
                 $excel = Spreadsheet_File::fileToArray($file->temporary_file_name, $errors);
                 $worksheet_number = 0;
                 foreach ($excel as $temporary_file_name => $worksheet) {
                     if (filesize($temporary_file_name) > 1) {
                         $import_worksheet = Builder::create(Import_Worksheet::class, [$worksheet_number++, Import_Settings_Builder::buildArray($worksheet, $class_name), $csv_file = Builder::create(File::class, [$temporary_file_name])]);
                         $import_worksheet->errors = $errors;
                         $session_files->files[] = $csv_file;
                         $import->worksheets[] = $import_worksheet;
                     }
                 }
                 // only one file once
                 break;
             }
         }
         if (isset($session_files)) {
             Session::current()->set($session_files);
         }
     } else {
         /** @var $files File[] */
         $files = Session::current()->get(Files::class)->files;
         $parameters->unshift($import = Import_Builder_Form::build($form, $files));
         $import->class_name = $class_name;
     }
     // prepare parameters
     $parameters = $parameters->getObjects();
     $general_buttons = $this->getGeneralButtons($class_name);
     if (isset($parameters['constant_remove']) && strtoupper($parameters['constant_remove'][0]) === $parameters['constant_remove'][0]) {
         $parameters['constant_remove'] = rParse($parameters['constant_remove'], DOT);
     }
     foreach ($import->worksheets as $worksheet) {
         // apply controller parameters
         if (isset($parameters['constant_add']) && isset($worksheet->settings->classes[$parameters['constant_add']])) {
             $worksheet->settings->classes[$parameters['constant_add']]->addConstant();
         }
         if (isset($parameters['constant_remove']) && isset($worksheet->settings->classes[lLastParse($parameters['constant_remove'], DOT, 1, false)])) {
             $worksheet->settings->classes[lLastParse($parameters['constant_remove'], DOT, 1, false)]->removeConstant(rLastParse($parameters['constant_remove'], DOT, 1, true));
         }
         Custom_Settings_Controller::applyParametersToCustomSettings($worksheet->settings, array_merge($form, $parameters));
     }
     // recover empty Import_Settings (after loading empty one)
     /** @var $files File[] */
     $files = Session::current()->get(Files::class)->files;
     foreach ($import->worksheets as $worksheet_number => $worksheet) {
         if (empty($worksheet->settings->classes)) {
             $file = $files[$worksheet_number];
             $array = $file->getCsvContent();
             $import->worksheets[$worksheet_number] = new Import_Worksheet($worksheet_number, Import_Settings_Builder::buildArray($array, $class_name), $file);
         }
     }
     // get general buttons and customized import settings
     foreach ($import->worksheets as $worksheet_number => $worksheet) {
         $customized_import_settings = $worksheet->settings->getCustomSettings();
         $worksheet_general_buttons = $general_buttons;
         if (!isset($customized_import_settings[$worksheet->settings->name])) {
             unset($worksheet_general_buttons['delete']);
         }
         $parameters['custom'][$worksheet_number] = new StdClass();
         $parameters['custom'][$worksheet_number]->customized_lists = $customized_import_settings;
         $parameters['custom'][$worksheet_number]->general_buttons = $worksheet_general_buttons;
         $parameters['custom'][$worksheet_number]->settings = $worksheet->settings;
         $parameters['custom'][$worksheet_number]->aliases_property = Import_Array::getPropertiesAlias($worksheet->settings->getClassName());
         $parameters['custom'][$worksheet_number]->properties_alias = array_flip($parameters['custom'][$worksheet_number]->aliases_property);
     }
     // view
     $parameters[Template::TEMPLATE] = 'importPreview';
     return View::run($parameters, $form, $files, $class_name, Feature::F_IMPORT);
 }