Changeset 19344 for lang/php

Timestamp:

09/16/08 01:32:33 (2 months ago)

Author:

nowelium

Message:

 

Location:

lang/php/misc/Hermit/src/Hermit

Files:

• Hermit.php (modified) (1 diff)
• HermitAutoloader.php (modified) (2 diffs)
• HermitDao.php (modified) (1 diff)
• HermitDaoManager.php (added)
• HermitDataSourceManager.php (added)
• HermitListener.php (added)
• HermitTransactionManager.php (added)
• command/HermitSqlCommandFactory.php (modified) (2 diffs)
• hoge.php (added)
• proxy/HermitClassProxy.php (modified) (1 diff)
• proxy/HermitFutureProxy.php (modified) (1 diff)
• proxy/HermitInterfaceProxy.php (modified) (1 diff)
• proxy/HermitProxy.php (modified) (1 diff)
• responder (added)
• responder/HermitResponder.php (added)
• resultset (added)
• resultset/HermitProcedureResultSet.php (added)
• resultset/HermitResultSet.php (added)
• statement (added)
• statement/HermitStatement.php (added)
• statement/HermitStatementBuilder.php (added)
• tx (added)
• tx/AbstractHermitTx.php (added)
• tx/HermitMandatoryTx.php (added)
• tx/HermitNeverTx.php (added)
• tx/HermitRequiredTx.php (added)
• tx/HermitRequiresNewTx.php (added)
• tx/HermitTx.php (added)
• tx/HermitTxRule.php (added)

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

@@ -4 +4 @@
  * @author nowelium
  */
