Exemplo n.º 1
0
 /**
  * Assign default forein_model to singular association name
  * @param  Jam_Meta $meta
  * @param  string   $name
  */
 public function initialize(Jam_Meta $meta, $name)
 {
     if (!$this->foreign_model) {
         $this->foreign_model = Inflector::singular($name);
     }
     parent::initialize($meta, $name);
 }
Exemplo n.º 2
0
 public function before()
 {
     parent::before();
     // Save the old action so it can be brought back on after
     $this->_action = $this->request->action;
     // Set the current action
     $current_action = $this->request->action;
     $id = $this->request->param('id', NULL);
     // Let's guess the action based on the params
     if (!in_array($this->request->action, array('edit', 'add', 'delete')) and (!is_null($id) or !empty($id))) {
         $current_action = 'read';
     }
     if (!method_exists($this, 'action_' . $this->request->action)) {
         $model = Jelly::select(Inflector::singular($this->request->controller));
         foreach ($model->get_state() as $key => $value) {
             $param = $this->request->param($key, NULL);
             if (!is_null($param)) {
                 $model->set_state($key, $param);
             }
         }
         $this->request->response = Kostache::factory($this->request->controller . '/' . $current_action)->set_model($model);
         // Since the magic has been executed, just execute an empty action
         $this->request->action = 'default';
     }
 }
Exemplo n.º 3
0
Arquivo: arr.php Projeto: netbiel/core
 /**
  * Convert an array to XML string
  *
  * @static
  * @param   array   $array
  * @param   string  $root
  * @param   SimpleXMLElement  $xml
  * @return  string
  */
 public static function xml(array $array, $root = 'data', SimpleXMLElement &$xml = null)
 {
     // Initialize
     if (is_null($xml)) {
         $xml = simplexml_load_string('<?xml version="1.0" encoding="' . Kohana::$charset . '"?><' . $root . ' />');
     }
     foreach ($array as $key => $value) {
         // No numeric keys in our xml please!
         $numeric = false;
         if (is_numeric($key)) {
             $numeric = true;
             $key = Inflector::singular($root);
         }
         // Valid XML name
         $key = preg_replace('/[^a-z0-9\\-\\_\\.\\:]/i', '', $key);
         // Recursive call required for array values
         if (is_array($value)) {
             $node = true || Arr::is_assoc($value) || $numeric ? $xml->addChild($key) : $xml;
             self::xml($value, $key, $node);
         } else {
             $xml->addChild($key, htmlspecialchars($value));
         }
     }
     return $xml->asXML();
 }
Exemplo n.º 4
0
 /**
  * Get field validation messages
  * 
  * @return string
  */
 public function get_error()
 {
     $errors = $this->_get_view_var('errors');
     if ($errors) {
         if ($this->_field instanceof Jelly_Field_ManyToMany) {
             if (array_key_exists(Inflector::singular($this->_field->name), $errors)) {
                 return $errors[Inflector::singular($this->_field->name)];
                 //extra validation from controller
             } elseif (isset($errors['_external'])) {
                 if (array_key_exists(Inflector::singular($this->_field->name), $errors['_external'])) {
                     return $errors['_external'][Inflector::singular($this->_field->name)];
                 }
             }
         } else {
             if (array_key_exists($this->_field->name, $errors)) {
                 return $errors[$this->_field->name];
                 //extra validation from controller
             } elseif (isset($errors['_external'])) {
                 if (array_key_exists($this->_field->name, $errors['_external'])) {
                     return $errors['_external'][$this->_field->name];
                 }
             }
         }
     }
 }
Exemplo n.º 5
0
 /**
  * Constructs a new CDM model
  *
  * @param  key  record key to load
  */
 public function __construct($key = NULL)
 {
     if (!CDM::$_connected) {
         foreach (Kohana::config('cdm')->connection['hosts'] as $host) {
             // Connect to cassandra nodes
             CassandraConn::add_node($host['hostname'], $host['port']);
         }
         CDM::$_connected = TRUE;
     }
     if (!isset($this->_keyspace)) {
         // Find the application keyspace if not already set
         $this->_keyspace = Kohana::config('cdm')->keyspace;
     }
     if (!isset($this->_column_family)) {
         // Use singular version of model name for the column family
         $this->_column_family = Inflector::singular(strtolower(substr(get_class($this), 10)));
     }
     if (!isset(CDM::$_managers[$this->_keyspace][$this->_column_family])) {
         // Create column manager
         CDM::$_managers[$this->_keyspace][$this->_column_family] = new CassandraCF($this->_keyspace, $this->_column_family, $this->_is_super);
     }
     $this->_manager = CDM::$_managers[$this->_keyspace][$this->_column_family];
     if ($key !== NULL) {
         // Load initial record
         $this->find($key);
     }
 }
Exemplo n.º 6
0
 /**
  * Initialize object (for relations)
  * @param orm $object 
  */
 public function initialize(&$object)
 {
     $models[0] = Inflector::plural(strtolower(str_replace('Model_', '', get_class($object))));
     $models[1] = $this->item['name'];
     sort($models);
     $object->create_relation('hasMany', $this->item['name'], array('model' => Inflector::singular($this->item['name']), 'through' => $models[0] . '_' . $models[1]));
 }
Exemplo n.º 7
0
 public function config($group, $type, $model_name = NULL)
 {
     $model_name = $model_name ? $model_name : $this->model_name;
     $config = self::$_config === NULL ? self::$_config = Kohana::$config->load('huia/api') : self::$_config;
     $custom = $config->get('custom_' . $group);
     $regexp = Arr::path($custom, strtolower(Inflector::singular($model_name)) . '.' . $type);
     return $regexp !== NULL ? $regexp : Arr::get($config->get($group), $type);
 }
Exemplo n.º 8
0
 public function title()
 {
     $name = str_replace('Controller_Tart_', '', get_class($this));
     $name = ucwords(Inflector::humanize($name));
     if ($this->request->param('id')) {
         return ucwords(Inflector::singular($name)) . ' - ' . Inflector::humanize($this->request->action());
     } else {
         return $name . ' - ' . Inflector::humanize($this->request->action());
     }
 }
