programr 0.0.1

data/lib/programr/aiml_parser.rb

@@ -0,0 +1,269 @@
+require 'rexml/parsers/sax2parser'
+require 'programr/aiml_elements'
+
+# gli accenti nel file di input vengono trasformati in ' !!!
+#
+module  ProgramR
+class AimlParser
+  def initialize(learner); @learner = learner end
+
+  def parse(aiml)
+    @parser = REXML::Parsers::SAX2Parser.new(aiml)
+    category         = nil
+    openLabels       = []
+    patternIsOpen    = false
+    thatIsOpen       = false
+    currentSetLabel  = nil
+    currentCondition = nil
+    currentSrai      = nil
+    currentGender    = nil
+    currentPerson    = nil
+    currentPerson2   = nil
+    currentTopic     = nil
+
+    @parser.listen(%w{ category }){|uri,localname,qname,attributes| 
+      category = Category.new
+      category.topic = currentTopic if(currentTopic)
+    }
+
+    @parser.listen(['topicstar','thatstar','star']){|u,localname,qn,attributes|
+      openLabels[-1].add(Star.new(localname,attributes))
+    }
+
+### condition -- random
+    @parser.listen(%w{ condition }){|uri,localname,qname,attributes|
+      if(attributes.key?('value'))
+        currentCondition = Condition.new(attributes)
+      else
+        currentCondition = ListCondition.new(attributes)
+      end
+      openLabels[-1].add(currentCondition)
+      openLabels.push(currentCondition)
+    }
+    
+    @parser.listen(%w{ random }){|uri,localname,qname,attributes|
+      currentCondition = Random.new
+      openLabels[-1].add(currentCondition)
+      openLabels.push(currentCondition)
+    }
+    
+    @parser.listen(:characters, %w{ condition }){|text|
+      next if(text =~ /^\s+$/)
+      currentCondition.add(text)
+    }
+
+    @parser.listen(%w{ li }){|uri,localname,qname,attributes|
+      next unless currentCondition
+      currentCondition.setListElement(attributes)
+    }
+    
+    @parser.listen(:characters,%w{ li }){|text|
+      next unless currentCondition
+      currentCondition.add(text)
+    }
+
+    @parser.listen(:end_element, ['condition','random']){
+      currentCondition = nil
+      openLabels.pop      
+    }
+### end condition -- random
+
+    @parser.listen([/^get.*/,/^bot_*/,'for_fun',/that$/, 'question']){
+                   |uri,localname,qname,attributes|
+      unless(openLabels.empty?)
+        openLabels[-1].add(ReadOnlyTag.new(localname, attributes))
+      end
+    }
+
+    @parser.listen(['bot','name']){|uri,localname,qname,attributes|
+      if(localname == 'bot')
+        localname = 'bot_'+attributes['name']
+      else
+        localname = 'bot_name'
+      end
+      if(patternIsOpen)
+        category.add_pattern(ReadOnlyTag.new(localname, {}))
+      elsif(thatIsOpen)
+        category.add_that(ReadOnlyTag.new(localname, {}))
+      else
+        openLabels[-1].add(ReadOnlyTag.new(localname, {}))
+      end
+    }
+
+### set
+    @parser.listen([/^set_*/,'set']){|uri,localname,qname,attributes|
+      setObj = SetTag.new(localname,attributes)    
+      openLabels[-1].add(setObj)
+      openLabels.push(setObj)
+    }
+
+    @parser.listen(:characters,[/^set_*/]){|text|
+      openLabels[-1].add(text)    
+    }
+
+    @parser.listen(:end_element, [/^set_*/,'set']){
+      openLabels.pop      
+    }
+### end set
+
+### pattern
+    @parser.listen(%w{ pattern }){patternIsOpen = true}
+    @parser.listen(:characters,%w{ pattern }){|text| 
+      #TODO verify if case insensitive. Cross check with facade
+      category.add_pattern(text.upcase)
+    }
+    @parser.listen(:end_element, %w{ pattern }){patternIsOpen = false}
+#end pattern
+
+#### that
+    @parser.listen(%w{ that }){thatIsOpen = true}
+    @parser.listen(:characters,%w{ that }){|text| category.add_that(text)}
+    @parser.listen(:end_element, %w{ that }){thatIsOpen = false}
+### end that
+
+### template
+    @parser.listen(%w{ template }){ 
+      category.template = Template.new 
+      openLabels.push(category.template)
+    }
+
+    @parser.listen(:characters, %w{ template }){|text|
+      category.template.append(text)
+    }
+
+    @parser.listen(:end_element, %w{ template }){
+      openLabels.pop
+    }
+### end template
+
+    @parser.listen(%w{ input }){|uri,localname,qname,attributes|
+      category.template.add(Input.new(attributes))
+    }
+
+### think
+    @parser.listen(:start_element, %w{ think }){
+      openLabels[-1].add(Think.new('start'))
+    }
+
+    @parser.listen(:end_element, %w{ think }){
+    openLabels[-1].add(Think.new('end'))
+    }
+###end think
+
+    @parser.listen(:characters, %w{ uppercase }){|text|
+      openLabels[-1].add(text.upcase.gsub(/\s+/, ' '))
+    }
+
+    @parser.listen(:characters, %w{ lowercase }){|text|
+      openLabels[-1].add(text.downcase.gsub(/\s+/, ' '))
+    }
+
+    @parser.listen(:characters, %w{ formal }){|text|
+      text.gsub!(/(\w+)/){$1.capitalize}
+      openLabels[-1].add(text.gsub(/\s+/, ' '))
+    }
+
+    @parser.listen(:characters, %w{ sentence }){|text|
+      openLabels[-1].add(text.capitalize.gsub(/\s+/, ' '))
+    }
+
+    @parser.listen(%w{ date }){
+      openLabels[-1].add(Sys_Date.new)
+    }
+    
+    @parser.listen(:characters, %w{ system }){|text|
+      openLabels[-1].add(Command.new(text))
+    }
+    
+    @parser.listen(%w{ size }){ 
+      openLabels[-1].add(Size.new)
+    }
+
+    @parser.listen(%w{ sr }){|uri,localname,qname,attributes|
+      openLabels[-1].add(Srai.new(Star.new('star',{})))
+    }
+### srai    
+    @parser.listen(%w{ srai }){|uri,localname,qname,attributes|
+      currentSrai = Srai.new
+      openLabels[-1].add(currentSrai)
+      openLabels.push(currentSrai)
+    }
+    
+    @parser.listen(:characters, %w{ srai }){|text|
+      currentSrai = Srai.new
+      currentSrai.add(text)
+    }
+    
+    @parser.listen(:end_element, %w{ srai }){
+      currentSrai = nil
+      openLabels.pop
+    }
+### end srai
+
+### gender
+    @parser.listen(%w{ gender }){|uri,localname,qname,attributes|
+      currentGender = Gender.new
+      openLabels[-1].add(currentGender)
+      openLabels.push(currentGender)
+    }
+    
+    @parser.listen(:characters, %w{ gender }){|text|
+      currentGender.add(text)
+    }
+
+    @parser.listen(:end_element, %w{ gender }){
+      currentGender = nil
+      openLabels.pop
+    }
+### end gender
+
+### person
+    @parser.listen(%w{ person }){|uri,localname,qname,attributes|
+      currentPerson = Person.new
+      openLabels[-1].add(currentPerson)
+      openLabels.push(currentPerson)
+    }
+    
+    @parser.listen(:characters, %w{ person }){|text|
+      currentPerson.add(text)
+    }
+
+    @parser.listen(:end_element, %w{ person }){
+      currentPerson = nil
+      openLabels.pop
+    }
+### end person
+
+### person2
+    @parser.listen(%w{ person2 }){|uri,localname,qname,attributes|
+      currentPerson2 = Person2.new
+      openLabels[-1].add(currentPerson2)
+      openLabels.push(currentPerson2)
+    }
+    
+    @parser.listen(:characters, %w{ person2 }){|text|
+      currentPerson2.add(text)
+    }
+
+    @parser.listen(:end_element, %w{ person2 }){
+      currentPerson2 = nil
+      openLabels.pop
+    }
+### end perso2
+
+    @parser.listen(:end_element, %w{ category }){ @learner.learn(category) }
+
+### topic
+    @parser.listen(%w{ topic }){|uri,localname,qname,attributes|
+      currentTopic = attributes['name']
+    }
+    
+    @parser.listen(:end_element, %w{ topic }){
+      currentTopic = nil
+    }
+### end topic
+
+    @parser.parse
+  end
+end #Aiml@parser
+end

