/**
     * Cache a file containing the dispatch list.
     *
     * Serializes the server definition stores the information
     * in $filename.
     *
     * Returns false on any error (typically, inability to write to file), true
     * on success.
     *
     * @param  string $filename
     * @param  \Zend\Server\Server $server
     * @return bool
     */
    public static function save($filename, Server $server)
    {
        if (!is_string($filename)
            || (!file_exists($filename) && !is_writable(dirname($filename))))
        {
            return false;
        }

        $methods = $server->getFunctions();

        if ($methods instanceof Definition) {
            $definition = new Definition();
            foreach ($methods as $method) {
                if (in_array($method->getName(), self::$_skipMethods)) {
                    continue;
                }
                $definition->addMethod($method);
            }
            $methods = $definition;
        }

        if (0 === @file_put_contents($filename, serialize($methods))) {
            return false;
        }

        return true;
    }

 /**
  * @param Definition $definition
  */
 public function add(Definition $definition)
 {
     if (!class_exists($definition->getClass())) {
         throw new \InvalidArgumentException(sprintf("Invalid class \"%s\"", $definition->getClass()));
     }
     $this->classes[$definition->getName()] = $definition;
 }

 /**
  * @test
  */
 public function expects_an_expected_field_in_each_expectation()
 {
     $this->assertException(new \Exception('Missing expected field.'), function () {
         $definitions = array('expectations' => array(array('uri' => 'http://www.example.com', 'type' => 'json')));
         $d = new Definition($definitions);
         $d->getExpectations();
     });
 }

 /**
  * {@inheritdoc}
  */
 public function create($type, $path, array $properties = array())
 {
     $definition = new Definition();
     $definition->setType($type);
     $definition->setPath($path);
     $definition->setProperties($properties);
     return $definition;
 }

/**
 * Creates a matrix with 7 columns, one per day of week, and as many rows (weeks) as necessary.
 * Every cell contains a dictionary with the wotd, the definition and other info.
 */
function createCalendar($year, $month)
{
    $days = listDaysOfMonth($year, $month);
    $today = date('Y-m-d');
    $calendar = array();
    // Pad beginning
    $startDow = date('N', strtotime("{$year}-{$month}-01"));
    for ($i = 1; $i < $startDow; $i++) {
        $calendar[] = array();
    }
    // Create a record per day
    foreach ($days as $i => $date) {
        $wotd = WordOfTheDay::get_by_displayDate($date);
        $wotdr = $wotd ? WordOfTheDayRel::get_by_wotdId($wotd->id) : null;
        $def = $wotdr ? Definition::get_by_id($wotdr->refId) : null;
        $visible = $def && ($date <= $today || util_isModerator(PRIV_WOTD));
        $calendar[] = array('wotd' => $wotd, 'def' => $def, 'visible' => $visible, 'dayOfMonth' => $i + 1);
    }
    // Pad end
    while (count($calendar) % 7 != 0) {
        $calendar[] = array();
    }
    // Wrap 7 records per line
    $weeks = array();
    while (count($calendar)) {
        $weeks[] = array_splice($calendar, 0, 7);
    }
    return $weeks;
}

