Ejemplo n.º 1
0
 /**
  * Construct stream.
  *
  * @param string|resource $streamOrPath A resource or path.
  * @param string $mode Stream mode, see {@see fopen}.
  * @throws InvalidArgumentException If the stream can not be opened.
  */
 public function __construct($streamOrPath, $mode = 'rb')
 {
     if (is_resource($streamOrPath)) {
         $this->stream = $streamOrPath;
     } else {
         \Jivoo\Assume::isString($streamOrPath);
         $error = ErrorHandler::detect(function () use($streamOrPath, $mode) {
             $this->stream = fopen($streamOrPath, $mode);
         });
         if ($error or $this->stream === false) {
             throw new InvalidArgumentException('Could not open stream', 0, $error);
         }
     }
 }
Ejemplo n.º 2
0
Archivo: Enum.php Proyecto: jivoo/data
 /**
  * Get values of an enum class.
  *
  * @param string $class
  *            Class name.
  * @throws InvalidEnumException If the class invalid or does not contain
  *         constants.
  * @return string[] Enum values.
  */
 public static function getValues($class = null)
 {
     if (!isset($class)) {
         $class = get_called_class();
     }
     if (!isset(self::$values[$class])) {
         if (!self::classExists($class)) {
             throw new InvalidEnumException('Enum class not found: ' . $class);
         }
         $class = self::$classes[$class];
         Assume::isSubclassOf($class, 'Jivoo\\Models\\Enum');
         $ref = new \ReflectionClass($class);
         self::$values[$class] = array_flip($ref->getConstants());
         if (count(self::$values[$class]) < 1) {
             throw new InvalidEnumException('Enum type "' . $class . '" must contain at least one constant');
         }
     }
     return self::$values[$class];
 }
Ejemplo n.º 3
0
 /**
  * Converts expiration timestamp, interval, {\DateInterval} or {\DateTime}
  * to a {\DateTime} or null (for no expiration date).
  *
  * @param int|\DateInterval|\DateTime|null $expiration
  *            Timestamp or interval.
  *            Null and the integer 0 is interpreted as 'no expiration date'.
  *            If the integer is less than or equal to 2,592,000 (30 days), the time
  *            is relative to the current timestamp, otherwise it is interpreted as an
  *            absolute UNIX timestamp.
  * @return \DateTime|null
  */
 public static function convertExpiration($expiration)
 {
     if ($expiration === null or $expiration === 0) {
         return null;
     }
     if (is_int($expiration)) {
         if ($expiration <= 2592000) {
             $expiration += time();
         }
         return \DateTime::createFromFormat('U', $expiration);
     }
     if ($expiration instanceof \DateTime) {
         return $expiration;
     }
     Assume::that($expiration instanceof \DateInterval);
     $d = new \DateTime();
     return $d->add($expiration);
 }
Ejemplo n.º 4
0
Archivo: Uri.php Proyecto: jivoo/http
 /**
  * {@inheritdoc}
  */
 public function withPort($port)
 {
     \Jivoo\Assume::that($port > 0 and $port < 65535);
     $uri = clone $this;
     $uri->port = $port;
     return $uri;
 }
Ejemplo n.º 5
0
 /**
  * Prepare selection, e.g.
  * by joining with join table.
  *
  * @param BasicSelection $selection
  *            Input selection or null for source.
  * @return ReadSelection Resulting selection.
  */
 private function prepareSelection(BasicSelection $selection = null)
 {
     if (!isset($selection)) {
         return $this->source;
     }
     $selection->alias($this->alias);
     if (isset($this->join)) {
         Assume::that($selection instanceof ReadSelection);
         $selection = $selection->leftJoin($this->join, $this->otherPrimary . '= J.' . $this->otherKey, 'J')->where('J.' . $this->thisKey . ' = ?', $this->recordId);
     } else {
         $selection = $selection->where($this->thisKey . ' = ?', $this->recordId);
         if ($selection instanceof SelectionBuilder) {
             $selection = $selection->toReadSelection();
         }
     }
     if (isset($this->condition)) {
         $selection = $selection->where($this->condition);
     }
     return $selection;
 }