data/lib/programr/environment.rb

@@ -0,0 +1,75 @@
+require 'yaml'
+require 'programr/history'
+
+module ProgramR
+class Environment
+  @@readOnlyTags = nil
+  @@history      = nil
+
+  def initialize
+    return self unless(@@readOnlyTags == nil)
+    @@readOnlyTags = YAML::load(
+                          File.open( 
+                            File.dirname(__FILE__) +
+                              "/../../conf/readOnlyTags.yaml"))
+    @@history      = History.new
+    srand(1)
+  end
+
+  def get(aTag)
+    send(aTag)
+  end
+
+  def set(aTag,aValue)
+    @@history.updateTopic(aValue) if(aTag == 'topic')
+    @@readOnlyTags[aTag] = aValue
+  end
+
+  def method_missing(methId)
+    tag = methId.id2name
+    return @@history.send(tag) if(tag =~ /that$/)
+    return @@readOnlyTags[tag] if(@@readOnlyTags.key?(tag))
+    ''
+  end
+  
+  def test
+    #should overwrite test ....
+    return @@readOnlyTags[tag] if(@@readOnlyTags.key?(tag))
+    ''
+  end
+  
+  def star(anIndex)
+    @@history.getStar(anIndex)
+  end
+  
+  def thatstar(anIndex)
+    @@history.getThatStar(anIndex)
+  end
+  
+  def topicstar(anIndex)
+    @@history.getTopicStar(anIndex)
+  end
+  
+  def male
+    @@readOnlyTags['gender'] = 'male'
+    return 'male'
+  end
+  
+  def female
+    @@readOnlyTags['gender'] = 'female'
+    return 'female'
+  end
+  
+  def question
+    @@readOnlyTags['question'][rand(@@readOnlyTags['question'].length-1)]
+  end
+
+  def getRandom(anArrayofChoices)
+    anArrayofChoices[rand(anArrayofChoices.length-1)]
+  end
+
+  def getStimula(anIndex)
+    @@history.getStimula(anIndex)
+  end
+end
+end