function smarty_fetchSkin()
{
    $skin = session_getSkin();
    // Set some skin variables based on the skin preferences in the config file.
    // Also assign some skin-specific variables so we don't compute them unless we need them
    $skinVariables = session_getSkinPreferences($skin);
    switch ($skin) {
        case 'zepu':
            $skinVariables['afterSearchBoxBanner'] = true;
            break;
        case 'polar':
            $wordCount = Definition::getWordCount();
            $wordCountRough = $wordCount - $wordCount % 10000;
            smarty_assign('words_total', util_formatNumber($wordCount, 0));
            smarty_assign('words_rough', util_formatNumber($wordCountRough, 0));
            smarty_assign('words_last_month', util_formatNumber(Definition::getWordCountLastMonth(), 0));
            break;
        case 'mobile':
            smarty_assign('words_total', util_formatNumber(Definition::getWordCount(), 0));
            smarty_assign('words_last_month', util_formatNumber(Definition::getWordCountLastMonth(), 0));
            break;
    }
    smarty_assign('skinVariables', $skinVariables);
    smarty_register_outputfilters();
    return $GLOBALS['smarty_theSmarty']->fetch("{$skin}/pageLayout.ihtml");
}

 public static function handle($uri)
 {
     $definitions = \Definition::all();
     // Polyfill
     if (!function_exists('array_column')) {
         function array_column($array, $column_name)
         {
             return array_map(function ($element) use($column_name) {
                 return $element[$column_name];
             }, $array);
         }
     }
     // Get unique properties
     $keywords = Definitions\KeywordController::getKeywordList($definitions);
     $languages = array_count_values(array_filter(array_column($definitions->toArray(), 'language')));
     $licenses = array_count_values(array_filter(array_column($definitions->toArray(), 'rights')));
     $themes = array_count_values(array_filter(array_column($definitions->toArray(), 'theme')));
     $publishers = array_count_values(array_filter(array_column($definitions->toArray(), 'publisher_name')));
     // Sort by "Popularity"
     // For alphabetical order: use ksort
     arsort($keywords);
     arsort($languages);
     arsort($licenses);
     arsort($themes);
     arsort($publishers);
     $view = \View::make('home')->with('title', 'Datasets | The Datatank')->with('page_title', 'Datasets')->with('keywords', $keywords)->with('languages', $languages)->with('licenses', $licenses)->with('themes', $themes)->with('publishers', $publishers)->with('definitions', $definitions);
     return \Response::make($view);
 }

 public static function deleteByLexemId($lexemId)
 {
     $ldms = LexemDefinitionMap::get_all_by_lexemId($lexemId);
     foreach ($ldms as $ldm) {
         Definition::updateModDate($ldm->definitionId);
         $ldm->delete();
     }
 }

 public function test()
 {
     $loader = new ResourceLoader();
     $definitions = new Definition($loader->load($this->source));
     foreach ($definitions->getExpectations() as $definition) {
         if (null !== $definition['type']) {
             $actual = $loader->getType($definition['uri']);
             if ($actual !== $definition['type']) {
                 throw new FailedExpectationException("Type mismatch for {$definition['uri']}. Got [{$actual}] but expected [{$definition['type']}]");
             }
         }
         $expectation = new Expectation($definition['expected']);
         if (!$expectation->assert($loader->load($definition['uri']))) {
             throw new FailedExpectationException(implode("\n", $expectation->getMessages()));
         }
     }
     return true;
 }

 public function process(ContainerBuilder $container)
 {
     $methods = $container->findTaggedServiceIds('knp_rad_prototype.method');
     foreach ($methods as $id => $tags) {
         foreach ($tags as $tag) {
             $tag = array_merge(['alias' => $tag['method'], 'domain' => null], $tag);
             $definition = new Definition('Knp\\Rad\\Prototype\\Prototype\\Method', [sprintf('@%s', $id), $tag['method']]);
             $definition->addTag('knp_rad_prototype.prototype_method', $tag);
             $name = sprintf('knp_rad_prototype.prototype.method.%s', Inflector::tableize($tag['alias']));
             $container->setDefinition($name, $definition);
         }
     }
     $methodContainer = $container->getDefinition('knp_rad_prototype.prototype.container');
     $methods = $container->findTaggedServiceIds('knp_rad_prototype.prototype_method');
     foreach ($methods as $id => $tags) {
         $tag = current($tags);
         $methodContainer->addMethodCall('addMethod', [$tag['alias'], new Reference($id), $tag['domain']]);
     }
 }

 /**
  * Adds a service
  *
  * @param string $id
  * @param Definition $definition
  * @return string
  */
 private function addService($id, $definition)
 {
     $code = "  {$id}:\n";
     if ($definition->getClass()) {
         $code .= sprintf("    class: %s\n", $definition->getClass());
     }
     $tagsCode = '';
     foreach ($definition->getTags() as $name => $tags) {
         foreach ($tags as $attributes) {
             $att = array();
             foreach ($attributes as $key => $value) {
                 $att[] = sprintf('%s: %s', Yaml::dump($key), Yaml::dump($value));
             }
             $att = $att ? ', ' . implode(' ', $att) : '';
             $tagsCode .= sprintf("      - { name: %s%s }\n", Yaml::dump($name), $att);
         }
     }
     if ($tagsCode) {
         $code .= "    tags:\n" . $tagsCode;
     }
     if ($definition->getFile()) {
         $code .= sprintf("    file: %s\n", $definition->getFile());
     }
     if ($definition->getFactoryMethod()) {
         $code .= sprintf("    factory_method: %s\n", $definition->getFactoryMethod());
     }
     if ($definition->getFactoryService()) {
         $code .= sprintf("    factory_service: %s\n", $definition->getFactoryService());
     }
     if ($definition->getArguments()) {
         $code .= sprintf("    arguments: %s\n", Yaml::dump($this->dumpValue($definition->getArguments()), 0));
     }
     if ($definition->getProperties()) {
         $code .= sprintf("    properties: %s\n", Yaml::dump($this->dumpValue($definition->getProperties()), 0));
     }
     if ($definition->getMethodCalls()) {
         $code .= sprintf("    calls:\n      %s\n", str_replace("\n", "\n      ", Yaml::dump($this->dumpValue($definition->getMethodCalls()), 1)));
     }
     if (ContainerInterface::SCOPE_CONTAINER !== ($scope = $definition->getScope())) {
         $code .= sprintf("    scope: %s\n", $scope);
     }
     if ($callable = $definition->getConfigurator()) {
         if (is_array($callable)) {
             if (is_object($callable[0]) && $callable[0] instanceof Reference) {
                 $callable = array($this->getServiceCall((string) $callable[0], $callable[0]), $callable[1]);
             } else {
                 $callable = array($callable[0], $callable[1]);
             }
         }
         $code .= sprintf("    configurator: %s\n", Yaml::dump($callable, 0));
     }
     return $code;
 }

 /**
  * __construct() - For concrete implementation of Zend_Db_Table
  *
  * @param string|array $config string can reference a \Zend\Registry key for a db adapter
  *                             OR it can reference the name of a table
  * @param array|\Zend\Db\Table\Definition $definition
  */
 public function __construct($config = array(), $definition = null)
 {
     if ($definition !== null && is_array($definition)) {
         $definition = new Definition($definition);
     }
     if (is_string($config)) {
         if (\Zend\Registry::isRegistered($config)) {
             trigger_error(__CLASS__ . '::' . __METHOD__ . '(\'registryName\') is not valid usage of Zend_Db_Table, ' . 'try extending Zend_Db_Table_Abstract in your extending classes.', E_USER_NOTICE);
             $config = array(self::ADAPTER => $config);
         } else {
             // process this as table with or without a definition
             if ($definition instanceof Definition && $definition->hasTableConfig($config)) {
                 // this will have DEFINITION_CONFIG_NAME & DEFINITION
                 $config = $definition->getTableConfig($config);
             } else {
                 $config = array(self::NAME => $config);
             }
         }
     }
     parent::__construct($config);
 }