Ejemplo n.º 6
0
 /**
  *
  * @param string $expression
  * @return ParseInput
  */
 public static function lex($expression, $vars = array())
 {
     $lexer = new RegexLexer(true, 'i');
     $lexer->is = 'is';
     $lexer->not = 'not';
     $lexer->bool = 'true|false';
     $lexer->null = 'null';
     $lexer->operator = 'like|in|!=|<>|>=|<=|!<|!>|=|<|>|and|or';
     $lexer->dot = '\\.';
     $lexer->name = '[a-z][a-z0-9]*';
     $lexer->model = '\\{(.+?)\\}';
     $lexer->modelPlaceholder = '%(model|m)';
     $lexer->field = '\\[(.+?)\\]';
     $lexer->fieldPlaceholder = '%(column|field|c)';
     $lexer->number = '-?(0|[1-9]\\d*)(\\.\\d+)?([eE][+-]?\\d+)?';
     $lexer->string = '"((?:[^"\\\\]|\\\\.)*)"';
     $lexer->placeholder = '((\\?)|%([a-z_\\\\]+))(\\(\\))?';
     $lexer->map('model', function ($value, $matches) {
         return $matches[1];
     });
     $lexer->map('field', function ($value, $matches) {
         return $matches[1];
     });
     $lexer->map('number', function ($value) {
         if (strpos($value, '.') !== false or stripos($value, 'e') !== false) {
             return new Literal(DataType::float(), floatval($value));
         } else {
             return new Literal(DataType::integer(), intval($value));
         }
     });
     $lexer->mapType('number', 'literal');
     $lexer->map('string', function ($value, $matches) {
         return new Literal(DataType::text(), stripslashes($matches[1]));
     });
     $lexer->mapType('string', 'literal');
     $lexer->map('bool', function ($value) {
         return new Literal(DataType::boolean(), strtolower($value) == 'true');
     });
     $lexer->mapType('bool', 'literal');
     $lexer->map('model', function ($value, $matches) {
         return $matches[1];
     });
     $lexer->map('field', function ($value, $matches) {
         return $matches[1];
     });
     $i = 0;
     $lexer->map('modelPlaceholder', function ($value, $matches) use(&$i, $vars) {
         $value = $vars[$i];
         $i++;
         if (!is_string($value)) {
             Assume::that($value instanceof Model);
             $value = $value->getName();
         }
         return $value;
     });
     $lexer->mapType('modelPlaceholder', 'model');
     $lexer->map('fieldPlaceholder', function ($value, $matches) use(&$i, $vars) {
         $value = $vars[$i];
         $i++;
         Assume::that(is_string($value));
         return $value;
     });
     $lexer->mapType('fieldPlaceholder', 'field');
     $lexer->map('placeholder', function ($value, $matches) use(&$i, $vars) {
         $value = $vars[$i];
         $i++;
         $type = null;
         if (isset($matches[3])) {
             if ($matches[3] == '_') {
                 if (!is_string($value)) {
                     Assume::that($value instanceof DataType);
                     $value = $value->placeholder;
                 }
                 $matches[3] = ltrim($value, '%');
                 $value = $vars[$i];
                 $i++;
             }
             if ($matches[3] == 'e' or $matches[3] == 'expr' or $matches[3] == 'expression') {
                 Assume::that($value instanceof Expression);
                 return $value;
             }
             if ($matches[3] != '()') {
                 $type = DataType::fromPlaceholder($matches[3]);
             }
         }
         if (!isset($type)) {
             $type = DataType::detectType($value);
         }
         if (isset($matches[4]) or isset($matches[3]) and $matches[3] == '()') {
             Assume::isArray($value);
             foreach ($value as $key => $v) {
                 $value[$key] = $v;
             }
             return new ArrayLiteral($type, $value);
         }
         return new Literal($type, $value);
     });
     $lexer->mapType('placeholder', 'literal');
     return new ParseInput($lexer($expression));
 }
