git.roojs.org Git - pear/blob - HTML/FlexyFramework2/Generator.php

   1 <?php
   2
   3
   4 /**
   5  * This works by creating '_generate** methods, which are called by start()
   6  *
   7  */
   8
   9 require_once 'PDO/DataObject/Generator.php';
  10
  11
  12 class HTML_FlexyFramework2_Generator extends PDO_DataObject_Generator
  13 {
  14     // block class generation.
  15     static $generateClasses = false;
  16
  17     function generateClasses()
  18     {
  19 //        echo "GENERATE CLASSES?";
  20         if (!HTML_FlexyFramework2_Generator::$generateClasses ) {
  21             return;
  22         }
  23
  24         //echo "GENERATE CLASSES?";
  25         parent::generateClasses();
  26     }
  27
  28
  29     function generateReaders()
  30     {
  31         $options = PDO_DataObject::config();
  32
  33         $out = array();
  34         foreach($this->tables as $table) {
  35
  36             $out = array_merge($out, $this->_generateReader($table));
  37
  38
  39         }
  40
  41         file_put_contents($options["schema_location"] . '.reader', serialize($out));
  42
  43     }
  44
  45     function generatePhp ()
  46     {
  47         // NOOP
  48     }
  49
  50     /**
  51      * Generate the cached readers used for meta data in the queries.
  52      *
  53      */
  54     function _generateReader($table)
  55     {
  56         $DB = $this->PDO();
  57         $dbtype = $DB->getAttribute(PDO::ATTR_DRIVER_NAME);;
  58
  59         $ret = array();
  60         foreach($table->columns as $t) {
  61              switch (strtoupper($t->type)) {
  62
  63                 case 'INT':
  64                 case 'INT2':    // postgres
  65                 case 'INT4':    // postgres
  66                 case 'INT8':    // postgres
  67                 case 'SERIAL4': // postgres
  68                 case 'SERIAL8': // postgres
  69                 case 'INTEGER':
  70                 case 'TINYINT':
  71                 case 'SMALLINT':
  72                 case 'MEDIUMINT':
  73                 case 'BIGINT':
  74                 // wierd ones..
  75                 case 'YEAR':
  76
  77                     $ret[$table->table.'.'.$t->name] = array('type' => 'int');
  78                     continue 2;
  79
  80                 case 'REAL':
  81                 case 'DOUBLE':
  82                 case 'DOUBLE PRECISION': // double precision (firebird)
  83                 case 'FLOAT':
  84                 case 'FLOAT4': // real (postgres)
  85                 case 'FLOAT8': // double precision (postgres)
  86                 case 'DECIMAL':
  87                 case 'MONEY':  // mssql and maybe others
  88                 case 'NUMERIC':
  89                 case 'NUMBER': // oci8
  90                     $ret[$table->table.'.'.$t->name] = array('type' => 'float'); //???
  91                     break;
  92
  93                 case 'BIT':
  94                 case 'BOOL':
  95                 case 'BOOLEAN':
  96                     $ret[$table->table.'.'.$t->name] = array('type' => 'boolean'); //???
  97                     // postgres needs to quote '0'
  98                     if ($dbtype == 'pgsql') {
  99                         ///$type +=  DB_DATAOBJECT_STR;
 100                     }
 101                     break;
 102
 103                 case 'STRING':
 104                 case 'CHAR':
 105                 case 'VARCHAR':
 106                 case 'VARCHAR2':
 107                 case 'TINYTEXT':
 108
 109                 case 'ENUM':
 110                 case 'SET':         // not really but oh well
 111
 112                 case 'POINT':       // mysql geometry stuff - not really string - but will do..
 113
 114                 case 'TIMESTAMPTZ': // postgres
 115                 case 'BPCHAR':      // postgres
 116                 case 'INTERVAL':    // postgres (eg. '12 days')
 117
 118                 case 'CIDR':        // postgres IP net spec
 119                 case 'INET':        // postgres IP
 120                 case 'MACADDR':     // postgress network Mac address.
 121
 122                 case 'INTEGER[]':   // postgres type
 123                 case 'BOOLEAN[]':   // postgres type
 124
 125
 126                 case 'TEXT':
 127                 case 'MEDIUMTEXT':
 128                 case 'LONGTEXT':
 129                 case 'BLOB':       /// these should really be ignored!!!???
 130                 case 'TINYBLOB':
 131                 case 'MEDIUMBLOB':
 132                 case 'LONGBLOB':
 133
 134                 case 'CLOB': // oracle character lob support
 135
 136                 case 'BYTEA':   // postgres blob support..
 137                     $ret[$table->table.'.'.$t->name] =  $t->name; // strings are not sent as arrays..
 138                    // $type = DB_DATAOBJECT_STR;
 139                     break;
 140
 141
 142
 143
 144                 case 'DATE':
 145                     $ret[$table->table.'.'.$t->name] = array('type' => 'date', 'dateFormat' => 'Y-m-d'); //???
 146                     break;
 147
 148                 case 'TIME':
 149                     $ret[$table->table.'.'.$t->name] = $t->name; // technically not...
 150                     break;
 151
 152
 153                 case 'DATETIME':
 154                     $ret[$table->table.'.'.$t->name] = array('type' => 'date', 'dateFormat' => 'Y-m-d H:i:s'); //???
 155                     break;
 156
 157                 case 'TIMESTAMP': // do other databases use this???
 158
 159                     $ret[$table->table.'.'.$t->name] =   ($dbtype == 'mysql') ?
 160                          array('type' => 'float') :
 161                         array('type' => 'date', 'dateFormat' => 'Y-m-d H:i:s');
 162                     break;
 163
 164
 165
 166
 167
 168                 default:
 169                     $ret[$table->table.'.'.$t->name] = $t->name;
 170                     break;
 171             }
 172         }
 173
 174         return $ret;
 175
 176
 177     }
 178     /**
 179      * Generate the cached *.ini and links.ini files (merged for all components)
 180      *
 181      */
 182     static function writeCache($iniCacheTmp, $iniCache)
 183     {
 184
 185         $fp = fopen($iniCache.".lock", "a+");
 186         flock($fp,LOCK_EX);
 187
 188         $ff = HTML_FlexyFramework2::get();
 189         $ff->debug('Framework Generator:writeCache ' . $iniCacheTmp .  ' ' . $iniCache);
 190
 191         //var_dump($iniCacheTmp);
 192        // echo '<PRE>';echo file_get_contents($iniCacheTmp);exit;
 193         // only unpdate if nothing went wrong.
 194         if (file_exists($iniCacheTmp) && filesize($iniCacheTmp)) {
 195             if (file_exists($iniCache)) {
 196                 unlink($iniCache);
 197             }
 198             $ff->debug("Writing merged ini file : $iniCache\n");
 199             rename($iniCacheTmp, $iniCache);
 200         }
 201
 202         // readers..??? not needed??? (historical)
 203         if (file_exists($iniCacheTmp.'.reader') &&  filesize($iniCacheTmp.'.reader')) {
 204             if (file_exists($iniCache.'.reader')) {
 205                 unlink($iniCache.'.reader');
 206             }
 207             $ff->debug("Writing merged reader file : $iniCache.reader\n");
 208             rename($iniCacheTmp.'.reader', $iniCache.'.reader');
 209         }
 210
 211
 212         // merge and set links.. test for generated links file..
 213
 214         $linksCacheTmp = preg_replace('/\.ini/', '.links.ini', $iniCacheTmp );
 215         $links = array();
 216         if (file_exists($linksCacheTmp )) {
 217             $links = self::mergeIni( parse_ini_file($linksCacheTmp, true), $links);
 218             unlink($linksCacheTmp);
 219         }
 220         // we are going to use the DataObject directories..
 221
 222         $inis = explode(PATH_SEPARATOR,$ff->PDO_DataObject['class_location']);
 223         //print_r($inis);exit;
 224         $ff->debug("class_location = ". $ff->PDO_DataObject['class_location']);
 225
 226
 227         $lproject = strtolower(explode('/', $ff->project)[0]);
 228
 229         foreach($inis as $path) {
 230             $ini = $path . '/'. strtolower( $lproject ) . '.links.ini';
 231              //var_dump($ini);
 232             if (!file_exists($ini)) {
 233                 $ff->debug("Framework Generator:writeCache PROJECT.links.ini does not exist in $path - trying glob");
 234
 235                 // try scanning the directory for another ini file..
 236                 $ar = glob(dirname($ini).'/*.links.ini');
 237
 238
 239                 if (empty($ar)) {
 240                     continue;
 241                 }
 242
 243
 244                 sort($ar);
 245                 $ff->debug("Framework Generator:writeCache using {$ar[0]}");
 246
 247                 // first file.. = with links removed..
 248                 $ini = preg_replace('/\.links\./' , '.', $ar[0]);
 249                 $ini = preg_replace('/\.ini$/', '.links.ini', $ini);
 250             }
 251
 252             // why do this twice???
 253             if (!file_exists($ini)) {
 254                 continue;
 255             }
 256             $ff->debug("Adding in $ini");
 257             // prefer first ?
 258             $links = self::mergeIni( parse_ini_file($ini, true), $links);
 259         }
 260         $iniLinksCache = preg_replace('/\.ini$/', '.links.ini', $iniCache);
 261         $out = array();
 262         foreach($links as $tbl=>$ar) {
 263             $out[] = '['. $tbl  .']';
 264             foreach ($ar as $k=>$v) {
 265                 $out[] = $k . '=' .$v;
 266             }
 267             $out[] = '';
 268         }
 269         if (count($out)) {
 270             $ff->debug("Writing merged Links file : $iniLinksCache \n");
 271
 272
 273             file_put_contents($iniCacheTmp. '.links.ini', implode("\n", $out));
 274             if (file_exists($iniLinksCache)) {
 275                 unlink($iniLinksCache);
 276             }
 277             rename($iniCacheTmp. '.links.ini', $iniLinksCache);
 278         }
 279
 280         flock($fp, LOCK_UN);
 281         fclose($fp);
 282
 283         clearstatcache();
 284
 285         if(file_exists($iniCache.".lock")){
 286             unlink($iniCache.".lock");
 287         }
 288
 289     }
 290     /* bit like merge recursive, but it avoids doing stuff with arrays.. */
 291     static function mergeIni($new, $old)
 292     {
 293         foreach($new as $g => $ar) {
 294             if (!isset($old[$g])) {
 295                 $old[$g] = $ar;
 296                 continue;
 297             }
 298             foreach($ar as $k=>$v) {
 299                 if (isset($old[$g][$k])) {
 300                     continue;
 301                 }
 302                 $old[$g][$k] = $v;
 303             }
 304         }
 305         return $old;
 306
 307
 308     }
 309
 310 }