Exemplo n.º 9
0
Arquivo: crud.php Projeto: raku/MorCMS
 /**
  * Prepare controller and model for crud actions
  */
 public function before()
 {
     parent::before();
     $this->controller_name = $this->request->controller();
     if ($this->model == null) {
         $this->model = $this->request->controller();
     }
     if (is_string($this->model)) {
         $this->model = ORM::factory(Inflector::singular($this->model));
     }
 }
Exemplo n.º 10
0
 /**
  * Add a validator item
  *
  * @access public
  * @param mixed $type
  * @param mixed $rule
  * @return object
  */
 public function add_validator($type, $rule)
 {
     $type = Inflector::plural($rule->type);
     if (in_array($type, array('filters', 'display_filters'))) {
         return $this->add_filter(Inflector::singular($type), $rule);
     }
     $next = count($this->_validators[$type]);
     // Resolve the context
     $this->make_context($rule);
     $this->_validators[$type][$next] = $rule;
     return $this;
 }
Exemplo n.º 11
0
 /**
  * Try to load Flatfile Model, based on url segment
  * Throw 404 error page if markdown file cant found
  **/
 public function __construct()
 {
     try {
         $model_name = Inflector::singular(strtolower(Request::current()->controller()));
         $model = 'Model_' . ucfirst($model_name);
         /**
          * Assign model to a variable named as the controller name
          **/
         $this->{$model_name} = new $model(Request::initial()->param('slug'));
     } catch (Kohana_Exception $e) {
         if ($slug = Request::initial()->param('slug')) {
             throw HTTP_Exception::factory(404, __("Unable to find page :slug"), array(':slug' => $slug));
         }
         throw HTTP_Exception::factory(404, __("Unable to find URI :uri"), array(':uri' => Request::initial()->uri()));
     }
 }
Exemplo n.º 12
0
 /**
  * Input for edit item
  * @return string Form::input
  */
 public function input_edit($value)
 {
     if (is_object($value)) {
         $id = $value->id;
     } else {
         $id = $value;
         $value = ORM::factory(Inflector::singular($this->item['name']), $id);
     }
     $field = isset($this->item['field']) ? $this->item['field'] : 'name';
     $values_model = $value->clear()->find_all()->as_array($field);
     $values = array();
     foreach ($values_model as $value) {
         $values[$value->id] = $value->{$field};
     }
     if (!$this->item['notnull']) {
         Arr::unshift($values, 0, '');
     }
     return Form::select($this->item['name'], $values, $id);
 }
Exemplo n.º 13
0
Arquivo: date.php Projeto: anqh/core
 /**
  * Returns age in human readable format with only the largest span
  *
  * @param		int|string	$time1
  * @param		int|string	$time2
  * @param		string			$output
  * @return	string
  */
 public static function age($time1, $time2 = null)
 {
     if (!is_numeric($time1)) {
         $time1 = strtotime($time1);
     }
     if (!is_null($time2) && !is_int($time2)) {
         $time2 = strtotime($time2);
     }
     if ($difference = Date::span($time1, $time2) and is_array($difference)) {
         foreach ($difference as $span => $amount) {
             if ($amount > 0) {
                 return $amount . ' ' . __(Inflector::singular($span, $amount));
             }
         }
     }
     if (empty($difference)) {
         return '0 ' . __('seconds');
     }
     return __('some time');
 }
Exemplo n.º 14
0
 /**
  * Count the number of records in the table.
  * @param bool $reset Pass FALSE to avoid resetting on the next call
  * @return int
  */
 public function count_all($reset = true)
 {
     $is_distinct = false;
     $selects = [];
     foreach ($this->_db_pending as $key => $method) {
         if ($method['name'] == 'distinct') {
             $is_distinct = true;
             // Ignore any selected columns for now
             $selects[] = $method;
             unset($this->_db_pending[$key]);
         }
         if ($method['name'] == 'select') {
             // Ignore any selected columns for now
             $selects[] = $method;
             unset($this->_db_pending[$key]);
         }
     }
     if (!empty($this->_load_with)) {
         foreach ($this->_load_with as $alias) {
             // Bind relationship
             $this->with($alias);
         }
     }
     $this->_build(Database::SELECT);
     $records = $this->_db_builder->from([$this->_table_name, $this->_object_name]);
     if ($is_distinct) {
         $records->select([DB::expr('COUNT(DISTINCT(`' . Inflector::singular($this->_table_name) . '`.`' . $this->_primary_key . '`))'), 'records_found']);
     } else {
         $records->select([DB::expr('COUNT(*)'), 'records_found']);
     }
     $records = $records->execute($this->_db)->get('records_found');
     // Add back in selected columns
     $this->_db_pending += $selects;
     $this->reset($reset);
     // Return the total number of records in a table
     return $records;
 }