data/lib/programr/facade.rb

@@ -0,0 +1,65 @@
+require 'programr/graph_master'
+require 'programr/aiml_parser'
+require 'programr/history'
+require 'programr/utils'
+
+module ProgramR
+class Facade
+  def initialize(cache = nil)
+    @graph_master = GraphMaster.new
+    @parser       = AimlParser.new(@graph_master)
+    @history      = History.new
+  end
+
+  def learn(files)
+    AimlFinder::find(files).each{|f| File.open(f,'r'){|f| @parser.parse f} }
+  end
+
+  def loading(theCacheFilename='cache')
+    cache = Cache::loading(theCacheFilename)
+    @graph_master = cache if cache
+  end
+
+  def merging(theCacheFilename='cache')
+    cache = Cache::loading(theCacheFilename)
+    @graph_master.merge(cache) if cache
+  end
+
+  def dumping(theCacheFilename='cache')
+    Cache::dumping(theCacheFilename,@graph_master)
+  end
+  
+  def get_reaction(stimula,firstStimula=true)
+    starGreedy = []  
+#TODO verify if case insensitive. Cross check with parser
+    #@history.updateStimula(stimula.upcase) if(firstStimula)
+@history.updateStimula(stimula.upcase) if(firstStimula)
+    thinkIsActive = false
+reaction = @graph_master.get_reaction(stimula.upcase, @history.that,
+                                          @history.topic,starGreedy)
+    @history.updateStarMatches(starGreedy)
+    res = ''
+    reaction.each{|tocken| 
+      if(tocken.class == Srai)
+        tocken = get_reaction(tocken.pattern,false)
+        @history.updateStarMatches(starGreedy)
+      end
+      if tocken.class == Think
+        thinkIsActive = ! thinkIsActive
+        next
+      end
+      value = tocken.to_s
+      res += value unless(thinkIsActive)
+    }
+    #TODO verify if case insensitive. Cross check with main program & parser
+    @history.updateResponse(res.strip.upcase) if(firstStimula)
+    return res.strip
+  end
+
+  def to_s
+    @graph_master.to_s
+  end  
+
+  #  def getBotName()end
+end
+end

