/**
* find elements
*
* @param Charcoal_String|string $selector
* @param Charcoal_Integer|integer $index
*/
public function find($selector, $index = NULL)
{
Charcoal_ParamTrait::validateString(1, $selector);
Charcoal_ParamTrait::validateInteger(2, $index, TRUE);
if (!$this->simple_html_dom) {
_throw(new SimpleHtmlDomComponentException("SimpleHtmlDom object is not created"));
}
$selector = us($selector);
log_debug("debug", "index:{$index}");
if ($index !== NULL) {
// returns single element
$index = ui($index);
log_debug("debug", "returns single element");
$result = $this->simple_html_dom->find($selector, $index);
log_debug("debug", "result: " . print_r($result, true));
return $result ? new Charcoal_SimpleHtmlDomElement($result) : NULL;
}
// returns all elements
log_debug("debug", "selector:" . print_r($selector, true));
$result = $this->simple_html_dom->find($selector);
log_debug("debug", "result: " . print_r($result, true));
$elements = array();
foreach ($result as $e) {
$elements[] = new Charcoal_SimpleHtmlDomElement($e);
}
return $result ? $elements : array();
}
public static function splitParams($args)
{
Charcoal_ParamTrait::validateString(1, $args);
$args = us($args);
$pos = 0;
$dq = FALSE;
$sq = FALSE;
$max_pos = strlen($args);
$args_array = array();
$arg_tmp = '';
$escape = FALSE;
while ($pos < $max_pos) {
$ch = substr($args, $pos, 1);
$escape_now = FALSE;
if ($escape) {
$arg_tmp .= $ch;
} elseif ($dq) {
if ($ch == '\\') {
$escape = TRUE;
$escape_now = TRUE;
} elseif ($ch == '"') {
$dq = FALSE;
} else {
$arg_tmp .= $ch;
}
} elseif ($sq) {
if ($ch == '\\') {
$escape = TRUE;
$escape_now = TRUE;
} elseif ($ch == "'") {
$sq = FALSE;
} else {
$arg_tmp .= $ch;
}
} else {
if ($ch == ' ') {
$args_array[] = $arg_tmp;
$arg_tmp = '';
} elseif ($ch == '\\') {
$escape = TRUE;
$escape_now = TRUE;
} elseif ($ch == '"') {
$dq = TRUE;
} elseif ($ch == "'") {
$sq = TRUE;
} else {
$arg_tmp .= $ch;
}
}
if (!$escape_now && $escape) {
$escape = FALSE;
}
$pos++;
}
if (strlen($arg_tmp) > 0) {
$args_array[] = $arg_tmp;
}
return $args_array;
}
/**
* render buffer
*
* @param Charcoal_String|string $buffer rendering data
*/
public function render($buffer)
{
Charcoal_ParamTrait::validateString(1, $buffer);
$buffer = us($buffer);
if (is_string($buffer)) {
echo $buffer;
}
}
public function __construct($component_name, $entry, $message = NULL, $prev = NULL)
{
Charcoal_ParamTrait::validateString(1, $component_name);
Charcoal_ParamTrait::validateString(2, $entry);
Charcoal_ParamTrait::validateString(3, $message);
Charcoal_ParamTrait::validateException(4, $prev, TRUE);
parent::__construct("component({$component_name}) config maybe wrong: [entry]{$entry} [message]{$message}", $prev);
}
/**
* Construct
*/
public function __construct($message, $prev = NULL)
{
Charcoal_ParamTrait::validateString(1, $message);
Charcoal_ParamTrait::validateException(2, $prev, TRUE);
parent::__construct(us($message), 0, $prev);
$this->backtrace = debug_backtrace();
$this->previous = $prev;
}
public function __construct($name, $value, $params)
{
Charcoal_ParamTrait::validateString(1, $name);
Charcoal_ParamTrait::validateString(2, $value);
Charcoal_ParamTrait::validateVector(3, $params);
$this->name = us($name);
$this->value = us($value);
$this->params = uv($params);
}
public function __construct($argument, $option_name, $prev = NULL)
{
Charcoal_ParamTrait::validateString(1, $argument);
Charcoal_ParamTrait::validateString(2, $option_name);
Charcoal_ParamTrait::validateException(3, $prev, TRUE);
$this->argument = $argument;
$this->option_name = $option_name;
parent::__construct("Invalid argument for -{$option_name}: {$argument}", $prev);
}
/**
* indicates FROM clause and switches to from context
*
* @param Charcoal_String $model_name model name for table
* @param Charcoal_String $alias alias name for table
*
* @return Charcoal_FromContext from context
*/
public function from($model_name, $alias = NULL)
{
Charcoal_ParamTrait::validateString(1, $model_name);
Charcoal_ParamTrait::validateString(2, $alias, TRUE);
$query_target = new Charcoal_QueryTarget($model_name);
if ($alias) {
$query_target->setAlias($alias);
}
$this->getContext()->setQueryTarget($query_target);
return new Charcoal_FromContext($this->getContext());
}
public function __construct($path, $parent = NULL)
{
Charcoal_ParamTrait::validateString(1, $path);
Charcoal_ParamTrait::validateIsA(2, 'Charcoal_File', $parent, TRUE);
parent::__construct($path, $parent);
if (!is_readable(parent::getPath())) {
_throw(new Charcoal_FileNotFoundException($this));
}
$this->_data = getimagesize(parent::getPath());
if ($this->_data === FALSE) {
_throw(new Charcoal_ImageGetSizeException($this));
}
}
/**
* Constructor
*/
public function __construct($page_info, $where = NULL, $params = NULL, $order_by = NULL, $group_by = NULL)
{
Charcoal_ParamTrait::validateIsA(1, 'Charcoal_DBPageInfo', $page_info);
Charcoal_ParamTrait::validateString(2, $where, TRUE);
Charcoal_ParamTrait::validateVector(2, $params, TRUE);
Charcoal_ParamTrait::validateString(3, $order_by, TRUE);
Charcoal_ParamTrait::validateString(4, $group_by, TRUE);
$this->page_info = $page_info;
$page = $page_info->getPage();
$page_size = $page_info->getPageSize();
$page = ui($page);
$page_size = ui($page_size);
$limit = $page_size;
$offset = ($page - 1) * $page_size;
parent::__construct($where, $params, $order_by, $limit, $offset, $group_by);
}
/**
* find elements
*
* @param Charcoal_String|string $selector
* @param Charcoal_Integer|integer $index
*/
public function find($selector, $index = NULL)
{
Charcoal_ParamTrait::validateString(1, $selector);
Charcoal_ParamTrait::validateInteger(2, $index, TRUE);
$selector = us($selector);
if ($index !== NULL) {
// returns single element
$index = ui($index);
$result = $this->element->find($selector, $index);
return $result ? new Charcoal_SimpleHtmlDomElement($result) : NULL;
}
// returns all elements
$result = $this->element->find($selector);
$elements = array();
foreach ($result as $e) {
$elements[] = new Charcoal_SimpleHtmlDomElement($e);
}
return $result ? $elements : array();
}
/**
* render buffer
*
* @param Charcoal_String|string $buffer rendering data
*/
public function render($buffer)
{
Charcoal_ParamTrait::validateString(1, $buffer);
$buffer = us($buffer);
if (is_string($buffer)) {
$dir = new Charcoal_File(dirname($this->file_path));
if (!$dir->exists()) {
$dir->makeDirectory($this->dir_mode);
}
if (!$dir->isWriteable()) {
_throw(new Charcoal_RenderTargetException("directory not writable: {$dir}"));
}
$result = @file_put_contents($this->file_path, $buffer, LOCK_EX);
if ($result === FALSE) {
$last_error = print_r(error_get_last(), true);
_throw(new Charcoal_RenderTargetException("file_put_contents failed: {$this->file_path} last error: {$last_error}"));
}
}
}
public function createFile($file_path, $contents, $overwrite = TRUE, $mode = 0777)
{
Charcoal_ParamTrait::validateString(1, $file_path);
Charcoal_ParamTrait::validateString(2, $contents);
Charcoal_ParamTrait::validateBoolean(3, $overwrite);
Charcoal_ParamTrait::validateInteger(4, $mode);
$obj = new Charcoal_File($file_path, $this->_base_dir_obj);
if ($overwrite) {
if ($obj->exists() && !$obj->canWrite()) {
_throw(new Charcoal_FileSystemComponentException('specified file is not writeable.'));
}
} elseif ($obj->exists()) {
_throw(new Charcoal_FileSystemComponentException('specified file is already exists.'));
}
try {
// create file with parent directory
$obj->makeFile($mode, $contents, TRUE);
return $obj;
} catch (Exception $e) {
_catch($e);
_throw(new Charcoal_FileSystemComponentException(s('creating file failed.'), $e));
}
}
/**
* generate feed and output to the buffer
*
* @param Charcoal_String|string $format format name of the feed
*/
public function outputFeed($format = self::DEFAULT_FORMAT)
{
Charcoal_ParamTrait::validateString(1, $format);
echo 'outputFeed' . PHP_EOL;
$this->creator->outputFeed(us($format));
}
/**
* Prepare for statement and execute query
*
* @param string|Charcoal_String $sql SQL statement(placeholders can be included)
* @param array|Charcoal_HashMap $params Parameter values for prepared statement
* @param array|Charcoal_HashMap $driver_options Driver options
*
* @return PDOStatement
*/
private function _prepareExecute($sql, $params, $driver_options)
{
Charcoal_ParamTrait::validateString(1, $sql);
Charcoal_ParamTrait::validateHashMap(2, $params, TRUE);
Charcoal_ParamTrait::validateHashMap(3, $driver_options, TRUE);
$params = um($params);
$driver_options = um($driver_options);
$params = $params ? $params : array();
$driver_options = $driver_options ? $driver_options : array();
$timer_handle = Charcoal_Benchmark::start();
$command_id = $this->command_id++;
$params_disp = $params ? implode(',', $params) : '';
log_debug('data_source,sql,debug', "[ID]{$command_id} [SQL]{$sql}", self::TAG);
log_debug('data_source,sql,debug', "[ID]{$command_id} [params]{$params_disp}", self::TAG);
/** @var PDOStatement $stmt */
$stmt = $this->getConnection()->prepare($sql, $driver_options);
$this->sql_histories->push(new Charcoal_SQLHistory($sql, $params));
$success = $stmt->execute($params);
if (!$success) {
list($sqlstate, $err_code, $err_msg) = $stmt->errorInfo();
$msg = "PDO#execute failed. [ID]{$command_id} [SQL]{$sql} [params]{$params_disp} [SQLSTATE]{$sqlstate} [ERR_CODE]{$err_code} [ERR_MSG]{$err_msg}";
log_error('data_source,sql,debug', "...FAILED: {$msg}", self::TAG);
_throw(new Charcoal_DBDataSourceException($msg));
}
$this->num_rows = $rows = $stmt->rowCount();
log_info('data_source,sql,debug', "[ID]{$command_id} ...success(numRows={$rows})", self::TAG);
// ログ
$elapse = Charcoal_Benchmark::stop($timer_handle);
log_debug('data_source,sql,debug', "[ID]{$command_id} _prepareExecute() end. time=[{$elapse}]msec.", self::TAG);
// SQL benchmark
ini_set('serialize_precision', 16);
log_debug('sql_bench', var_export(array($sql, $rows, $elapse), true), self::TAG);
return $stmt;
}
public function __construct($url)
{
Charcoal_ParamTrait::validateString(1, $url);
parent::__construct(p(array()));
$this->url = $url;
}
public function getDefaultValue($field)
{
Charcoal_ParamTrait::validateString(1, $field);
$field = s($field);
$annot = $this->getAnnotationValue($field, s('default'));
if (!$annot) {
return NULL;
}
$value = $annot->getValue();
if (!$value) {
return NULL;
}
$value = us($value);
return $value == 'NULL' ? NULL : $value;
}
/**
* [Fluent Interface] create fluent interface
*
* @param string $fields field list(comma separated string) for SELECT clause
*
* @return Charcoal_SelectContext select context
*/
public function select($fields)
{
Charcoal_ParamTrait::validateString(1, $fields);
$context = new Charcoal_QueryContext($this);
if (!empty($fields)) {
$context->setFields($fields);
}
return new Charcoal_SelectContext($context);
}
/**
* parse XML
*
* @param Charcoal_String|string $data Chunk of data to parse
* @param Charcoal_Boolean|bool $is_final If set and TRUE, data is the last piece of data sent in this parse.
*
* @return bool Returns 1 on success or 0 on failure.
*/
public function parse($data, $is_final = false)
{
Charcoal_ParamTrait::validateString(1, $data);
Charcoal_ParamTrait::validateBoolean(2, $is_final);
if (!$this->parser) {
_throw(new PhpXmlParserComponentException('parser object is not created'));
}
return xml_parse($this->parser, us($data), ub($is_final));
}
/**
* Set temporary file mode
*
* @param string|Charcoal_String $mode file mode
*/
public function setMode($mode)
{
Charcoal_ParamTrait::validateString(1, $mode);
$this->mode = us($mode);
}
/**
* real implementation of Charcoal_SmartGateway::updateAll()
*
* @param Charcoal_QueryTarget $query_target description about target model, alias, or joins
* @param Charcoal_SQLCriteria $criteria criteria object
* @param Charcoal_HashMap|array $data associative array or HashMap object to update
* @param Charcoal_String|string $comment comment text
*
* @return integer count of affected rows
*/
public function updateAll($comment, $query_target, $criteria, $data)
{
Charcoal_ParamTrait::validateString(1, $comment, TRUE);
Charcoal_ParamTrait::validateIsA(2, 'Charcoal_QueryTarget', $query_target);
Charcoal_ParamTrait::validateIsA(3, 'Charcoal_SQLCriteria', $criteria);
Charcoal_ParamTrait::validateHashMap(4, $data);
$model = $this->getModel($query_target->getModelName());
$alias = $query_target->getAlias();
$dto = $model->createDTO(um($data));
list($sql, $params) = $this->sql_builder->buildUpdateSQL($model, $alias, $dto, $criteria);
$sql = !empty($comment) ? $this->sql_builder->prependComment($sql, $comment) : $sql;
// log_debug( "debug,smart_gateway,sql", "sql:$sql", self::TAG );
// log_debug( "debug,smart_gateway,sql", "params:" . print_r($params,true), self::TAG );
// SQL実行
$this->data_source->prepareExecute($sql, $params);
return $this->data_source->numRows();
}
/**
* Generate RDBMS-specific SQL for TABLE EXISTS
*
* @param string $database table schema
* @param Charcoal_ITableModel $model table model object related with th query
*
* @return string SQL
*/
public function buildExistsTableSQL($database, $model)
{
Charcoal_ParamTrait::validateString(1, $database);
Charcoal_ParamTrait::validateIsA(2, 'Charcoal_ITableModel', $model);
try {
$table_name = $model->getTableName();
$sql = "SELECT count(*) FROM information_schema.columns WHERE TABLE_NAME = '{$table_name}'";
$sql .= " AND TABLE_SCHEMA = '{$database}'";
log_debug("debug,sql,smart_gateway", "buildExistsTableSQL result: {$sql}", self::TAG);
return $sql;
} catch (Exception $e) {
_throw(new Charcoal_SQLBuilderException("MySQL_SQLBuilder#buildCreateTableSQL failed"));
}
return '';
}
public function validate($sequence, $form_token, $throws = TRUE)
{
Charcoal_ParamTrait::validateIsA(1, 'Charcoal_ISequence', $sequence);
Charcoal_ParamTrait::validateString(2, $form_token);
Charcoal_ParamTrait::validateBoolean(3, $throws);
$throws = ub($throws);
log_debug("debug", "sequence: " . print_r($sequence, true));
log_debug("debug", "form_token: " . print_r($form_token, true));
if ($this->getSandbox()->isDebug() && $this->debug_mode) {
ad($sequence, array('title' => "sequence"));
}
$token_key = $this->token_key;
log_debug("debug", "token_key: " . print_r($token_key, true));
if ($this->getSandbox()->isDebug() && $this->debug_mode) {
ad($token_key, array('title' => "token_key", "type" => "div"));
}
// get token container from session.
$token_list = $sequence->get(s($token_key));
if ($this->getSandbox()->isDebug() && $this->debug_mode) {
ad($token_list, array('title' => "token list"));
}
log_debug("debug", "token_list: " . print_r($token_list, true));
if ($token_list === NULL || !is_array($token_list)) {
$token_list = array();
}
// find token from token list.
$token_index = NULL;
foreach ($token_list as $idx => $token) {
log_info("debug", "token: {$token}");
if ($this->getSandbox()->isDebug() && $this->debug_mode) {
ad($token, array('title' => "token", "type" => "div"));
}
if ($token == $form_token) {
$token_index = $idx;
break;
}
}
if ($token_index === NULL) {
// illegal access
log_warning("system, debug", "token not found: {$form_token}");
if ($this->getSandbox()->isDebug() && $this->debug_mode) {
ad($form_token, array('title' => "token not found", "type" => "div"));
}
if ($throws) {
_throw(new Charcoal_FormTokenValidationException('token not found in sequence:' . $form_token), FALSE);
}
return FALSE;
} else {
// authorized access
log_debug("debug", "token accepted: {$form_token}");
if ($this->getSandbox()->isDebug() && $this->debug_mode) {
ad($form_token, array('title' => "token accepted", "type" => "div"));
}
// erase token from token list to prevent duplicate form submission.
unset($token_list[$token_index]);
}
// update token list in sequence.
$sequence->set($token_key, $token_list);
// the event was successfully processed.
return TRUE;
}
public function execute($sql)
{
Charcoal_ParamTrait::validateString(1, $sql);
// 接続処理
$this->connect();
// SQLを実行
$sqliteerror = '';
$result = $this->sqlite_exec($sql, SQLITE_BOTH, $sqliteerror);
if ($result === FALSE) {
_throw(new Charcoal_DBDataSourceException(__METHOD__ . " Failed. SQLite error: {$sqliteerror}"));
}
}
/**
* Set fields
*/
public function setFields($fields)
{
Charcoal_ParamTrait::validateString(1, $fields);
$this->_fields = $fields;
}
/**
* repair HTML from file
*
* @param Charcoal_String|string $input HTML text to parse
*
* @return string Returns the repaired string.
*/
public function repairFile($file, $use_include_path = FALSE)
{
Charcoal_ParamTrait::validateString(1, $file);
return $this->tidy->repairFile(us($file), $this->config, $this->encoding, $use_include_path);
}
public function __construct($expression)
{
Charcoal_ParamTrait::validateString(1, $expression);
$expression = us($expression);
parent::__construct();
$tokens = $this->tokenize($expression);
if (count($tokens) < 1) {
_throw(new Charcoal_QueryTargetException("no query target element is not specified."));
}
$state = NULL;
$element_list = NULL;
foreach ($tokens as $token) {
if (strlen($token) === 0) {
continue;
}
if ($state === NULL) {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_MODEL), s($token));
$state = "model set";
} elseif (in_array($state, array("model set", "join set")) && $token == 'as') {
$state = "as";
} elseif ($state == "as") {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_AS_NAME), s($token));
$state = "as set";
} elseif ($state == "model set" || $state == "as set" || $state == "join set" || $state == "on set") {
if ($token == 'on') {
$state = "on";
} elseif ($token == '+') {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_INNER_JOIN));
$state = "join";
} elseif ($token == '(+') {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_LEFT_JOIN));
$state = "join";
} elseif ($token == '+)') {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_RIGHT_JOIN));
$state = "join";
} elseif ($state == "on set") {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_ON_CONDITION), s($token));
}
} elseif ($state == "join") {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_MODEL), s($token));
$state = "join set";
} elseif ($state == "on") {
$element_list[] = new Charcoal_QueryTargetElement(i(Charcoal_EnumQueryTargetType::TARGET_ON_CONDITION), s($token));
$state = "on set";
}
}
// log_debug( "debug, smart_gateway", "element_list: " . print_r($element_list,true) );
$main_model = NULL;
$alias = NULL;
$state = "main model";
$join_stack = new Charcoal_Stack();
foreach ($element_list as $element) {
if ($state === "main model") {
switch ($element->getType()) {
case Charcoal_EnumQueryTargetType::TARGET_MODEL:
$main_model = $element->getString();
break;
case Charcoal_EnumQueryTargetType::TARGET_AS_NAME:
$alias = $element->getString();
break;
case Charcoal_EnumQueryTargetType::TARGET_INNER_JOIN:
$join_stack->push(new Charcoal_QueryJoin(i(Charcoal_EnumSQLJoinType::INNER_JOIN)));
$state = "joins";
break;
case Charcoal_EnumQueryTargetType::TARGET_LEFT_JOIN:
$join_stack->push(new Charcoal_QueryJoin(i(Charcoal_EnumSQLJoinType::LEFT_JOIN)));
$state = "joins";
break;
case Charcoal_EnumQueryTargetType::TARGET_RIGHT_JOIN:
$join_stack->push(new Charcoal_QueryJoin(i(Charcoal_EnumSQLJoinType::RIGHT_JOIN)));
$state = "joins";
break;
}
} elseif ($state === "joins") {
$join = $join_stack->pop();
switch ($element->getType()) {
case Charcoal_EnumQueryTargetType::TARGET_MODEL:
$join->setModelName(s($element->getString()));
break;
case Charcoal_EnumQueryTargetType::TARGET_AS_NAME:
$join->setAlias(s($element->getString()));
break;
case Charcoal_EnumQueryTargetType::TARGET_ON_CONDITION:
$join_cond = $join->getCondition();
$join->setCondition(s($join_cond . $element->getString()));
break;
case Charcoal_EnumQueryTargetType::TARGET_INNER_JOIN:
$join_stack->push($join);
$join = new Charcoal_QueryJoin(i(Charcoal_EnumSQLJoinType::INNER_JOIN));
break;
case Charcoal_EnumQueryTargetType::TARGET_LEFT_JOIN:
$join_stack->push($join);
$join = new Charcoal_QueryJoin(i(Charcoal_EnumSQLJoinType::LEFT_JOIN));
break;
case Charcoal_EnumQueryTargetType::TARGET_RIGHT_JOIN:
$join_stack->push($join);
$join = new Charcoal_QueryJoin(i(Charcoal_EnumSQLJoinType::RIGHT_JOIN));
break;
}
$join_stack->push($join);
}
}
$joins = $join_stack->toArray();
// log_debug( "debug, smart_gateway", "joins: " . print_r($joins,true) );
$this->model_name = $main_model;
$this->alias = $alias;
$this->joins = $joins;
// log_debug( "debug, smart_gateway", "query_target_list: " . print_r($this,true) );
}
/**
* Generate RDBMS-specific SQL for DELETE
*
* @param Charcoal_ITableModel $model table model object related with th query
* @param string $alias table model alias which is specified by $model
* @param Charcoal_SQLCriteria $criteria criteria which should be used in WHERE clause
*
* @return string SQL
*/
public function buildDeleteSQL($model, $alias, $criteria)
{
Charcoal_ParamTrait::validateIsA(1, 'Charcoal_ITableModel', $model);
Charcoal_ParamTrait::validateString(2, $alias, TRUE);
Charcoal_ParamTrait::validateIsA(3, 'Charcoal_SQLCriteria', $criteria);
$table_name = $model->getTableName();
$sql = "DELETE FROM " . us($table_name);
if (!$criteria) {
return $sql;
}
$where_clause = $criteria->getWhere();
$order_by = $criteria->getOrderBy();
$limit = $criteria->getLimit();
$group_by = $criteria->getGroupBy();
if (!empty($where_clause)) {
$sql .= ' WHERE ' . $where_clause;
}
if (!empty($group_by)) {
$sql .= ' GROUP BY ' . $group_by;
}
if (!empty($order_by)) {
$sql .= ' ORDER BY ' . $order_by;
}
if (!empty($limit)) {
$sql .= ' LIMIT ' . $limit;
}
return $sql;
}
/**
* set author
*
* @param Charcoal_String|string $author
*/
public function setAuthor($author)
{
Charcoal_ParamTrait::validateString(1, $author, TRUE);
$this->item->author = us($author);
return $this;
}
/**
* Get framework/project/application file
*
* @param Charcoal_IEnvironment $env framework's environment variables
* @param string $virtual_path virtual path to retrieve, including macro key like '%BASE_DIR%', '%WEBAPP_DIR%', etc.
* @param string $filename file name
*
* @return Charcoal_File file object
*/
public static function getFile($env, $virtual_path, $filename = NULL)
{
Charcoal_ParamTrait::validateIsA(1, 'Charcoal_IEnvironment', $env);
Charcoal_ParamTrait::validateString(2, $virtual_path);
Charcoal_ParamTrait::validateString(3, $filename, TRUE);
return new Charcoal_File(self::getPath($env, $virtual_path, $filename));
}