Exemplo n.º 15
0
 /**
  * Initialize the fields and add validation rules based on field properties.
  *
  * @return  void
  */
 protected function __construct()
 {
     if ($this->_init) {
         if ($this->state() === 'loading') {
             // Object loading via mysql_fetch_object or similar has finished
             $this->state('loaded');
         }
         // Can only be called once
         return;
     }
     // Initialization has been started
     $this->_init = TRUE;
     // Set up the fields
     $this->_init();
     if (!$this->_model) {
         // Set the model name based on the class name
         $this->_model = strtolower(substr(get_class($this), 6));
     }
     if (!$this->_table) {
         // Set the table name to the plural model name
         $this->_table = inflector::plural($this->_model);
     }
     foreach ($this->_fields as $name => $field) {
         if ($field->primary === TRUE) {
             if (!$this->_primary_key) {
                 // This is the primary key
                 $this->_primary_key = $name;
             } else {
                 if (is_string($this->_primary_key)) {
                     // More than one primary key found, create a list of keys
                     $this->_primary_key = array($this->_primary_key);
                 }
                 // Add this key to the list
                 $this->_primary_key[] = $name;
             }
         }
     }
     foreach ($this->_fields as $name => $field) {
         if ($field instanceof Sprig_Field_ForeignKey and !$field->model) {
             if ($field instanceof Sprig_Field_HasMany) {
                 $field->model = Inflector::singular($name);
             } else {
                 $field->model = $name;
             }
         }
         if ($field instanceof Sprig_Field_ManyToMany) {
             if (!$field->through) {
                 // Get the model names for the relation pair
                 $pair = array(strtolower($this->_model), strtolower($field->model));
                 // Sort the model names alphabetically
                 sort($pair);
                 // Join the model names to get the relation name
                 $pair = implode('_', $pair);
                 if (!isset(Sprig::$_relations[$pair])) {
                     // Must set the pair key before loading the related model
                     // or we will fall into an infinite recursion loop
                     Sprig::$_relations[$pair] = TRUE;
                     $tables = array($this->table(), Sprig::factory($field->model)->table());
                     // Sort the table names alphabetically
                     sort($tables);
                     // Join the table names to get the table name
                     Sprig::$_relations[$pair] = implode('_', $tables);
                 }
                 // Assign by reference so that changes to the pivot table
                 // will carry over to all models
                 $field->through =& Sprig::$_relations[$pair];
             }
         }
         if (!$field->column) {
             // Create the key based on the field name
             if ($field instanceof Sprig_Field_BelongsTo) {
                 if (isset($field->foreign_key) and $field->foreign_key) {
                     $fk = $field->foreign_key;
                 } else {
                     $fk = Sprig::factory($field->model)->fk();
                 }
                 $field->column = $fk;
             } elseif ($field instanceof Sprig_Field_HasOne) {
                 $field->column = $this->fk();
             } elseif ($field instanceof Sprig_Field_ForeignKey) {
                 // This field is probably a Many and does not need a column
             } else {
                 $field->column = $name;
             }
         }
         if (!$field->label) {
             $field->label = Inflector::humanize($name);
         }
         if ($field->null) {
             // Fields that allow NULL values must accept empty values
             $field->empty = TRUE;
         }
         if ($field->editable) {
             if (!$field->empty and !isset($field->rules['not_empty'])) {
                 // This field must not be empty
                 $field->rules['not_empty'] = NULL;
             }
             if ($field->unique) {
                 // Field must be a unique value
                 $field->callbacks[] = array($this, '_unique_field');
             }
             if ($field->choices and !isset($field->rules['in_array'])) {
                 // Field must be one of the available choices
                 $field->rules['in_array'] = array(array_keys($field->choices));
             }
             if (!empty($field->min_length)) {
                 $field->rules['min_length'] = array($field->min_length);
             }
             if (!empty($field->max_length)) {
                 $field->rules['max_length'] = array($field->max_length);
             }
         }
         if ($field instanceof Sprig_Field_BelongsTo or !$field instanceof Sprig_Field_ForeignKey) {
             // Set the default value for any field that is stored in the database
             $this->_original[$name] = $field->value($field->default);
         }
     }
 }
Exemplo n.º 16
0
 /**
  * Initialize the fields and add validation rules based on field properties.
  *
  * @return  void
  */
 protected function init()
 {
     if ($this->_init) {
         // Can only be called once
         return;
     }
     // Set up fields
     $this->set_model_definition();
     if (!$this->_model) {
         // Set the model name based on the class name
         $this->_model = strtolower(substr(get_class($this), 6));
     }
     foreach ($this->_fields as $name => &$field) {
         if ($field['type'] === 'has_one' && !isset($field['model'])) {
             $field['model'] = $name;
         } elseif ($field['type'] === 'has_many' && !isset($field['model'])) {
             $field['model'] = Inflector::singular($name);
         }
     }
     if (!$this->_embedded) {
         if (!$this->_collection) {
             // Set the collection name to the plural model name
             $this->_collection = Inflector::plural($this->_model);
         }
         if (!isset($this->_fields['_id'])) {
             // default _id field
             $this->_fields['_id'] = array('type' => 'MongoId');
         }
         // Normalize relations
         foreach ($this->_relations as $name => &$relation) {
             if ($relation['type'] === 'has_and_belongs_to_many') {
                 $relation['model'] = isset($relation['model']) ? $relation['model'] : Inflector::singular($name);
                 $relation['related_relation'] = isset($relation['related_relation']) ? $relation['related_relation'] : Inflector::plural($this->_model);
             } elseif (!isset($relation['model'])) {
                 if ($relation['type'] === 'belongs_to' || $relation['type'] === 'has_one') {
                     $relation['model'] = $name;
                 } else {
                     $relation['model'] = Inflector::singular($name);
                 }
             }
             switch ($relation['type']) {
                 case 'belongs_to':
                     $this->_fields[$name . '_id'] = array('type' => 'MongoId', 'required' => !Arr::get($relation, 'sparse', FALSE));
                     break;
                 case 'has_and_belongs_to_many':
                     $this->_fields[$name . '_ids'] = array('type' => 'set', 'duplicates' => FALSE);
                     break;
             }
         }
     }
     $this->_init = TRUE;
 }
Exemplo n.º 17
0
 /**
  * Builds "degenerated" words if the word does not exist in the database.
  *
  * @access  protected
  * @param   string  word to degenerate
  * @return  array   array of degenerated words of the word
  */
 protected function _degenerate_word($word)
 {
     // Check if word has been processed already
     if (isset($this->degenerates[$word]) === TRUE) {
         return $this->degenerates[$word];
     }
     $degenerates = array();
     // Add word with upper, lower and ucfirst casing
     $degenerates[] = strtolower($word);
     $degenerates[] = strtoupper($word);
     $degenerates[] = ucfirst($word);
     // Temporarily remove ! or ? or . from end of word for inflections
     $w = preg_replace('/([!?\\.])+$/', '', $word);
     // Add inflections
     $singular = Inflector::singular($w);
     $plural = Inflector::plural($w);
     $degenerates[] = $singular;
     $degenerates[] = strtoupper($singular);
     $degenerates[] = ucfirst($singular);
     $degenerates[] = $plural;
     $degenerates[] = strtoupper($plural);
     $degenerates[] = ucfirst($plural);
     // Remove duplicates
     $degenerates = array_unique($degenerates);
     // Degenerate each casing versions
     foreach ($degenerates as $degenerate) {
         // Check for ! or ? at end of word
         if (preg_match('/[!?]$/', $degenerate)) {
             // Reduce to single ! or ? at end of word, if multiple were found
             if (preg_match('/[!?]{2,}$/', $degenerate) > 0) {
                 $degenerates[] = preg_replace('/([!?])+$/', '$1', $degenerate);
             }
             // Remove ! or ? from end of word
             $degenerates[] = preg_replace('/([!?])+$/', '', $degenerate);
         } else {
             // Add ! and ? to end of word
             $degenerates[] = $degenerate . '!';
             $degenerates[] = $degenerate . '?';
         }
         // Remove . from end of word
         if (preg_match('/[\\.]$/', $degenerate)) {
             while (preg_match('/[\\.]$/', $degenerate)) {
                 $degenerates[] = $degenerate = substr($degenerate, 0, strlen($degenerate) - 1);
             }
         } else {
             // Add . to end of word
             $degenerates[] = $degenerate . '.';
         }
     }
     // Remove duplicates
     $degenerates = array_unique($degenerates);
     // Remove degenerate word that matches the original word
     if (in_array($word, $degenerates)) {
         foreach ($degenerates as $key => $degenerate) {
             if ($degenerate == $word) {
                 unset($degenerates[$key]);
                 break;
             }
         }
     }
     // Store the list of degenerates for the word
     $this->degenerates[$word] = $degenerates;
     return $degenerates;
 }