Ejemplo n.º 7
0
Archivo: E.php Proyecto: jivoo/data
 /**
  * Substitute and encode variables in an expression.
  *
  * Placeholders (see also {@see DataType::fromPlaceHolder()}:
  * <code>
  * true // Boolean true
  * false // Boolean false
  * {AnyModelName} // A model name
  * [anyFieldName] // A column/field name
  * "any string" // A string
  * ? // Any scalar value.
  * %e %expr %expression // A subexpression (instance of {@see Expression})
  * %m %model // A table/model object or name
  * %c %column %field // A column/field name
  * %_ // A placeholder placeholder, can also be a type, e.g. where(..., 'id = %_', $type, $value)
  * %i %int %integer // An integer value
  * %f %float // A floating point value
  * %s %str %string // A string
  * %t $text // Text
  * %b %bool %boolean // A boolean value
  * %date // A date value
  * %d %datetime // A date/time value
  * %n %bin %binary // A binary object
  * %AnyEnumClassName // An enum value of that class
  * %anyPlaceholder() // A tuple of values
  * </code>
  *
  * @param string|Condition $format
  *            Expression format, use placeholders instead of values.
  * @param mixed[] $vars
  *            List of values to replace placeholders with.
  * @param Quoter $quoter
  *            Quoter object for quoting identifieres and literals.
  * @return string The interpolated expression.
  */
 public static function interpolate($format, $vars, Quoter $quoter)
 {
     if ($format instanceof self) {
         return $format->toString($quoter);
     }
     Assume::isString($format);
     $boolean = DataType::boolean();
     $true = $quoter->quoteLiteral($boolean, true);
     $false = $quoter->quoteLiteral($boolean, false);
     $format = preg_replace('/\\btrue\\b/i', $true, $format);
     $format = preg_replace('/\\bfalse\\b/i', $false, $format);
     $string = DataType::text();
     $format = preg_replace_callback('/"((?:[^"\\\\]|\\\\.)*)"|\\{(.+?)\\}|\\[(.+?)\\]/', function ($matches) use($quoter, $string) {
         if (isset($matches[3])) {
             return $quoter->quoteField($matches[3]);
         } elseif (isset($matches[2])) {
             return $quoter->quoteModel($matches[2]);
         } else {
             return $quoter->quoteLiteral($string, stripslashes($matches[1]));
         }
     }, $format);
     $i = 0;
     return preg_replace_callback('/((\\?)|%([a-z_\\\\]+))(\\(\\))?/i', function ($matches) use($vars, &$i, $quoter) {
         $value = $vars[$i];
         $i++;
         $type = null;
         if (isset($matches[3])) {
             if ($matches[3] == '_') {
                 if (!is_string($value)) {
                     Assume::that($value instanceof DataType);
                     $value = $value->placeholder;
                 }
                 $matches[3] = ltrim($value, '%');
                 $value = $vars[$i];
                 $i++;
             }
             if ($matches[3] == 'e' or $matches[3] == 'expr' or $matches[3] == 'expression') {
                 Assume::that($value instanceof Expression);
                 return '(' . $value->toString($quoter) . ')';
             }
             if ($matches[3] == 'm' or $matches[3] == 'model') {
                 if (!is_string($value)) {
                     Assume::that($value instanceof Model);
                     $value = $value->getName();
                 }
                 return $quoter->quoteModel($value);
             }
             if ($matches[3] == 'c' or $matches[3] == 'column' or $matches[3] == 'field') {
                 Assume::isString($value);
                 return $quoter->quoteField($value);
             }
             if ($matches[3] != '()') {
                 $type = DataType::fromPlaceholder($matches[3]);
             }
         }
         if (!isset($type)) {
             $type = DataType::detectType($value);
         }
         if (isset($matches[4]) or isset($matches[3]) and $matches[3] == '()') {
             Assume::isArray($value);
             foreach ($value as $key => $v) {
                 $value[$key] = $quoter->quoteLiteral($type, $v);
             }
             return '(' . implode(', ', $value) . ')';
         }
         return $quoter->quoteLiteral($type, $value);
     }, $format);
 }
