Changeset 19426

Timestamp:

09/17/08 13:55:47 (5 years ago)

Author:

nowelium

Message:

 

Location:

lang/php/misc/Hermit/src/Hermit

Files:

• Hermit.php (modified) (1 diff)
• HermitAutoloader.php (modified) (1 diff)
• annote/HermitAnnote.php (modified) (1 diff)
• annote/HermitAnnoteConst.php (modified) (2 diffs)
• command/HermitDeleteCommand.php (added)
• command/HermitInsertCommand.php (added)
• command/HermitSelectCommand.php (modified) (1 diff)
• command/HermitSqlCommand.php (modified) (1 diff)
• command/HermitSqlCommandFactory.php (modified) (3 diffs)
• command/HermitUpdateCommand.php (added)
• creator/HermitSqlCreator.php (modified) (1 diff)
• creator/HermitStaticSqlCreator.php (modified) (1 diff)
• proxy/HermitInterfaceProxy.php (modified) (1 diff)
• statement/HermitStatementBuilder.php (modified) (1 diff)

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

@@ -7 +7 @@
     protected $listeners = array();
     protected $delegaters = array();
-
     public function __construct($class){
         $this->proxy = self::__create($class);

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

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitAutoloader {
+abstract class HermitAutoloader {
     private static $classPath = array(
         '/',

lang/php/misc/Hermit/src/Hermit/annote/HermitAnnote.php

@@ -11 +11 @@
     public abstract function hasMethod($name);
     public abstract function getMethod($name);
-    public abstract function hasSql($name);
-    public abstract function getSql($name, $instance = null);
-    public abstract function hasQuery($name);
-    public abstract function getQuery($name, $instance = null);
-    public abstract function hasFile($name);
-    public abstract function getFile($name, $instance = null);
-    public abstract function hasPath($name);
-    public abstract function getPath($name, $instance = null);
-    public abstract function hasDelegate($name);
-    public abstract function getDelegate($name, $instance = null);
+    public abstract function isProcedureMethod(ReflectionMethod $method);
+    public abstract function isInsertMethod(ReflectionMethod $method);
+    public abstract function isUpdateMethod(ReflectionMethod $method);
+    public abstract function isDeleteMethod(ReflectionMethod $method);
+    public abstract function getProcedure(ReflectionMethod $method);
+    public abstract function getSql(ReflectionMethod $method, $suffix = null);
+    public abstract function getFile(ReflectionMethod $method);
+    public abstract function getQuery(ReflectionMethod $method);
+    public abstract function getDelegate(ReflectionMethod $method);
     public static final function create(ReflectionClass $reflector){
         return new HermitAnnoteConst($reflector);
     }
+    public function isSelectMethod(ReflectionMethod $method){
+        if($this->isProcedureMethod($method)){
+            return false;
+        }
+        if($this->isInsertMethod($method)){
+            return false;
+        }
+        if($this->isUpdateMethod($method)){
+            return false;
+        }
+        if($this->isDeleteMethod($method)){
+            return false;
+        }
+        return true;
+    }
 }
+

lang/php/misc/Hermit/src/Hermit/annote/HermitAnnoteConst.php

@@ -10 +10 @@
     const QUERY_SUFFIX = '_QUERY';
     const FILE_SUFFIX = '_FILE';
-    const PATH_SUFFIX = '_PATH';
+    const PROCEDURE_SUFFIX = '_PROCEDURE';
     const DELEGATE_SUFFIX = '_DELEGATE';
 
+    const UNDERSCORE = '_';
+    const SQL_FILE_EXTENSION = '.sql';
+
+    const PROCEDURE_NAMES = '/^(proc|call)/i';
+    const INSERT_NAMES = '/^(insert|create|add)/i';
+    const UPDATE_NAMES = '/^(update|modify|store)/i';
+    const DELETE_NAMES = '/^(delete|remove)/i';
+
     protected $reflector;
-    protected function __construct(ReflectionClass $reflector){
+    public function __construct(ReflectionClass $reflector){
         $this->reflector = $reflector;
     }
-    protected static function createFilePath($pathOfClass, $suffix){
-        return dirname($pathOfClass) . '_' . $suffix . '.sql';
+    protected static function underscore(){
+        $args = func_get_args();
+        $buf = '';
+        foreach($args as $arg){
+            $buf .= $arg;
+            $buf .= self::UNDERSCORE;
+        }
+        return substr($buf, 0, -1);
     }
     public function getTable(){
@@ -39 +53 @@
         return $this->reflector->getMethod($name);
     }
-    public function hasSql($name){
-        return $this->reflector->hasConstant($name . self::SQL_SUFFIX);
+    public function isProcedureMethod(ReflectionMethod $method){
+        return 1 === preg_match(self::PROCEDURE_NAMES, $method->getName());
     }
-    public function getSql($name, $instance = null){
-        return $this->reflector->getConstant($name . self::SQL_SUFFIX);
+    public function isInsertMethod(ReflectionMethod $method){
+        return 1 === preg_match(self::INSERT_NAMES, $method->getName());
     }
-    public function hasQuery($name){
-        return $this->reflector->hasConstant($name . self::QUERY_SUFFIX);
+    public function isUpdateMethod(ReflectionMethod $method){
+        return 1 === preg_match(self::UPDATE_NAMES, $method->getName());
     }
-    public function getQuery($name, $instance = null){
-        return $this->reflector->getConstant($name . self::QUERY_SUFFIX);
+    public function isDeleteMethod(ReflectionMethod $method){
+        return 1 === preg_match(self::DELETE_NAMES, $method->getName());
     }
-    public function hasFile($name){
-        if(!$this->reflector->hasConstant($name . self::FILE_SUFFIX)){
-            return false;
+    public function getProcedure(ReflectionMethod $method){
+        $key = $method->getName . self::PROCEDURE_SUFFIX;
+        if($this->reflector->hasConstant($key)){
+            return $this->reflector->getConstant($key);
         }
-        return file_exists(self::createFilePath($this->reflector->getFileName(), $name));
+        return null;
     }
-    public function getFile($name, $instance = null){
-        $path = self::createFilePath($this->reflector->getFileName(), $name);
-        return file_get_contents($path);
+    public function getSql(ReflectionMethod $method, $suffix = null){
+        if(is_null($suffix)){
+            $suffix = '';
+        }
+        $methodName = $method->getName();
+        $key1 = $methodName . self::UNDERSCORE . $suffix . self::SQL_SUFFIX;
+        if($this->reflector->hasConstant($key1)){
+            return $this->reflector->getConstant($key1);
+        }
+        $key2 = $methodName . self::SQL_SUFFIX;
+        if($this->reflector->hasConstant($key2)){
+            return $this->reflector->getConstant($key2);
+        }
+
+        $fileName = $this->reflector->getFileName();
+        $className = $this->reflector->getName();
+        $dirPath = dirname($fileName) . DIRECTORY_SEPARATOR;
+        $key3 = $dirPath . self::underscore($className, $methodName, $suffix) . self::SQL_FILE_EXTENSION;
+        if(file_exists($key3)){
+            return file_get_contents($key3);
+        }
+        $key4 = $dirPath . self::underscore($className, $methodName) . self::SQL_FILE_EXTENSION;
+        if(file_exists($key4)){
+            return file_get_contents($key4);
+        }
+        return null;
     }
-    public function hasPath($name){
-        if(!$this->reflector->hasConstant($name . self::PATH_SUFFIX)){
-            return false;
+    public function getQuery(ReflectionMethod $method){
+        $key = $method->getName() . self::QUERY_SUFFIX;
+        if($this->reflector->hasConstant($key)){
+            return $this->reflector->getConstant($key);
         }
-        return file_exists($this->getPath($name));
+        return null;
     }
-    public function getPath($name, $instance = null){
-        return file_get_contents($this->reflector->getConstant($name . self::PATH_SUFFIX));
+    public function getFile(ReflectionMethod $method){
+        $key = $method->getName() . self::FILE_SUFFIX;
+        if($this->reflector->hasConstant($key)){
+            $path = $this->reflector->getConstant($key);
+            if(file_exists($path)){
+                return file_get_contents($path);
+            }
+        }
+        return null;
     }
-    public function hasDelegate($name){
-        return $this->reflector->hasConstant($name . self::DELEGATE_SUFFIX);
-    }
-    public function getDelegate($name, $instance = null){
+    public function getDelegate(ReflectionMethod $method){
         return $this->reflector->getConstant($name . self::DELEGATE_SUFFIX);
     }
 }
+

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

@@ -12 +12 @@
     }
     public function execute(PDO $pdo, array $parameters){
-        $sql = $this->sqlCreator->createSql();
+        $sql = $this->sqlCreator->createSql($pdo);
         $stmt = HermitStatementBuilder::prepare($pdo, $this->method, $sql);
         $stmt->execute($parameters);

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

@@ -2 +2 @@
 
 interface HermitSqlCommand {
-    public function execute(PDO $pdo);
+    public function execute(PDO $pdo, array $params);
 }

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

@@ -12 +12 @@
         $this->reflector = $reflector;
     }
-    public function hasCommand($methodName){
+    public function has($methodName){
         return $this->annote->hasMethod($methodName);
     }
-    public function getCommand($methodName){
+    public function create(PDO $pdo, $methodName){
         $method = $this->annote->getMethod($methodName);
         $methodId = spl_object_hash($method);
@@ -25 +25 @@
     }
     protected function createCommand(ReflectionMethod $method){
+        $methodName = $method->getName();
+        if($this->annote->isProcedureMethod($methodName)){
+            return $this->createProcedureCommand($method);
+        }
         if($this->annote->isInsertMethod($methodName)){
             return $this->createInsertCommand($method);
@@ -36 +40 @@
         return $this->createSelectCommand($method);
     }
+    protected function createProcedureCommand(ReflectionMethod $method){
+        $creator = $this->createProcedureSqlCreator($method);
+        return new HermitProcedureCommand($method, $creator);
+    }
+    protected function createProcedureSqlCreator(ReflectionMethod $method){
+        $sql = $this->annote->getProcedure($method);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        $sql = $this->annote->getSql($method);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        $sql = $this->annote->getFile($method);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        throw new BadMethodCallException('method: "' . $method->getName() . '" was not apply to Procedure command');
+    }
     protected function createInsertCommand(ReflectionMethod $method){
+        throw new RuntimeException('T.B.D');
     }
     protected function createUpdateCommand(ReflectionMethod $method){
+        throw new RuntimeException('T.B.D');
+    }
+    protected function createDeleteCommand(ReflectionMethod $method){
+        throw new RuntimeException('T.B.D');
     }
     protected function createSelectCommand(ReflectionMethod $method){
-        $creator = $this->createSelectSqlCreator($method->getName());
+        $creator = $this->createSelectSqlCreator($method);
+        $query = $this->annote->getQuery($method);
+        if(null !== $query){
+            $creator->addQuery($query);
+        }
         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;
+    protected function createSelectSqlCreator(ReflectionMethod $method){
+        $sql = $this->annote->getSql($method);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
         }
-        throw new BadMethodCallException('invalid method:' . $name);
+        $sql = $this->annote->getFile($method);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        return new HermitAutoSelectCreator;
     }
 }
+

lang/php/misc/Hermit/src/Hermit/creator/HermitSqlCreator.php

@@ -1 +1 @@
 <?php
 
+/**
+ * @author nowelium
+ */
 interface HermitSqlCreator {
-    public function createSql();
+    public function createSql(PDO $pdo);
 }

lang/php/misc/Hermit/src/Hermit/creator/HermitStaticSqlCreator.php

@@ -3 +3 @@
 class HermitStaticSqlCreator implements HermitSqlCreator {
     private $sql;
-    public function __construct(ReflectionMethod $method, $sql){
+    public function __construct($sql){
         $this->sql = $sql;
     }
-    public function createSql(){
+    public function createSql(PDO $pdo){
         return $this->sql;
     }

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

@@ -15 +15 @@
     }
     public function request($name, array $params){
-        if(!$this->commandFactory->hasCommand($name)){
+        if(!$this->commandFactory->has($name)){
             throw new BadMethodCallException($this->reflector->getName() . '::' . $name);
         }
-        $command = $this->commandFactory->getCommand($name);
+        $pdo = HermitDataSourceManager::get($this->reflector->getName());
+        $command = $this->commandFactory->create($pdo, $name);
         return $command->execute($pdo, $params);
     }

lang/php/misc/Hermit/src/Hermit/statement/HermitStatementBuilder.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitStatementBuilder {
+abstract class HermitStatementBuilder {
     const REGEX = '/(\/\*(\w+)\*\/)((\'|")(\w+)(\'|"))/m';
     public static function prepare(PDO $pdo, ReflectionMethod $method, $sql){