function getSourcesForLexem($lexem)
{
    global $SOURCES;
    $defs = Definition::loadByLexemId($lexem->id);
    $sources = array();
    foreach ($defs as $def) {
        $shortName = $SOURCES[$def->sourceId]->shortName;
        if (!in_array($shortName, $sources)) {
            $sources[] = $shortName;
        }
    }
    return '(' . implode(',', $sources) . ')';
}

 public function testDeleteApi()
 {
     // Delete the published definition for each test csv file.
     foreach ($this->test_data as $file) {
         $this->updateRequest('DELETE');
         $controller = \App::make('Tdt\\Core\\Definitions\\DefinitionController');
         $response = $controller->handle("csv/{$file}");
         $this->assertEquals(200, $response->getStatusCode());
     }
     // Check if everything is deleted properly.
     $definitions_count = \Definition::all()->count();
     $csv_count = \CsvDefinition::all()->count();
     $this->assertTrue($csv_count == 0);
     $this->assertTrue($definitions_count == 0);
 }

 private function createDefinitions()
 {
     $definitionList = $this->document->getElementsByTagName('definition');
     foreach ($definitionList as $definition) {
         if ($definition->hasChildNodes()) {
             $definitionChildrenNode = $definition->childNodes;
             $definitionObj = new Definition();
             foreach ($definitionChildrenNode as $definitionChild) {
                 if ($definitionChild->nodeName == "name") {
                     $definitionName = $definitionChild->nodeValue;
                     $definitionObj->setName($definitionName);
                 }
                 if ($definitionChild->nodeName == "base") {
                     $definitionObj->setBase($definitionChild->nodeValue);
                 }
                 if ($definitionChild->nodeName == "put") {
                     $pageKey = "";
                     $value = "";
                     $role = "";
                     if ($definitionChild->hasAttribute('pageKey')) {
                         $pageKey = $definitionChild->getAttribute('pageKey');
                     }
                     if ($definitionChild->hasAttribute('value')) {
                         $value = $definitionChild->getAttribute('value');
                     }
                     if ($definitionChild->hasAttribute('role')) {
                         $role = $definitionChild->getAttribute('role');
                     }
                     $put = new Put($pageKey, $value, $role);
                     $definitionObj->addPut($put);
                 }
             }
             $this->addDefinition($definitionName, $definitionObj);
         }
     }
 }

 /**
  * Delete everything out of our testing database.
  */
 public static function tearDownAfterClass()
 {
     parent::tearDownAfterClass();
     \Definition::truncate();
     \CsvDefinition::truncate();
     \InstalledDefinition::truncate();
     \JsonDefinition::truncate();
     \ShpDefinition::truncate();
     \SparqlDefinition::truncate();
     \XlsDefinition::truncate();
     \XmlDefinition::truncate();
     \GeoProperty::truncate();
     \TabularColumns::truncate();
     \Geoprojection::truncate();
 }

