Changeset 19017 for lang/php

Timestamp:

09/09/08 00:44:36 (2 months ago)

Author:

nowelium

Message:

 

Location:

lang/php/misc/Hermit

Files:

• example/employee/hoge.php (modified) (2 diffs)
• example/example.php (added)
• src/Hermit/Hermit.php (modified) (3 diffs)
• src/Hermit/HermitAutoloader.php (modified) (1 diff)
• src/Hermit/HermitDao.php (modified) (1 diff)
• src/Hermit/HermitStatementBuilder.php (added)
• src/Hermit/command (added)
• src/Hermit/command/HermitSqlCommand.php (added)
• src/Hermit/command/HermitSqlCommandFactory.php (added)
• src/Hermit/creator (added)
• src/Hermit/creator/HermitAnnotationSqlCreator.php (added)
• src/Hermit/creator/HermitAutoInsertSqlCreator.php (added)
• src/Hermit/creator/HermitAutoSelectSqlCreator.php (added)
• src/Hermit/creator/HermitAutoUpdateSqlCreator.php (added)
• src/Hermit/creator/HermitSqlCreator.php (added)
• src/Hermit/meta (added)
• src/Hermit/proxy/HermitClassProxy.php (added)
• src/Hermit/proxy/HermitFutureProxy.php (modified) (1 diff)
• src/Hermit/proxy/HermitInterfaceProxy.php (modified) (4 diffs)
• src/Hermit/proxy/HermitProxy.php (modified) (1 diff)

lang/php/misc/Hermit/example/employee/hoge.php

@@ -2 +2 @@
 
 require dirname(__FILE__) . '/../example.php';
+HermitAutoloader::import(dirname(__FILE__));
+HermitAutoloader::import(dirname(__FILE__) . '/dao');
 
 class Hoge {
@@ -16 +18 @@
 }
 
+Hermit::bind('Hoge', 'EmployeeDao');
 $pdo = new PDO('sqlite:' . dirname(__FILE__) . '/resource/employee.db');
 $hoge = new Hoge;

lang/php/misc/Hermit/src/Hermit/Hermit.php

@@ -4 +4 @@
  * @author nowelium
  */