Exemplo n.º 18
0
Arquivo: orm.php Projeto: halkeye/tops
 /**
  * Prepares the model database connection, determines the table name,
  * and loads column information.
  *
  * @return  void
  */
 protected function _initialize()
 {
     if (!is_object($this->_db)) {
         // Get database instance
         $this->_db = Database::instance($this->_db);
     }
     if (empty($this->_table_name)) {
         // Table name is the same as the object name
         $this->_table_name = $this->_object_name;
         if ($this->_table_names_plural === TRUE) {
             // Make the table name plural
             $this->_table_name = Inflector::plural($this->_table_name);
         }
     }
     foreach ($this->_belongs_to as $alias => $details) {
         $defaults['model'] = $alias;
         $defaults['foreign_key'] = $alias . $this->_foreign_key_suffix;
         $this->_belongs_to[$alias] = array_merge($defaults, $details);
     }
     foreach ($this->_has_one as $alias => $details) {
         $defaults['model'] = $alias;
         $defaults['foreign_key'] = $this->_object_name . $this->_foreign_key_suffix;
         $this->_has_one[$alias] = array_merge($defaults, $details);
     }
     foreach ($this->_has_many as $alias => $details) {
         $defaults['model'] = Inflector::singular($alias);
         $defaults['foreign_key'] = $this->_object_name . $this->_foreign_key_suffix;
         $defaults['through'] = NULL;
         $defaults['far_key'] = Inflector::singular($alias) . $this->_foreign_key_suffix;
         $this->_has_many[$alias] = array_merge($defaults, $details);
     }
     // Load column information
     $this->reload_columns();
 }
Exemplo n.º 19
0
 /**
  * Recursive helper for writing XML element(s)
  *
  * @param XMLWriter    $xml  XMLWriter instance
  * @param array|string $data element(s) to write
  * @param string       $root root tag for nested elements
  */
 private static function __from_array(XMLWriter &$xml, $data, $root = '')
 {
     if (is_array($data)) {
         foreach ($data as $index => $element) {
             if (is_int($index)) {
                 $root = $root ? Inflector::singular($root) : 'element_' . $index;
             } else {
                 $root = $index;
             }
             $xml->startElement($root);
             if (is_array($element)) {
                 self::__from_array($xml, $element, $root);
             } else {
                 if (ctype_alnum($element) or ctype_graph($element) or strpos($element, ' ') > -1) {
                     $xml->writeCdata($element);
                 } else {
                     $xml->writeRaw($element);
                 }
             }
             $xml->endElement();
         }
     }
 }
Exemplo n.º 20
0
 public function proxy_load_relationship($object, $relationship)
 {
     // Build query :
     $query = glue::qselect($this->name, $set);
     foreach ($this->object_pk($object) as $f => $val) {
         $query->where($f, '=', $val);
         $query->fields($f);
     }
     $query->with($set, Inflector::singular($relationship));
     // Execute query :
     $query->execute();
 }
Exemplo n.º 21
0
 /**
  * Tests Inflector::singular
  *
  * @test
  * @dataProvider provider_singular
  * @param boolean $input  Input for File::mime
  * @param boolean $expected Output for File::mime
  */
 public function test_singular($input, $count, $expected)
 {
     $this->assertSame($expected, Inflector::singular($input, $count));
 }
Exemplo n.º 22
0
 /**
  * Setting namespace item for a log section
  *
  * @param string $item
  * @param string $section
  */
 public function _set_namespace_item($item, $section)
 {
     $item = Sprig::factory(Inflector::singular($section) . '_sprig', array('name' => $item));
     $item->create();
     Logapp::${$section}[$item] = $_item->id;
 }
Exemplo n.º 23
0
 /**
  * Setting namespace item for a log section
  *
  * @param string $item
  * @param string $section
  */
 public function _set_namespace_item($item, $section)
 {
     $_item = Jelly::factory(Inflector::singular($section) . '_jelly')->set(array('name' => $item))->save();
     Logapp::${$section}[$item] = $_item->id;
 }
Exemplo n.º 24
0
 /**
  * Safe Tag
  *
  * Pass individual tag phrases along with object and object ID's in order to
  * set a tag on an object. If the tag in its raw form does not yet exist,
  * this function will create it.
  *
  * @param   integer  $user_id  The user_id unique ID of the person who tagged the object with this tag
  * @param   Model    $object   The Model Object
  * @param   string   $tag      A raw string from a web form containing tags
  * @return  boolean
  *
  * @uses    Inflector::singular
  */
 public function safe_tag($user_id = 0, Model $object, $tag = '')
 {
     $object_id = $object->id;
     if (!($user_id = intval($user_id)) or !($object_id = intval($object_id)) or empty($tag)) {
         return FALSE;
     }
     if (!empty($this->config['append_to_integer']) and is_numeric($tag) and intval($tag) == $tag) {
         // Converts numeric tag "123" to "123_" to facilitate
         // alphanumeric sorting (otherwise, PHP converts string to
         // true integer).
         $tag = preg_replace('/^([0-9]+)$/', "\$1" . $this->config['append_to_integer'], $tag);
     }
     $normalized_tag = $this->normalize_tag(strtolower($tag));
     //this is required to avoid duplicate tags, ex: 'demo, demo, test'
     $result = ORM::factory(Inflector::singular($this->config['tagging_model']))->join($this->config['tag_table'], 'INNER')->on('tag_id', '=', $this->config['tag_table'] . '.id')->where($this->config['object_foreign_key'], '=', $object_id)->where($this->config['tag_table'] . '.type', '=', $object->type)->where('name', '=', $normalized_tag);
     if ($result->reset(FALSE)->count_all() > 0) {
         return TRUE;
     }
     // Then see if a tag in this form exists.
     $result = ORM::factory(Inflector::singular($this->config['tag_table']))->where('name', '=', $tag)->where('type', '=', $object->type);
     if ($result->reset(FALSE)->count_all() > 0) {
         $result = $result->find();
         $tag_id = $result->id;
     } else {
         // Add new tag!
         $new_tag = ORM::factory(Inflector::singular($this->config['tag_table']));
         $new_tag->name = $normalized_tag;
         $new_tag->type = $object->type;
         $new_tag->save();
         $tag_id = $new_tag->id;
     }
     if (!($tag_id > 0)) {
         return FALSE;
     }
     $new_tagging = ORM::factory(Inflector::singular($this->config['tagging_model']));
     $new_tagging->tag_id = $tag_id;
     $new_tagging->author = $user_id;
     $new_tagging->type = $object->type;
     $new_tagging->{$this->config['object_foreign_key']} = $object_id;
     $new_tagging->save();
     return TRUE;
 }
