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, $replace = array())
 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             // is the replace file exist?
 196             if (!isset($replace[$iniCache]) || $replace[$iniCache] != md5_file($iniCacheTmp)) {
 197
 198
 199                 if (file_exists($iniCache)) {
 200                     unlink($iniCache);
 201                 }
 202                 $ff->debug("Writing merged ini file : $iniCache\n");
 203                 rename($iniCacheTmp, $iniCache);
 204             } else {
 205                 touch($iniCache);
 206             }
 207         }
 208         /*
 209         // readers..??? not needed??? (historical)
 210         if (file_exists($iniCacheTmp.'.reader') &&  filesize($iniCacheTmp.'.reader')) {
 211             if (file_exists($iniCache.'.reader')) {
 212                 unlink($iniCache.'.reader');
 213             }
 214             $ff->debug("Writing merged reader file : $iniCache.reader\n");
 215             rename($iniCacheTmp.'.reader', $iniCache.'.reader');
 216         }
 217         */
 218
 219         // merge and set links.. test for generated links file..
 220
 221         $linksCacheTmp = preg_replace('/\.ini/', '.links.ini', $iniCacheTmp );
 222         $links = array();
 223         if (file_exists($linksCacheTmp )) {
 224             $links = self::mergeIni( parse_ini_file($linksCacheTmp, true), $links);
 225             unlink($linksCacheTmp);
 226         }
 227         // we are going to use the DataObject directories..
 228
 229         $inis = explode(PATH_SEPARATOR,$ff->PDO_DataObject['class_location']);
 230         //print_r($inis);exit;
 231         $ff->debug("class_location = ". $ff->PDO_DataObject['class_location']);
 232
 233
 234         $lproject = strtolower(explode('/', $ff->project)[0]);
 235
 236         foreach($inis as $path) {
 237             $ini = $path . '/'. strtolower( $lproject ) . '.links.ini';
 238              //var_dump($ini);
 239             if (!file_exists($ini)) {
 240                 $ff->debug("Framework Generator:writeCache PROJECT.links.ini does not exist in $path - trying glob");
 241
 242                 // try scanning the directory for another ini file..
 243                 $ar = glob(dirname($ini).'/*.links.ini');
 244
 245
 246                 if (empty($ar)) {
 247                     continue;
 248                 }
 249
 250
 251                 sort($ar);
 252                 $ff->debug("Framework Generator:writeCache using {$ar[0]}");
 253
 254                 // first file.. = with links removed..
 255                 $ini = preg_replace('/\.links\./' , '.', $ar[0]);
 256                 $ini = preg_replace('/\.ini$/', '.links.ini', $ini);
 257             }
 258
 259             // why do this twice???
 260             if (!file_exists($ini)) {
 261                 continue;
 262             }
 263             $ff->debug("Adding in $ini");
 264             // prefer first ?
 265             $links = self::mergeIni( parse_ini_file($ini, true), $links);
 266         }
 267         $iniLinksCache = preg_replace('/\.ini$/', '.links.ini', $iniCache);
 268         $out = array();
 269         foreach($links as $tbl=>$ar) {
 270             $out[] = '['. $tbl  .']';
 271             foreach ($ar as $k=>$v) {
 272                 $out[] = $k . '=' .$v;
 273             }
 274             $out[] = '';
 275         }
 276         if (count($out)) {
 277             $ff->debug("Writing merged Links file : $iniLinksCache \n");
 278             $out_str = implode("\n", $out);
 279             // is target file different?
 280             if (!isset($replace[$iniLinksCache]) || $replace[$iniLinksCache] != md5($out)) {
 281
 282                  file_put_contents($iniCacheTmp. '.links.ini', $out_str);
 283                  if (file_exists($iniLinksCache)) {
 284                      unlink($iniLinksCache);
 285                  }
 286                  rename($iniCacheTmp. '.links.ini', $iniLinksCache);
 287             } else {
 288                 touch($iniLinksCache);
 289
 290             }
 291         } // we ignore that we might need to delete old links.ini
 292
 293         flock($fp, LOCK_UN);
 294         fclose($fp);
 295
 296         clearstatcache();
 297
 298         if(file_exists($iniCache.".lock")){
 299             unlink($iniCache.".lock");
 300         }
 301
 302     }
 303     /* bit like merge recursive, but it avoids doing stuff with arrays.. */
 304     static function mergeIni($new, $old)
 305     {
 306         foreach($new as $g => $ar) {
 307             if (!isset($old[$g])) {
 308                 $old[$g] = $ar;
 309                 continue;
 310             }
 311             foreach($ar as $k=>$v) {
 312                 if (isset($old[$g][$k])) {
 313                     continue;
 314                 }
 315                 $old[$g][$k] = $v;
 316             }
 317         }
 318         return $old;
 319
 320
 321     }
 322
 323 }