function createLexemDefinitionMap()
{
    LexemDefinitionMap::deleteAll();
    $dbResult = db_selectAllConcepts();
    print "Migrating " . mysql_num_rows($dbResult) . " concepts...\n";
    $seen = 0;
    while ($dbRow = mysql_fetch_assoc($dbResult)) {
        $concept = new Concept();
        $concept->populateFromDbRow($dbRow);
        $words = Word::loadByConceptId($concept->id);
        $definitions = Definition::loadByConceptId($concept->id);
        if ($definitions) {
            // Select distinct words
            $distinctWords = array();
            foreach ($words as $word) {
                $distinctWords[$word->name] = 1;
            }
            // For every word, look up all the lexems. Then map each of those lexems
            // to every definition.
            foreach ($distinctWords as $word => $ignored) {
                $lexems = Lexem::loadByUnaccented($word);
                // Create lexem if necessary so that we don't lose any words during the
                // migration
                if (count($lexems) == 0) {
                    $lexem = Lexem::create($word, 'T', 1, '');
                    $lexem->save();
                    $lexem->id = db_getLastInsertedId();
                    $lexems[] = $lexem;
                    $lexem->regenerateParadigm();
                }
                foreach ($lexems as $lexem) {
                    foreach ($definitions as $definition) {
                        $ldm = LexemDefinitionMap::load($lexem->id, $definition->id);
                        if (!$ldm) {
                            $ldm = LexemDefinitionMap::create($lexem->id, $definition->id);
                            $ldm->save();
                        }
                    }
                }
            }
        }
        $seen++;
        if ($seen % 1000 == 0) {
            print "Seen: {$seen};\n";
        }
    }
    print "Seen: {$seen};\n";
}

 /**
  * Run the migrations.
  *
  * @return void
  */
 public function up()
 {
     Schema::table('definitions', function ($table) {
         $table->string('title', 255);
     });
     // Denormalize the definitions by copying the existing titles and descriptions
     foreach (\Definition::all() as $definition) {
         $source_model = new $definition->source_type();
         $source = $source_model->find($definition->source_id);
         if (!empty($source->title)) {
             $definition->title = $source->title;
         }
         if (!empty($source->description)) {
             $definition->description = $source->description;
         }
         $definition->save();
     }
 }

 /**
  * Run the migrations.
  *
  * @return void
  */
 public function up()
 {
     Schema::create('definition_facet_types', function ($table) {
         $table->increments('id');
         $table->string('facet_name', 255);
     });
     $facet_types = ['rights', 'keyword', 'language', 'theme', 'publisher_name'];
     $facet_type_models = [];
     foreach ($facet_types as $facet) {
         $facet_type = \FacetType::create(['facet_name' => $facet]);
         $facet_type->save();
         if ($facet != 'keyword') {
             $facet_type_model[$facet] = $facet_type;
         } else {
             $facet_type_model['keywords'] = $facet_type;
         }
     }
     Schema::create('definition_facets', function ($table) {
         $table->increments('id');
         $table->integer('definition_id');
         $table->integer('facet_id');
         $table->string('facet_name');
         $table->string('value');
     });
     // Copy all of the facet related info to the new definition_facets table
     $definitions = \Definition::all();
     foreach ($definitions as $definition) {
         foreach ($facet_type_models as $facet_name => $facet_type) {
             if ($facet_name != 'keywords' && !empty($definition->{$facet_name})) {
                 $facet = \Facet::create(['definition_id' => $definition->id, 'facet_id' => $facet_type->id, 'facet_name' => $facet_name, 'value' => $definition->{$facet_name}]);
                 $facet->save();
             } else {
                 // split the keywords
                 if (!empty($definition->keywords)) {
                     $keywords = explode(',', $definition->keywords);
                     foreach ($keywords as $keyword) {
                         $facet = \Facet::create(['definition_id' => $definition->id, 'facet_id' => $facet_type->id, 'facet_name' => 'keyword', 'value' => $keyword]);
                         $facet->save();
                     }
                 }
             }
         }
     }
 }

 /** Parses one definition line, i.e. extracts {{label}}, definition,
  * {{example|Quotation sentence.}}, creates and fills a meaning (WMeaning).
  * @param page_title    word which is described in this article 'text'
  * @param lang_section  language of this section of an article
  * @param line          definition line
  * @return WMeaning or null if the line is not started from "#" or = "# "
  */
 public static function parseOneDefinition($page_title, $lang_section, $line)
 {
     if (preg_match("/\\{\\{Нужен перевод\\}\\}/", $line)) {
         return null;
     }
     // remove empty quotations: {{пример|}} and {{пример}}
     $line = preg_replace("/\\{\\{пример\\|\\}\\}/", "", $line);
     $line = preg_replace("/\\{\\{пример\\}\\}/", "", $line);
     $line = preg_replace("/\\{\\{пример перевод\\|\\}\\}/", "", $line);
     // todo check - does exist this example
     $line = preg_replace("/\\[\\[\\]\\]/", "", $line);
     // empty definition
     $line = Definition::stripNumberSign($page_title, $line);
     if (0 == strlen($line)) {
         return null;
     }
     if (preg_match("/\\A\\{\\{морфема/", $line)) {
         return null;
     }
     // skip now, todo (parse) in future
     $label_text = LabelRu . extractLabelsTrimText(line);
     if (null == label_text) {
         return null;
     }
     /*
             $line = label_text.getText();
             
             // 2. extract text till first {{пример|
             String wiki_definition = WQuoteRu.getDefinitionBeforeFirstQuote(page_title, line);
     
             // 3. parsing wiki-text
             //StringBuffer definition = WikiWord.parseDoubleBrackets(page_title, new StringBuffer(wiki_definition));
     
             // 4. extract wiki-links (internal links)
             //WikiWord[] ww = WikiWord.getWikiWords(page_title, new StringBuffer(wiki_definition));
     
             // 5. extract quotations
             WQuote[] quote = WQuoteRu.getQuotes(page_title, line);        
     
             return new WMeaning(page_title, label_text.getLabels(), wiki_definition, quote, false);
     */
 }