Exemplo n.º 25
0
<div id="chart" class="yui-u">
<canvas id="perfchart" width="600" height="250">Performance chart here.</canvas>
</div>

</div>
<ul>
<?php 
echo '<li>server ', html::anchor($bot->server->uri(), $bot->server->name), '</li>';
?>
</ul>

<?php 
if (isset($stats)) {
    ?>
<h3>Last <?php 
    echo count($stats), ' ', ucfirst(Inflector::singular('games', count($stats)));
    ?>
 of <?php 
    echo $game_count;
    ?>
</h3>
<ol class="stats">
<?php 
    foreach ($stats as $game) {
        echo '<li>', $game->DatePlayed, ' ', html::anchor($game->bot1->uri(), $game->bot1->name), ', ', html::anchor($game->bot2->uri(), $game->bot2->name), ', ', html::anchor($game->bot3->uri(), $game->bot3->name), ', ', html::anchor($game->bot4->uri(), $game->bot4->name), ' Winner: ', html::anchor($game->winner->uri(), $game->winner->name), ' ', '<span>Show History</span>', '<div class="history">', '<pre>', $game->GameHistory, '</pre>', '</div>', '</li>';
    }
    ?>
</ol>
<?php 
}
?>
Exemplo n.º 26
0
 /**
  * Clears all inflection rules.
  *
  * @param string|boolean $lang The language name to reset or `true` to reset all even defaults.
  */
 public static function reset($lang = null)
 {
     if (is_string($lang)) {
         unset(static::$_singular[$lang]);
         unset(static::$_plural[$lang]);
         return;
     }
     static::$_singular = [];
     static::$_plural = [];
     if ($lang === true) {
         return;
     }
     /**
      * Initilalize the class with english inflector rules.
      */
     Inflector::singular('/([^s])s$/i', '\\1', 'default');
     Inflector::plural('/([^s])$/i', '\\1s', 'default');
     Inflector::singular('/(x|z|s|ss|ch|sh)es$/i', '\\1', 'default');
     Inflector::plural('/(x|z|ss|ch|sh)$/i', '\\1es', 'default');
     Inflector::singular('/ies$/i', 'y', 'default');
     Inflector::plural('/([^aeiouy]|qu)y$/i', '\\1ies', 'default');
     Inflector::plural('/(meta|data)$/i', '\\1', 'default');
     Inflector::irregular('child', 'children', 'default');
     Inflector::irregular('equipment', 'equipment', 'default');
     Inflector::irregular('information', 'information', 'default');
     Inflector::irregular('man', 'men', 'default');
     Inflector::irregular('news', 'news', 'default');
     Inflector::irregular('person', 'people', 'default');
     Inflector::irregular('woman', 'women', 'default');
     /**
      * Warning, using an "exhastive" list of rules will slow
      * down all singularizations/pluralizations generations.
      * So it may be preferable to only add the ones you are actually needed.
      *
      * Anyhow bellow a list english exceptions which are not covered by the above rules.
      */
     // Inflector::irregular('advice', 'advice', 'default');
     // Inflector::irregular('aircraft', 'aircraft', 'default');
     // Inflector::irregular('alias', 'aliases', 'default');
     // Inflector::irregular('alga', 'algae', 'default');
     // Inflector::irregular('alumna', 'alumnae', 'default');
     // Inflector::irregular('alumnus', 'alumni', 'default');
     // Inflector::irregular('analysis', 'analyses', 'default');
     // Inflector::irregular('antenna', 'antennae', 'default');
     // Inflector::irregular('automaton', 'automata', 'default');
     // Inflector::irregular('axis', 'axes', 'default');
     // Inflector::irregular('bacillus', 'bacilli', 'default');
     // Inflector::irregular('bacterium', 'bacteria', 'default');
     // Inflector::irregular('barracks', 'barracks', 'default');
     // Inflector::irregular('basis', 'bases', 'default');
     // Inflector::irregular('bellows', 'bellows', 'default');
     // Inflector::irregular('buffalo', 'buffaloes', 'default');
     // Inflector::irregular('bus', 'buses', 'default');
     // Inflector::irregular('bison', 'bison', 'default');
     // Inflector::irregular('cactus', 'cacti', 'default');
     // Inflector::irregular('cafe', 'cafes', 'default');
     // Inflector::irregular('calf', 'calves', 'default');
     // Inflector::irregular('cargo', 'cargoes', 'default');
     // Inflector::irregular('cattle', 'cattle', 'default');
     // Inflector::irregular('child', 'children', 'default');
     // Inflector::irregular('congratulations', 'congratulations', 'default');
     // Inflector::irregular('corn', 'corn', 'default');
     // Inflector::irregular('crisis', 'crises', 'default');
     // Inflector::irregular('criteria', 'criterion', 'default');
     // Inflector::irregular('curriculum', 'curricula', 'default');
     // Inflector::irregular('datum', 'data', 'default');
     // Inflector::irregular('deer', 'deer', 'default');
     // Inflector::irregular('die', 'dice', 'default');
     // Inflector::irregular('dregs', 'dregs', 'default');
     // Inflector::irregular('duck', 'duck', 'default');
     // Inflector::irregular('echo', 'echos', 'default');
     // Inflector::irregular('elf', 'elves', 'default');
     // Inflector::irregular('ellipsis', 'ellipses', 'default');
     // Inflector::irregular('embargo', 'embargoes', 'default');
     // Inflector::irregular('equipment', 'equipment', 'default');
     // Inflector::irregular('erratum', 'errata', 'default');
     // Inflector::irregular('evidence', 'evidence', 'default');
     // Inflector::irregular('eyeglasses', 'eyeglasses', 'default');
     // Inflector::irregular('fish', 'fish', 'default');
     // Inflector::irregular('focus', 'foci', 'default');
     // Inflector::irregular('foot', 'feet', 'default');
     // Inflector::irregular('fungus', 'fungi', 'default');
     // Inflector::irregular('gallows', 'gallows', 'default');
     // Inflector::irregular('genus', 'genera', 'default');
     // Inflector::irregular('goose', 'geese', 'default');
     // Inflector::irregular('gold', 'gold', 'default');
     // Inflector::irregular('grotto', 'grottoes', 'default');
     // Inflector::irregular('gymnasium', 'gymnasia', 'default');
     // Inflector::irregular('half', 'halves', 'default');
     // Inflector::irregular('headquarters', 'headquarters', 'default');
     // Inflector::irregular('hoof', 'hooves', 'default');
     // Inflector::irregular('hypothesis', 'hypotheses', 'default');
     // Inflector::irregular('information', 'information', 'default');
     // Inflector::irregular('graffito', 'graffiti', 'default');
     // Inflector::irregular('half', 'halves', 'default');
     // Inflector::irregular('hero', 'heroes', 'default');
     // Inflector::irregular('jewelry', 'jewelry', 'default');
     // Inflector::irregular('kin', 'kin', 'default');
     // Inflector::irregular('knife', 'knives', 'default');
     // Inflector::irregular('larva', 'larvae', 'default');
     // Inflector::irregular('leaf', 'leaves', 'default');
     // Inflector::irregular('legislation', 'legislation', 'default');
     // Inflector::irregular('life', 'lives', 'default');
     // Inflector::irregular('loaf', 'loaves', 'default');
     // Inflector::irregular('locus', 'loci', 'default');
     // Inflector::irregular('louse', 'lice', 'default');
     // Inflector::irregular('luck', 'luck', 'default');
     // Inflector::irregular('luggage', 'luggage', 'default');
     // Inflector::irregular('man', 'men', 'default');
     // Inflector::irregular('mathematics', 'mathematics', 'default');
     // Inflector::irregular('matrix', 'matrices', 'default');
     // Inflector::irregular('means', 'means', 'default');
     // Inflector::irregular('measles', 'measles', 'default');
     // Inflector::irregular('medium', 'media', 'default');
     // Inflector::irregular('memorandum', 'memoranda', 'default');
     // Inflector::irregular('money', 'monies', 'default');
     // Inflector::irregular('moose', 'moose', 'default');
     // Inflector::irregular('mosquito', 'mosquitoes', 'default');
     // Inflector::irregular('motto', 'mottoes', 'default');
     // Inflector::irregular('mouse', 'mice', 'default');
     // Inflector::irregular('mumps', 'mumps', 'default');
     // Inflector::irregular('music', 'music', 'default');
     // Inflector::irregular('mythos', 'mythoi', 'default');
     // Inflector::irregular('nebula', 'nebulae', 'default');
     // Inflector::irregular('neurosis', 'neuroses', 'default');
     // Inflector::irregular('news', 'news', 'default');
     // Inflector::irregular('nucleus', 'nuclei', 'default');
     // Inflector::irregular('numen', 'numina', 'default');
     // Inflector::irregular('oasis', 'oases', 'default');
     // Inflector::irregular('oats', 'oats', 'default');
     // Inflector::irregular('octopus', 'octopuses', 'default');
     // Inflector::irregular('offspring', 'offspring', 'default');
     // Inflector::irregular('ovum', 'ova', 'default');
     // Inflector::irregular('ox', 'oxen', 'default');
     // Inflector::irregular('pajamas', 'pajamas', 'default');
     // Inflector::irregular('pants', 'pants', 'default');
     // Inflector::irregular('paralysis', 'paralyses', 'default');
     // Inflector::irregular('parenthesis', 'parentheses', 'default');
     // Inflector::irregular('person', 'people', 'default');
     // Inflector::irregular('phenomenon', 'phenomena', 'default');
     // Inflector::irregular('pike', 'pike', 'default');
     // Inflector::irregular('plankton', 'plankton', 'default');
     // Inflector::irregular('pliers', 'pliers', 'default');
     // Inflector::irregular('polyhedron', 'polyhedra', 'default');
     // Inflector::irregular('potato', 'potatoes', 'default');
     // Inflector::irregular('quiz', 'quizzes', 'default');
     // Inflector::irregular('radius', 'radii', 'default');
     // Inflector::irregular('roof', 'roofs', 'default');
     // Inflector::irregular('salmon', 'salmon', 'default');
     // Inflector::irregular('scarf', 'scarves', 'default');
     // Inflector::irregular('scissors', 'scissors', 'default');
     // Inflector::irregular('self', 'selves', 'default');
     // Inflector::irregular('series', 'series', 'default');
     // Inflector::irregular('shears', 'shears', 'default');
     // Inflector::irregular('sheep', 'sheep', 'default');
     // Inflector::irregular('shelf', 'shelves', 'default');
     // Inflector::irregular('shorts', 'shorts', 'default');
     // Inflector::irregular('silver', 'silver', 'default');
     // Inflector::irregular('species', 'species', 'default');
     // Inflector::irregular('squid', 'squid', 'default');
     // Inflector::irregular('stimulus', 'stimuli', 'default');
     // Inflector::irregular('stratum', 'strata', 'default');
     // Inflector::irregular('swine', 'swine', 'default');
     // Inflector::irregular('syllabus', 'syllabi', 'default');
     // Inflector::irregular('synopsis', 'synopses', 'default');
     // Inflector::irregular('synthesis', 'syntheses', 'default');
     // Inflector::irregular('tax', 'taxes', 'default');
     // Inflector::irregular('terminus', 'termini', 'default');
     // Inflector::irregular('thesis', 'theses', 'default');
     // Inflector::irregular('thief', 'thieves', 'default');
     // Inflector::irregular('tomato', 'tomatoes', 'default');
     // Inflector::irregular('tongs', 'tongs', 'default');
     // Inflector::irregular('tooth', 'teeth', 'default');
     // Inflector::irregular('torpedo', 'torpedoes', 'default');
     // Inflector::irregular('torus', 'tori', 'default');
     // Inflector::irregular('trousers', 'trousers', 'default');
     // Inflector::irregular('trout', 'trout', 'default');
     // Inflector::irregular('tweezers', 'tweezers', 'default');
     // Inflector::irregular('vertebra', 'vertebrae', 'default');
     // Inflector::irregular('vertex', 'vertices', 'default');
     // Inflector::irregular('vespers', 'vespers', 'default');
     // Inflector::irregular('veto', 'vetoes', 'default');
     // Inflector::irregular('volcano', 'volcanoes', 'default');
     // Inflector::irregular('vortex', 'vortices', 'default');
     // Inflector::irregular('vita', 'vitae', 'default');
     // Inflector::irregular('virus', 'viri', 'default');
     // Inflector::irregular('wheat', 'wheat', 'default');
     // Inflector::irregular('wife', 'wives', 'default');
     // Inflector::irregular('wolf', 'wolves', 'default');
     // Inflector::irregular('woman', 'women', 'default');
     // Inflector::irregular('zero', 'zeros', 'default');
 }