-abstract class Hermit {
-    public static $classMap = array();
-    public static function bind($targetClass, $dao){
-        self::$classMap[$targetClass] = $dao;
+class Hermit {
+    protected $listeners = array();
+    protected $delegaters = array();
+
+    public function __construct($class){
+        $this->proxy = self::__create($class);
     }
-    public static function create(PDO $pdo, $class = null){
-        if(is_null($class)){
-            $e = new Exception;
-            $trace = $e->getTrace();
-            return Hermit::create($pdo, $trace[1]['class']);
+    public function __call($name, $parameters = array()){
+        if(isset($this->delegater[$name])){
+            return self::__request($this->delegater[$name], $name, $parameters);
         }
+        return self::__request($this->proxy, $name, $parameters);
+    }
+    protected static function __request(Hermit $hermit, $name, array $params){
+        return $hermit->request($name, $params);
+    }
+    protected static function __create($class){
         if(is_object($class)){
-            return HermitClassProxy::delegate($pdo, new ReflectionObject($class), $class);
+            return HermitObjectProxy::delegate(new ReflectionObject($class), $class);
         }
         if(isset(Hermit::$classMap[$class])){
-            return self::createProxy($pdo, Hermit::$classMap[$class]);
+            return self::__createProxy(Hermit::$classMap[$class]);
         }
         if(class_exists($class)){
-            return self::create($pdo, $class);
+            return self::__createProxy($class);
         }
-        throw new InvalidArgumentException('nosuch class: ' . $class);
+        throw new RuntimeException('Hermit does not create: ' . $class);
     }
-    protected static function createProxy(PDO $pdo, $targetClass){
+    protected static function __createProxy($targetClass){
         $reflector = new ReflectionClass($targetClass);
         if($reflector->isInterface()){
-            return HermitInterfaceProxy::delegate($pdo, $reflector);
+            return HermitInterfaceProxy::delegate($reflector);
         }
-        return HermitFutureProxy::delegate($pdo, $reflector, $targetClass);
+        return HermitClassProxy::delegate($reflector);
     }
 }
+

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

@@ -1 +1 @@
 <?php
 
+/**
+ * @author nowelium
+ */
 class HermitAutoloader {
     private static $classPath = array(
@@ -9 +12 @@
         '/meta',
         '/creator',
-        '/command'
+        '/command',
+        '/statement',
+        '/resultset',
+        '/responder',
+        '/tx'
     );
     private static $userClassPath = array();

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

@@ -2 +2 @@
 
 /**
- * @authro nowelium
+ * @author nowelium
  */
 interface HermitDao {

lang/php/misc/Hermit/src/Hermit/command/HermitSqlCommandFactory.php

@@ -1 +1 @@
 <?php
 
+/**
+ * @author nowelium
+ */
 class HermitSqlCommandFactory {
     protected $annote;
     protected $reflector;
-    protected $hasCommand = array();
+    protected $createdCommands = array();
     public function __construct(ReflectionClass $reflector){
         $this->annote = HermitAnnote::create($reflector);
@@ -13 +16 @@
     }
     public function getCommand($methodName){
-        $command = new HermitSqlCommand;
-
-        return $command;
+        $method = $this->annote->getMethod($methodName);
+        $methodId = spl_object_hash($method);
+        if(isset($this->createdCommands[$methodId])){
+            return $this->createdCommands[$methodId];
+        }
+        $command = $this->createCommand($method);
+        return $this->createdCommands[$methodId] = $command;
+    }
+    protected function createCommand(ReflectionMethod $method){
+        if($this->annote->isInsertMethod($methodName)){
+            return $this->createInsertCommand($method);
+        }
+        if($this->annote->isUpdateMethod($methodName)){
+            return $this->createUpdateCommand($method);
+        }
+        if($this->annote->isDeleteMethod($methodName)){
+            return $this->createDeleteCommand($method);
+        }
+        return $this->createSelectCommand($method);
+    }
+    protected function createInsertCommand(ReflectionMethod $method){
+    }
+    protected function createUpdateCommand(ReflectionMethod $method){
+    }
+    protected function createSelectCommand(ReflectionMethod $method){
+        $creator = $this->createSelectSqlCreator($method->getName());
+        return new HermitSelectCommand($method, $creator);
+    }
+    protected function createSelectSqlCreator($name){
+        switch(true){
+        case $this->annote->hasSql($name):
+            return new HermitStaticSqlCreator($this->annote->getSql($name));
+        case $this->annote->hasFile($name):
+            return new HermitStaticSqlCreator($this->annote->getFile($name));
+        case $this->annote->hasPath($name):
+            return new HermitStaticSqlCreator($this->annote->getPath($name));
+        case $this->annote->hasQuery($name):
+            $creator = new HermitAutoSelectCreator;
+            $creator->addQuery($this->annote->getQuery());
+            return $creator;
+        }
+        throw new BadMethodCallException('invalid method:' . $name);
     }
 }

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

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitClassProxy implements HermitDao {
-    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 delegate(PDO $pdo, ReflectionClass $reflector, $instance = null){
-        return new self($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);
-        }
-        throw new BadMethodCallException(get_class($this->target) . '::' . $name);
+class HermitClassProxy implements HermitProxy {
+    public function request($name, array $params){
     }
 }

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

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

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

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitInterfaceProxy implements HermitProxy {
-    protected $pdo;
+class HermitInterfaceProxy implements HermitFutureProxy {
     protected $reflector;
-    protected function __construct(ReflectionClass $reflector, $pdo){
+    protected $commandFactory;
+    protected function __construct(ReflectionClass $reflector){
         $this->reflector = $reflector;
-        $this->pdo = $pdo;
+        $this->commandFactory = new HermitSqlCommandFactory($reflector);
     }
-    public static function delegate(PDO $pdo, ReflectionClass $reflector, $instance = null){
-        return new self($reflector, $pdo);
+    public static function delegate(ReflectionClass $reflector, $instance = null){
+        return new self($reflector);
     }
-    public function __call($name, $params = array()){
-        $annote = HermitAnnote::create($this->reflector);
-        if(!$annote->hasMethod($name)){
+    public function request($name, array $params){
+        if(!$this->commandFactory->hasCommand($name)){
             throw new BadMethodCallException($this->reflector->getName() . '::' . $name);
         }
-
-        $method = $annote->getMethod($name);
-        switch(true){
-        case $annote->hasSql($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, $params, $sql);
-        case $annote->hasFile($name):
-            return $this->execute($method, $params, $annote->getFile($name));
-        case $annote->hasPath($name):
-            return $this->execute($method, $params, $annote->getPath($name));
-        case $annote->hasDelegate($name);
-            break;
-        }
-        throw new BadMethodCallException($this->reflector->getName() . '::' . $name);
-    }
-    protected function execute(ReflectionMethod $method, $params, $sql){
-        $stmt = HermitStatementBuilder::prepare($this->pdo, $method, $sql);
-        $stmt->execute($params);
-        return HermitResultSet::create($stmt, $method);
+        $command = $this->commandFactory->getCommand($name);
+        return $command->execute($pdo, $params);
     }
 }

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

@@ -5 +5 @@
  */
 interface HermitProxy extends HermitDao {
-    public static function delegate(PDO $pdo, ReflectionClass $reflector, $instance = null);
+    public function request($name, array $parameters);
 }