实战 Groovy: 关于 MOP 和迷你语言

class MOPHandler {	
 
  def invokeMethod(String method,Object params) { 	
    println "MOPHandler was asked to invoke ${method}"
    if(params != null){
	 params.each{ println "twith parameter ${it}" }
    }
  }
  
  def getProperty(String property){
     println "MOPHandler was asked for property ${property}"
  }  
}
def hndler = new MOPHandler()
hndler.helloWorld()
hndler.createUser("Joe",18,new Date())
hndler.name

aglover@glove-ubutu:~/projects/groovy-mop$ groovy 
  ./src/groovy/com/vanward/groovy/MOPHandler1.groovy
MOPHandler was asked to invoke helloWorld
MOPHandler was asked to invoke createUser
        with parameter Joe
        with parameter 18
        with parameter Sun Sep 04 10:32:22 EDT 2005
MOPHandler was asked for property name

package test.com.vanward.groovy
import com.vanward.groovy.SimpleDictionary
import groovy.util.GroovyTestCase
import java.io.File
import java.sql.Connection
import java.sql.DriverManager
import org.dbunit.database.DatabaseConnection
import org.dbunit.database.IDatabaseConnection
import org.dbunit.dataset.IDataSet
import org.dbunit.dataset.xml.FlatXmlDataSet
import org.dbunit.operation.DatabaSEOperation
class DictionaryTest extends GroovyTestCase{  
   def dictionary
   
   void setUp() {        
      this.handleSetUpOperation()  
      dictionary = new SimpleDictionary()    
   } 
  
   def handleSetUpOperation() {
      def conn = this.getConnection()
      def data = this.getDataSet()       
      try{
          DatabaSEOperation.CLEAN_INSERT.execute(conn,data)
      }finally{
          conn.close()
      }
    }
    
    def getDataSet()  {
      return new FlatXmlDataSet(new File("test/conf/words-seed.xml"))
    }
    
    def getConnection()  {
       Class.forName("org.gjt.mm.mysql.Driver")
       def jdbcConnection = DriverManager.
        	getConnection("jdbc:mysql://localhost/words","words","words")             
       return new DatabaseConnection(jdbcConnection)
    }  
}

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
 <word WORD_ID="1" SPELLING="pugnacious" PART_OF_SPEECH="Adjective"/>   
 <definition DEFINITION_ID="10" 
             DEFINITION="Combative in nature; belligerent." 
             WORD_ID="1" />
 <synonym SYNONYM_ID="20" WORD_ID="1" SPELLING="belligerent"/>
 <synonym SYNONYM_ID="21" WORD_ID="1" SPELLING="aggressive"/>  
 <word WORD_ID="2" SPELLING="glib" PART_OF_SPEECH="Adjective"/>
 <definition DEFINITION_ID="11" 
     	       DEFINITION="Performed with a natural,offhand ease" 
             WORD_ID="2" />             
 <definition DEFINITION_ID="12" 
  	      DEFINITION="Marked by ease and fluency of speech or 
  	      writing that often suggests or stems from insincerity,superficiality,or deceitfulness" 
         WORD_ID="2" />              
 <synonym SYNONYM_ID="30" WORD_ID="2" SPELLING="artful"/>
 <synonym SYNONYM_ID="31" WORD_ID="2" SPELLING="suave"/>  
 <synonym SYNONYM_ID="32" WORD_ID="2" SPELLING="insincere"/>  
 <synonym SYNONYM_ID="33" WORD_ID="2" SPELLING="urbane"/>  
 
 <word WORD_ID="3" SPELLING="rowel" PART_OF_SPEECH="Verb"/>  
 <definition DEFINITION_ID="50" 
             DEFINITION="to vec,trouble" 
             WORD_ID="13" />
</dataset>