Exemplo n.º 27
0
 /**
  * Gets the database columns associated with the field.
  * 
  * @param	Sprig_Field	The sprig field.
  * @param	Database_Table	The parent database table.
  * @return	array
  */
 private function _columns(Sprig_Field $field, Database_Table $table)
 {
     // Foreign keys are represented as BelongTo relationships
     if ($field instanceof Sprig_Field_BelongsTo) {
         // Get the model the field references
         $references = $this->_model($field->model);
         // Get all the primary keys in the referenced model as an array
         $pks = is_array($references->pk()) ? $references->pk() : array($references->pk());
         // Prepare a column array
         $columns = array();
         // Loop through each primary key
         foreach ($pks as $pk) {
             // Get the foreign primary key field
             $foreign_field = $references->field($pk);
             // Generates a table column for that foreign field
             $column = current($this->_columns($foreign_field, $table));
             // Renames the column to the standard foreign key format
             $column->name = Inflector::singular($references->table()) . '_' . $pk;
             // If the column is an integer
             if ($column instanceof Database_Column_Int) {
                 // We must disable auto_increment
                 $column->auto_increment = FALSE;
             }
             // Add the column to the column array
             $columns[] = $column;
         }
         // No further processing is needed, so return the columns.
         return $columns;
     } elseif ($field instanceof Sprig_Field_Char) {
         // If the character field is a text field
         if ($field instanceof Sprig_Field_Text) {
             // Set the column to have a text datatype
             $column = Database_Column::factory('text');
             // TODO: Ugly hack, fix it. (Text datatypes dont take parameters).
             unset($column->max_length);
         } else {
             // Create a new database column
             $column = Database_Column::factory('varchar');
             // Set the varchar's max length to a default of 45
             $column->max_length = isset($field->max_length) ? $field->max_length : 64;
         }
     } elseif ($field instanceof Sprig_Field_Integer) {
         // Use the int datatype and create the column
         $column = Database_Column::factory('int');
         // If the field is Sprig_Field_Auto then auto_increment is set to true.
         $column->auto_increment = $field instanceof Sprig_Field_Auto;
     } elseif ($field instanceof Sprig_Field_Boolean) {
         // Very simply, a tinyint is a 0 or a 1
         $column = Database_Column::factory('tinyint');
     }
     // Set the value of the column's name
     $column->name = $field->column;
     // Set the column's default value
     $column->default = $field->default;
     // The column is nullable if the field is not empty
     $column->nullable = !$field->empty;
     // Return the column as an array
     return array($column);
 }