Ejemplo n.º 8
0
 public static function sort($data, $field, $descending = false, $assoc = true)
 {
     Assume::isArray($data);
     $func = function (array $a, array $b) use($field, $descending) {
         if ($a[$field] == $b[$field]) {
             return 0;
         }
         if ($descending) {
             if (is_numeric($a[$field])) {
                 return $b[$field] - $a[$field];
             }
             return strcmp($b[$field], $a[$field]);
         } else {
             if (is_numeric($a[$field])) {
                 return $a[$field] - $b[$field];
             }
             return strcmp($a[$field], $b[$field]);
         }
     };
     if ($assoc) {
         uasort($data, $func);
     } else {
         usort($data, $func);
     }
     return $data;
 }
Ejemplo n.º 9
0
 /**
  * Construct data type.
  *
  * @param int $type
  *            Type.
  * @param bool $null
  *            Null.
  * @param mixed $default
  *            Default value.
  * @param int $flags
  *            Integer flags.
  * @param int|null $length
  *            String length.
  * @throws \InvalidArgumentException When type is invalid.
  */
 protected function __construct($type, $null = false, $default = null, $flags = 0, $length = null)
 {
     Assume::that($type >= 1 and $type <= 10);
     $this->type = $type;
     $this->length = $length;
     $this->default = $default;
     $this->null = $null;
     if ($type == self::INTEGER) {
         $this->signed = ($flags & self::UNSIGNED) == 0;
         $this->serial = ($flags & self::SERIAL) != 0;
         $this->size = $flags & 0x30;
     }
 }
Ejemplo n.º 10
0
 /**
  * Translate a string containing a numeric value, e.g.
  * <code>$l->nget('This post has %1 comments', 'This post has %1 comment', $numcomments);</code>
  *
  * @param string $plural
  *            Message in english (plural).
  * @param string $singular
  *            Singular version of message in english.
  * @param int|array|\Countable $n
  *            The integer to test, replaces the
  *            %1-placeholder in the message. May also be an array or a {@see \Countable},
  *            in which case {@see count} will be called on the value.
  * @param mixed $vars,...
  *            Values for additional placholders starting from %2.
  * @return Translated string.
  * @throws \Jivoo\InvalidArgumentException If $n is not an integer, an
  *         array, or a {@see \Countable}.
  */
 public function nget($plural, $singular, $n)
 {
     if (is_array($n) or $n instanceof \Countable) {
         $n = count($n);
     }
     Assume::that(is_scalar($n));
     $n = intval($n);
     if (isset($this->messages[$plural])) {
         $i = intval(eval($this->pluralExpr));
         $message = $this->messages[$plural][0];
         if (isset($this->messages[$plural][$i])) {
             $message = $this->messages[$plural][$i];
         }
     } elseif (abs($n) == 1) {
         $message = $singular;
     } else {
         $message = $plural;
     }
     return $this->replacePlaceholders($message, array_slice(func_get_args(), 2));
 }