-class Hermit {
-    public static $classMap = array(
-        'Hoge' => 'EmployeeDao'
-    );
+abstract class Hermit {
+    public static $classMap = array();
+    public static function bind($targetClass, $dao){
+        self::$classMap[$targetClass] = $dao;
+    }
     public static function create(PDO $pdo, $class = null){
         if(is_null($class)){
@@ -15 +16 @@
         }
         if(is_object($class)){
-            return HermitProxy::delegateInstance($pdo, $class);
+            return HermitClassProxy::delegate($pdo, new ReflectionObject($class), $class);
         }
         if(isset(Hermit::$classMap[$class])){
@@ -27 +28 @@
     protected static function createProxy(PDO $pdo, $targetClass){
         $reflector = new ReflectionClass($targetClass);
-        /*
-        if($reflector->implementsInterface('HermitDao')){
-            $instance = $reflector->newInstance();
-            $instance->setPDO($pdo);
-            return HermitProxy::delegateInstance($pdo, $instance);
-        }
-        */
         if($reflector->isInterface()){
             return HermitInterfaceProxy::delegate($pdo, $reflector);
         }
-        return HermitFutureProxy::delegate($pdo, $targetClass);
+        return HermitFutureProxy::delegate($pdo, $reflector, $targetClass);
     }
 }

lang/php/misc/Hermit/src/Hermit/HermitAutoloader.php

@@ -2 +2 @@
 
 class HermitAutoloader {
+    private static $classPath = array(
+        '/',
+        '/annote',
+        '/parameter',
+        '/proxy',
+        '/meta',
+        '/creator',
+        '/command'
+    );
+    private static $userClassPath = array();
+    private static $unmatch = array();
+    private static $current;
+    public static function initialize(){
+        self::$current = dirname(__FILE__);
+        spl_autoload_register(array(__CLASS__, 'autoload'));
+    }
+    public static function import($dir){
+        self::$userClassPath[] = $dir;
+    }
+    public static function autoload($className){
+        if(self::classload(self::$classPath, $className, self::$current)){
+            return true;
+        }
+        if(self::classload(self::$userClassPath, $className)){
+            return true;
+        }
+        return false;
+    }
+    protected static function classload(array $pathes, $className, $prefix = ''){
+        $file = $className . '.php';
+        foreach($pathes as $path){
+            $filePath = $prefix . $path . DIRECTORY_SEPARATOR . $file;
+            if(isset(self::$unmatch[$filePath]) && self::$unmatch[$filePath]){
+                continue;
+            }
+            if(file_exists($filePath)){
+                require $filePath;
+                return true;
+            }
+            self::$unmatch[$filePath] = true;
+        }
+        return false;
+    }
 }
+
+HermitAutoloader::initialize();

lang/php/misc/Hermit/src/Hermit/HermitDao.php

@@ -5 +5 @@
  */
 interface HermitDao {
-    public function setPDO(PDO $pdo);
 }

lang/php/misc/Hermit/src/Hermit/proxy/HermitFutureProxy.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitFutureProxy {
-    protected $pdo;
-    protected $target;
-    public static function delegate(PDO $pdo, $target){
-        $this->pdo = $pdo;
-        $this->target = $target;
+class HermitFutureProxy implements HermitProxy {
+    public static function delegate(PDO $pdo, ReflectionClass $reflector, $target = null){
     }
 }

lang/php/misc/Hermit/src/Hermit/proxy/HermitInterfaceProxy.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitInterfaceProxy {
+class HermitInterfaceProxy implements HermitProxy {
     protected $pdo;
     protected $reflector;
@@ -11 +11 @@
         $this->pdo = $pdo;
     }
-    public static function delegate(PDO $pdo, ReflectionClass $reflector){
+    public static function delegate(PDO $pdo, ReflectionClass $reflector, $instance = null){
         return new self($reflector, $pdo);
     }
@@ -23 +23 @@
         switch(true){
         case $annote->hasSql($name):
-            return $this->execute($method, $annote->getSql($name));
+            return $this->execute($method, $params, $annote->getSql($name));
         case $annote->hasQuery($name):
             $sql = 'SELECT * FROM ' . $annote->getTable() . ' WHERE ' . $annote->getQuery($name);
-            return $this->execute($method, $sql);
+            return $this->execute($method, $params, $sql);
         case $annote->hasFile($name):
-            return $this->execute($method, $annote->getFile($name));
+            return $this->execute($method, $params, $annote->getFile($name));
         case $annote->hasPath($name):
-            return $this->execute($method, $annote->getPath($name));
+            return $this->execute($method, $params, $annote->getPath($name));
         case $annote->hasDelegate($name);
             break;
@@ -36 +36 @@
         throw new BadMethodCallException($this->reflector->getName() . '::' . $name);
     }
-    protected static function execute(ReflectionMethod $method, $sql){
-        $stmt = HermitSqlBuilder::prepare($this->pdo, $method, $sql);
+    protected function execute(ReflectionMethod $method, $params, $sql){
+        $stmt = HermitStatementBuilder::prepare($this->pdo, $method, $sql);
         $stmt->execute($params);
         return HermitResultSet::create($stmt, $method);

lang/php/misc/Hermit/src/Hermit/proxy/HermitProxy.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitProxy {
-    protected $target;
-    protected $pdo;
-    protected function __construct(ReflectionClass $reflector, $targetClass, PDO $pdo = null){
-        $this->target = $targetClass;
-        $this->reflector = $reflector;
-        $this->pdo = $pdo;
-    }
-    public static function delegateInstance(PDO $pdo, $instance){
-        return new self(new ReflectionObject($reflector), $instance, $pdo);
-    }
-    public function __call($name, $params = array()){
-        $annote = HermitAnnote::create($this->reflector);
-        if($annote->hasMethod($name, true)){
-            $method = $annote->getMethod($name);
-            return $method->invokeArgs($this->target, $params);
-        }
-        switch(true){
-        case $annote->hasSql($name):
-            break;
-        case $annote->hasQuery($name):
-            break;
-        case $annote->hasFile($name):
-            break;
-        case $annote->hasPath($name):
-            break;
-        case $annote->hasDelegate($name):
-            break;
-        }
-        throw new BadMethodCallException(get_class($this->target) . '::' . $name);
-    }
+interface HermitProxy extends HermitDao {
+    public static function delegate(PDO $pdo, ReflectionClass $reflector, $instance = null);
 }