private determinePartOfSpeech(question){
  def matcher = question =~ 'is(.*)(An|A)(Verb|Adjective|Adverb|Noun)'
  matcher.matches()
  def word = matcher.group(1)
  def partOfSpeech = matcher.group(3)
  def row = sql.firstRow("select part_of_speech from word 
  	where spelling=?",[word])	
  return row[0] == partOfSpeech
}

void testPartOfSpeechFalse() {
  def val = dictionary.isPugnaciousAVerb()
  assertFalse("pugnacious is not a verb",val)
}	
void testPartOfSpeechTrue() {
  def val = dictionary.isPugnaciousAnAdjective()
  assertTrue("pugnacious is an Adjective",val)
}

private getSynonyms(question){
  def matcher = question =~ '(synonymsOf)(.*)'
  matcher.matches()
  def word = matcher.group(2).toLowerCase()
  def syns = []	
  sql.eachRow("select synonym.spelling from synonym,word " +
      "where synonym.word_id = word.word_id and " +
      "word.spelling = ?",[word]){ arow ->
          syns << arow.spelling
       }	   
  return syns		
}

void testSynonymsForWord() {
  def val = dictionary.synonymsOfPugnacious()
  def expect = ["belligerent","aggressive"]
  assertEquals("should be: " + expect,expect,val)
}
void testNoSynonymsForWord() {
  def val = dictionary.synonymsOfRowel()
  def expect = []
  assertEquals("should be: " + expect,val)
}

private removeWord(word){
  def matcher = word =~ '(remove|delete)(.*)'
  matcher.matches()
  def wordToRemove = matcher.group(2).toLowerCase()	
  sql.execute("delete from word where spelling=?",[wordToRemove])	
}

void testDeleteWord() {
  dictionary.deleteGlib()
  def val =  dictionary.glib()
  def expect = []
  assertEquals("should be: " + expect,val)
}
void testRemoveWord() {
  dictionary.removePugnacious()
  def val =  dictionary.pugnacious()
  def expect = []
  assertEquals("should be: " + expect,val)
}

private createWord(word,defsAndSyms){
  def wordId = id++
  def definitionId = wordId + 10
  sql.execute("insert into word 
  	(word_id,part_of_speech,spelling) values (?,?,?)",[wordId,defsAndSyms[0],word])
  for(definition in defsAndSyms[1]){	
    sql.execute("insert into definition 
    	(definition_id,definition,word_id) " +
      "values (?,[definitionId,wordId])
    }
  //has a list of synonyms has been passed in
  if(defsAndSyms.length > 2){
    def synonyms = defsAndSyms[2]
    synonyms.each{ syn ->
      sql.execute("insert into synonym 
      	(synonym_id,word_id,[id++,wordId,syn])
      }
    }
}

void testCreateWord() {	
  dictionary.bloviate("Verb",["To discourse at length in a pompous or boastful manner"],["orate","gabble","lecture"])
  def val = dictionary.bloviate()
  def expect = "To discourse at length in a pompous or boastful manner"
  assertEquals("should be: " + expect,val[0])
}
void testCreateWordNoSynonyms() {	
  dictionary.echelon("Noun",["a level within an organization"])
  def val = dictionary.echelon()
  def expect = "a level within an organization"
  assertEquals("should be: " + expect,val[0])
}

private getDefinitions(word){	
  def definitions = []			   	  
  sql.eachRow("select definition.definition from definition,word " +
    "where definition.word_Id = word.word_id and " +
    "word.spelling = ?",[word]){ arow ->
      definitions << arow.definition
    }	   
  return definitions	
}

void testFindWord() {
  def val = dictionary.pugnacious()
  def expect = "Combative in nature; belligerent."
  assertEquals("should be: " + expect,val[0])
}
void testFindWordAsProperty() {
  def val = dictionary.pugnacious
  def expect = "Combative in nature; belligerent."
  assertEquals("should be: " + expect,val[0])
}

def invokeMethod(String methodName,Object params) { 	
  if(isGetDefinitions(methodName,params)){
    return getDefinitions(methodName)
  }else if (params.length > 0){	 
    createWord(methodName,params)
  }else if(methodName[0..1] == 'is'){
    return determinePartOfSpeech(methodName)
  }else if
  (methodName[0..5] == 'remove' || methodName[0..5] == 'delete'){	
  	 removeWord(methodName)
  }else if (methodName[0..9] == 'synonymsOf'){
    return getSynonyms(methodName)
  }
}
 
private isGetDefinitions(methodName,params){
  return !(params.length > 0) && 
    ( (methodName.length() <= 5 
    && methodName[0..1] != 'is' ) || 
    (methodName.length() <= 10 
    && isRemoveDeleteIs(methodName) ) || 
    (methodName.length() >= 10 
    && methodName[0..9] != 'synonymsOf' 
    && isRemoveDeleteIs(methodName)))	
}
 
private isRemoveDeleteIs(methodName){
	return (methodName[0..5] != 'remove' 
      && methodName[0..5] != 'delete' 
      && methodName[0..1] != 'is')
  }

def getProperty(String property){
  return getDefinitions(property)
}

import com.vanward.groovy.SimpleDictionary
def dict = new SimpleDictionary()  
dict.vanward("Adjective",["Being on,or towards the front"],["Advanced"])
dict.pulchritude("Noun",["Great physical beauty and appeal"])
dict.vanward             //prints "Being on,or towards the front"
dict.pulchritude()       //prints "Great physical beauty and appeal"
dict.synonymsOfVanward() //prints "Advanced"
dict.isVanwardANoun()    //prints "false"
dict.removeVanward()
dict.deletePulchritude()