Ejemplo n.º 11
0
 /**
  * Make a database connection.
  *
  * @param string|Document|array $name
  *            Name of database connection.
  * @param DatabaseDefinition $definition
  *            Database definition (collecton of table definitions).
  * @throws ConfigurationException If the $options-array does not
  *         contain the necessary information for a connection to be made.
  * @throws InvalidSchemaException If one of the schema names listed
  *         in the $schemas-parameter is unknown.
  * @throws ConnectionException If the connection fails.
  * @return LoadableDatabase A database object.
  */
 public function connect($name, DatabaseDefinition $definition = null)
 {
     if (is_string($name)) {
         if (!isset($this->config[$name])) {
             throw new ConfigurationException('Database "' . $name . '" not configured');
         }
         $config = $this->config->getSubset($name);
     } elseif (is_array($name)) {
         $config = new Document($name);
         unset($name);
     } else {
         Assume::isInstanceOf($name, 'Jivoo\\Store\\Document');
         $config = $name;
         unset($name);
     }
     $driver = $config->get('driver', null);
     if (!isset($driver)) {
         throw new ConfigurationException('Database driver not set');
     }
     try {
         $driverInfo = $this->checkDriver($driver);
     } catch (InvalidDriverException $e) {
         throw new ConnectionException('Invalid database driver: ' . $e->getMessage(), 0, $e);
     }
     foreach ($driverInfo['requiredOptions'] as $option) {
         if (!isset($config[$option])) {
             throw new ConfigurationException('Database option missing: "' . $option . '"');
         }
     }
     try {
         $class = 'Jivoo\\Data\\Database\\Drivers\\' . $driver . '\\' . $driver . 'Database';
         Assume::isSubclassOf($class, 'Jivoo\\Data\\Database\\LoadableDatabase');
         if (!isset($definition)) {
             $definition = new DatabaseDefinitionBuilder([]);
         }
         $object = new $class($definition, $config);
         $object->setLogger($this->logger);
         if (isset($name)) {
             $this->connections[$name] = new DatabaseSchema($object);
         }
         return $object;
     } catch (ConnectionException $exception) {
         throw new ConnectionException('Database connection failed (' . $driver . '): ' . $exception->getMessage(), 0, $exception);
     }
 }
Ejemplo n.º 12
0
 /**
  * Update a document key.
  *
  * @param string $key
  *            The document key to access.
  * @param mixed $value
  *            The value to associate with the key.
  */
 public function set($key, $value)
 {
     Assume::that(is_scalar($key));
     if (isset($this->emptySubset)) {
         $this->createTrueSubset();
     }
     $oldValue = null;
     if (isset($this->data[$key])) {
         $oldValue = $this->data[$key];
     }
     if (isset($key) and isset($value) and $key !== '') {
         $this->data[$key] = $value;
     } else {
         $this->data[$key] = null;
     }
     if (!$this->root->updated and $oldValue !== $value) {
         $this->root->updated = true;
         $this->root->update();
     }
 }
Ejemplo n.º 13
0
 /**
  * {@inheritdoc}
  */
 public function saveDeferred(CacheItem $item)
 {
     if (!isset($this->data)) {
         $this->read();
     }
     Assume::isInstanceOf($item, 'Jivoo\\Cache\\MutableItem');
     $expiration = $item->getExpiration();
     if (isset($expiration)) {
         $expiration = $expiration->getTimestamp();
     }
     $this->data[$item->getKey()] = array($item->get(), $expiration);
     return true;
 }