data/lib/programr/graph_master.rb

@@ -0,0 +1,110 @@
+require 'programr/aiml_elements'
+
+module ProgramR
+THAT  = '<that>'
+TOPIC = '<topic>'
+class GraphMaster
+  attr_reader :graph
+  def initialize
+    @graph = Node.new
+  end
+
+  def merge(aCache)
+    @graph.merge(aCache.graph)
+  end
+  
+  def learn(category)
+    path = category.get_pattern
+    path += [THAT] + category.get_that unless (category.get_that).empty?
+    path += [TOPIC] + category.topic.split(/\s+/) if category.topic
+    @graph.learn(category, path)
+  end
+
+  def to_s
+    @graph.inspectNode()
+  end
+
+  def get_reaction(stimula, last_said,cur_topic,starGreedy)
+    path = "#{stimula} #{THAT} #{last_said} #{TOPIC} #{cur_topic}"
+    template = @graph.get_template(path.split(/\s+/),starGreedy)
+    return template.value unless(template == nil)
+    return []
+  end
+end
+
+class Node
+  attr_reader :children
+  def initialize
+    @template = nil
+    @children = {}
+  end
+
+  def merge(aCache)
+    aCache.children.keys.each do |key|
+      if(@children.key?(key))
+        @children[key].merge(aCache.children[key])
+	next
+      end
+      @children[key] = aCache.children[key]
+    end
+  end
+  
+  def learn(category, path)
+    branch = path.shift
+    return @template = category.template unless branch
+    @children[branch] = Node.new unless @children[branch]
+    @children[branch].learn(category, path)
+  end
+
+  def get_template(pattern,starGreedy,isGreedy=false)  
+    currentTemplate = nil
+    gotValue        = nil
+    curGreedy       = []
+    if(@template)
+      if(isGreedy)
+	starGreedy.push(pattern.shift) until(pattern.empty?||pattern[0]==THAT ||
+	                                     pattern[0] == TOPIC)
+      end
+      return @template if(pattern.empty?)
+      currentTemplate = @template if(pattern[0] == THAT || pattern[0] == TOPIC)
+    end
+    branch = pattern.shift
+    isGreedy = false if(branch == THAT || branch == TOPIC)
+    unless(branch != THAT || @children.key?(THAT))
+      branch = pattern.shift until (branch == nil or branch == TOPIC)
+    end
+    return nil unless(branch)
+    if(@children[branch])
+      gotValue = @children[branch].get_template(pattern.clone,curGreedy)
+    elsif(isGreedy)
+      curGreedy.push(branch)
+      gotValue = get_template(pattern.clone,curGreedy,true)
+    end
+    if(gotValue)
+      starGreedy.push(branch) if(branch == THAT || branch == TOPIC)
+      starGreedy.concat(curGreedy)
+      return gotValue
+    end
+    return currentTemplate if currentTemplate   
+    ["_","*"].each do |star|
+      next unless(@children.key?(star))
+      next unless(gotValue=@children[star].get_template(pattern.clone,
+                                                        curGreedy,true))
+starGreedy.push(branch) if(branch == THAT || branch == TOPIC)
+      starGreedy.concat(['<newMatch>',branch].concat(curGreedy))
+      return gotValue 
+    end
+    return nil
+  end
+
+  def inspectNode(nodeId = nil, ind = 0)
+    str = ''
+    str += '| '*(ind - 1) + "|_#{nodeId}" unless ind == 0
+    str += ": [#{@template.inspect}]" if @template
+    str += "\n" unless ind == 0
+    @children.each_key{|c| str += @children[c].inspectNode(c, ind+1)}
+    str
+  end
+end
+
+end #ProgramR