Exemplo n.º 28
0
        ?>
			<?php 
        $hide = ($type === 'skipped' or $type === 'incomplete');
        ?>
			<div class="<?php 
        echo $type;
        ?>
-list">
				<h2 onclick="toggle('<?php 
        echo $type;
        ?>
');"><?php 
        echo count($tests);
        ?>
					<?php 
        echo __(ucfirst(Inflector::singular($type, count($tests))));
        ?>
					<span id="<?php 
        echo $type;
        ?>
-show" class="show">[<?php 
        echo $hide ? __('show') : __('hide');
        ?>
]</span></h2>
				<ol id="<?php 
        echo $type;
        ?>
-ol" class="<?php 
        echo $hide ? 'hidden' : '';
        ?>
">
Exemplo n.º 29
0
 /**
  * Prepares the model database connection, determines the table name,
  * and loads column information.
  *
  * @return void
  */
 protected function _initialize()
 {
     // Set the object name and plural name
     $this->_object_name = strtolower(substr(get_class($this), 6));
     // Check if this model has already been initialized
     if (!($init = Arr::get(ORM::$_init_cache, $this->_object_name, FALSE))) {
         $init = array('_belongs_to' => array(), '_has_one' => array(), '_has_many' => array(), '_has_many_keys' => array());
         // Set the object plural name if none predefined
         if (!isset($this->_object_plural)) {
             $init['_object_plural'] = Inflector::plural($this->_object_name);
         }
         if (!$this->_errors_filename) {
             $init['_errors_filename'] = $this->_object_name;
         }
         if (!is_object($this->_db)) {
             // Get database instance
             $init['_db'] = Database::instance($this->_db_group);
         }
         if (empty($this->_table_name)) {
             // Table name is the same as the object name
             $init['_table_name'] = $this->_object_name;
             if ($this->_table_names_plural === TRUE) {
                 // Make the table name plural
                 $init['_table_name'] = Arr::get($init, '_object_plural', $this->_object_plural);
             }
         }
         if (!empty($this->_ignored_columns)) {
             // Optimize for performance
             $init['_ignored_columns'] = array_combine($this->_ignored_columns, $this->_ignored_columns);
         }
         $defaults = array();
         foreach ($this->_belongs_to as $alias => $details) {
             $defaults['model'] = $alias;
             $defaults['foreign_key'] = $alias . $this->_foreign_key_suffix;
             $init['_belongs_to'][$alias] = array_merge($defaults, $details);
         }
         foreach ($this->_has_one as $alias => $details) {
             $defaults['model'] = $alias;
             $defaults['foreign_key'] = $this->_object_name . $this->_foreign_key_suffix;
             $init['_has_one'][$alias] = array_merge($defaults, $details);
         }
         foreach ($this->_has_many as $alias => $details) {
             $defaults['model'] = Inflector::singular($alias);
             $defaults['foreign_key'] = $this->_object_name . $this->_foreign_key_suffix;
             $defaults['through'] = NULL;
             $defaults['far_key'] = Inflector::singular($alias) . $this->_foreign_key_suffix;
             $init['_has_many'][$alias] = array_merge($defaults, $details);
         }
         foreach ($this->_has_many_keys as $alias => $details) {
             $defaults['model'] = Inflector::singular($alias);
             $defaults['foreign_key'] = array($this->_object_name . $this->_foreign_key_suffix);
             $defaults['far_key'] = array(Inflector::singular($alias) . $this->_foreign_key_suffix);
             $init['_has_many_keys'][$alias] = array_merge($defaults, $details);
         }
         ORM::$_init_cache[$this->_object_name] = $init;
     }
     // Assign initialized properties to the current object
     foreach ($init as $property => $value) {
         $this->{$property} = $value;
     }
     // Load column information
     $this->reload_columns();
     // Clear initial model state
     $this->clear();
 }