Ejemplo n.º 14
0
 /**
  * Validate a route.
  *
  * @param string|array|Route|HasRoute $route A route array, string, or
  * object.
  * @return Route\Route Validated route.
  * @throws Route\RouteError If the route is invalid.
  * @throws \Jivoo\InvalidArgumentException If `$route` is not a recognized
  * type.
  */
 public function validate($route)
 {
     if ($route instanceof Route\Route) {
         return $route;
     }
     if ($route instanceof Route\HasRoute) {
         return $this->validate($route->getRoute());
     }
     if (is_callable($route)) {
         return new Route\CallableRoute($route);
     }
     if (is_string($route)) {
         if ($route == '') {
             $route = $this->findMatch([], 'GET');
             if (!isset($route)) {
                 throw new Route\RouteException('No root route');
             }
             return $route;
         } else {
             if (preg_match('/^([a-zA-Z0-9\\.\\-+]+):/', $route, $matches) === 1) {
                 $prefix = $matches[1];
                 if (isset($this->schemePrefixes[$prefix])) {
                     $scheme = $this->schemePrefixes[$prefix];
                     return $scheme->fromString($route);
                 }
                 throw new Route\RouteException('Unknown route scheme: ' . $prefix);
             }
             // TODO: use current scheme .. e.g. 'action:' if in a controller
             throw new Route\RouteException('Missing route scheme');
         }
     }
     \Jivoo\Assume::isArray($route);
     $default = ['parameters' => [], 'query' => [], 'fragment' => '', 'mergeQuery' => false];
     $scheme = null;
     $parameters = [];
     foreach ($route as $key => $value) {
         if (is_int($key)) {
             $parameters[] = $value;
         } elseif ($key == 'parameters') {
             $parameters = array_merge($parameters, $value);
         } elseif (in_array($key, ['query', 'fragment', 'mergeQuery'])) {
             $default[$key] = $value;
         } elseif (isset($this->schemeKeys[$key])) {
             $default[$key] = $value;
             if (!isset($scheme)) {
                 $scheme = $this->schemeKeys[$key];
             }
         } else {
             throw new Route\RouteException('Undefined key in route: ' . $key);
         }
     }
     $route = $default;
     if (count($parameters)) {
         $route['parameters'] = $parameters;
     }
     if ($route['mergeQuery']) {
         $query = [];
         if (isset($this->request)) {
             $query = $this->request->getQueryParams();
         }
         if (isset($route['query'])) {
             $query = merge_array($query, $route['query']);
         }
         $route['query'] = $query;
     }
     unset($route['mergeQuery']);
     if (isset($scheme)) {
         return $scheme->fromArray($route);
     }
     if (!isset($this->route)) {
         throw new Route\RouteException('Unknown route scheme');
     }
     $copy = $this->route;
     if (isset($route['parameters'])) {
         $copy = $copy->withParameters($route['parameters']);
     }
     if (isset($route['query'])) {
         $copy = $copy->withQuery($route['query']);
     }
     if (isset($route['fragment'])) {
         $copy = $copy->withFragment($route['fragment']);
     }
     return $copy;
 }
Ejemplo n.º 15
0
 /**
  * Set association.
  *
  * @param ActiveRecord $record
  *            A record.
  * @param array $association
  *            Association options.
  * @param ActiveRecord|Selection|ActiveRecord[] $value
  *            New value.
  * @throws InvalidAssociationException If association type unknown.
  */
 public function setAssociation(ActiveRecord $record, $association, $value)
 {
     switch ($association['type']) {
         case 'belongsTo':
             if (!isset($value)) {
                 $this->unsetAssociation($record, $association);
                 return;
             }
             Assume::that($value instanceof ActiveRecord);
             Assume::that($value->getModel() == $association['model']);
             $key = $association['otherKey'];
             $otherId = $association['model']->primaryKey;
             $record->{$key} = $value->{$otherId};
             return;
         case 'hasOne':
             Assume::that($value instanceof ActiveRecord);
             Assume::that($value->getModel() == $association['model']);
             $this->unsetAssociation($record, $association);
             $key = $association['thisKey'];
             $id = $this->primaryKey;
             $value->{$key} = $record->{$id};
             $value->save();
             return;
         case 'hasMany':
             $key = $association['thisKey'];
             $id = $this->primaryKey;
             $idValue = $record->{$id};
             if ($value instanceof Selection) {
                 $value->set($key, $idValue)->update();
                 return;
             }
             if (!is_array($value)) {
                 $value = array($value);
             }
             $this->unsetAssociation($record, $association);
             foreach ($value as $item) {
                 Assume::that($item instanceof ActiveRecord);
                 Assume::that($item->getModel() == $association['model']);
                 $item->{$key} = $idValue;
                 if (!$item->isNew()) {
                     $item->save();
                 }
             }
             return;
         case 'hasAndBelongsToMany':
             return;
     }
     throw new InvalidAssociationException('Unknown association type: ' . $association['type']);
 }