Exemplo n.º 30
0
 public static function generate_model($model, $force = FALSE)
 {
     $class_name = 'Model_' . $model;
     $file = str_replace('_', DIRECTORY_SEPARATOR, $model);
     $base_dir = 'Base';
     $model_dir = APPPATH . 'classes' . DIRECTORY_SEPARATOR . 'Model' . DIRECTORY_SEPARATOR;
     $model_base = $model_dir . $base_dir . DIRECTORY_SEPARATOR;
     $file_name = Kohana::find_file('classes/model', $file);
     $file_base_name = Kohana::find_file('classes/model/base', $file);
     $table_name = strtolower(Inflector::plural($model));
     $table_id = strtolower($model) . '_id';
     $rules = array();
     $labels = array();
     $has_many = array();
     $belongs_to = array();
     $columns = Database::instance()->list_columns($table_name);
     foreach ($columns as $field) {
         $name = Arr::get($field, 'column_name');
         $key = Arr::get($field, 'key');
         $type = Arr::get($field, 'type');
         $low_name = str_replace('_id', '', $name);
         $maximum_length = Arr::get($field, 'character_maximum_length', Arr::get($field, 'display'));
         $title = ucfirst($name);
         // ignore id and _at$
         if ($name === 'id' or preg_match('@_at$@', $name)) {
             continue;
         }
         $field_rules = array();
         // unique
         if ($key === 'UNI') {
             $field_rules[] = "array(array(\$this, 'unique'), array(':field', ':value')),";
         }
         // unique
         if ($type === 'int') {
             $field_rules[] = "array('numeric'),";
         }
         // not null
         if (Arr::get($field, 'is_nullable') === FALSE) {
             $field_rules[] = "array('not_empty'),";
         }
         // max length
         if ($maximum_length) {
             $field_rules[] = "array('max_length', array(':value', {$maximum_length})),";
         }
         // cpf
         if ($name === 'cpf') {
             $field_rules[] = "array('cpf', array(':value')),";
         }
         // email
         if (preg_match('@email@', $name)) {
             $field_rules[] = "array('email', array(':value')),";
         }
         // rules
         if (!empty($field_rules)) {
             $rules[$name] = $field_rules;
         }
         // labels
         if (!preg_match('@_id$@', $name)) {
             $labels[$name] = $title;
         }
         // belongs to
         if (preg_match('@_id$@', $name)) {
             $model_name = ORM::get_model_name($low_name);
             $belongs_to[$low_name] = "array(" . "'model' => '" . $model_name . "'" . "),";
             $labels[$low_name] = ucfirst($low_name);
         }
     }
     foreach (Database::instance()->list_tables() as $name) {
         $_columns = array_keys(Database::instance()->list_columns($name));
         // has many through
         if (preg_match('/(^' . $table_name . '_(.*)|(.*)_' . $table_name . '$)/', $name, $matchs)) {
             $related = $matchs[count($matchs) - 1];
             $has_many[$related] = "array(" . "'model' => '" . ORM::get_model_name($related) . "', " . "'through' => '" . $name . "'" . "),";
             $labels[$related] = ucfirst($related);
         }
         // has many
         if (in_array('id', $_columns) and in_array($table_id, $_columns)) {
             $related = Inflector::singular($name);
             $field_name = Inflector::singular($table_name);
             $model_name = ORM::get_model_name($related);
             $has_many[str_replace($field_name . '_', '', $name)] = "array(" . "'model' => '" . $model_name . "'" . "),";
         }
     }
     $class_extends = 'Model_App';
     $columns = self::format_columns($columns);
     $full_class_name = 'Model_' . $base_dir . '_' . $model;
     $view = View::factory('huia/orm/base');
     $view->set('class_name', $full_class_name);
     $view->set('class_extends', $class_extends);
     $view->set('table_name', $class_name);
     $view->set('rules', $rules);
     $view->set('labels', $labels);
     $view->set('has_many', $has_many);
     $view->set('belongs_to', $belongs_to);
     $view->set('columns', $columns);
     $render_view = $view->render();
     $hash_current = $file_base_name ? preg_replace("/[^A-Za-z0-9]/", "", @file_get_contents($file_base_name)) : NULL;
     $hash_new = preg_replace("/[^A-Za-z0-9]/", "", $render_view);
     if ($hash_current !== $hash_new) {
         $file_base_name = $model_base . $file . EXT;
         create_dir(dirname($file_base_name));
         file_put_contents($file_base_name, $view->render());
     }
     // Create if dont exists
     if (!$file_name) {
         $view = View::factory('huia/orm');
         $view->set('class_name', $class_name);
         $view->set('class_extends', 'Model_' . $base_dir . '_' . $model);
         $file_name = $model_dir . $file . EXT;
         create_dir(dirname($file_name));
         file_put_contents($file_name, $view->render());
     }
 }