james 0.0.1-universal-darwin-10 → 0.0.2-universal-darwin-10

data/aux/james/cli.rb

@@ -0,0 +1,22 @@
+require File.expand_path '../../../lib/james', __FILE__
+
+module James
+
+  class CLI
+
+    def execute *dialogues
+      all_dialogues = Dir["**/*_dialog{,ue}.rb"]
+      all_dialogues.select! { |dialogue| dialogues.any? { |given| dialogue =~ %r{#{given}_dialog(ue)?.rb$} } } unless dialogues.empty?
+
+      puts "James: Using #{all_dialogues.join(', ')} for our conversation, Sir."
+
+      all_dialogues.each do |dialogue|
+        require File.expand_path dialogue, Dir.pwd
+      end
+
+      James.listen
+    end
+
+  end
+
+end

data/bin/james

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+
+# james joke phonebook quote
+# OR
+# james # Uses Dir.pwd
+#
+
+begin
+  require 'james/cli'
+rescue LoadError => e
+  require 'rubygems'
+  james_path = File.expand_path '../../aux', __FILE__
+  $:.unshift(james_path) if File.directory?(james_path) && !$:.include?(james_path)
+  require 'james/cli'
+end
+
+cli = James::CLI.new
+cli.execute *ARGV

data/lib/james.rb

@@ -0,0 +1,18 @@
+module James; end
+
+require File.expand_path '../james/timer', __FILE__
+require File.expand_path '../james/visitor', __FILE__
+require File.expand_path '../james/dialogues', __FILE__
+
+require File.expand_path '../james/dialogue_api', __FILE__
+require File.expand_path '../james/dialogue_internals', __FILE__
+
+require File.expand_path '../james/controller', __FILE__
+
+module James
+
+  def self.listen
+    Controller.new.listen
+  end
+
+end

data/lib/james/builtin/main_dialogue.rb

@@ -0,0 +1,25 @@
+class Bla
+
+  include James::Dialogue
+
+  hear 'James?' => :awake
+
+  state :awake do
+    hear 'Leave me alone, James' => :away
+    into { "Sir?" }
+  end
+
+  state :away do
+    hear 'Are you there, James?' => :awake,
+         "That's it for today, James" => :exit
+    into { "Goodbye, Sir" }
+  end
+
+  state :exit do
+    into do
+      puts "James: Exits through a side door."
+      Kernel.exit
+    end
+  end
+
+end

data/lib/james/controller.rb

@@ -0,0 +1,116 @@
+framework 'AppKit'
+
+require File.expand_path '../inputs/base', __FILE__
+require File.expand_path '../inputs/audio', __FILE__
+require File.expand_path '../inputs/terminal', __FILE__
+
+require File.expand_path '../outputs/audio', __FILE__
+require File.expand_path '../outputs/terminal', __FILE__
+
+module James
+
+  class Controller
+
+    attr_reader :visitor
+
+    def initialize
+      @visitor = initialize_dialogues.visitor
+    end
+
+    def applicationDidFinishLaunching notification
+      load_voices
+
+      start_output
+      start_input
+
+      visitor.enter { |text| say text }
+
+      @input.listen
+    end
+    def windowWillClose notification
+      puts "James is going to bed."
+      exit
+    end
+
+    # Load voices from yaml.
+    #
+    def load_voices
+      # yaml_voices = ''
+      # File.open('voices.yml') do |f| yaml_voices << f.read end
+      # voices = YAML.load(yaml_voices)
+      # @male_voice = voices['male']
+      # @female_voice = voices['female']
+      # Commented voices are Apple built-in voices. Can be changed by replacing the last part e.g.'Vicki' with e.g.'Laura'
+      # much better female voice from iVox:
+      # female: com.acapela.iVox.voice.iVoxHeather22k
+      # much better male voice from iVox:
+      # male: com.acapela.iVox.voice.iVoxRyan22k
+      # female: com.apple.speech.synthesis.voice.Vicki
+      # male: com.apple.speech.synthesis.voice.Bruce
+    end
+
+    def initialize_dialogues
+      # Create the main dialogue.
+      #
+      # Everybody hooks into this, then.
+      #
+      dialogues = Dialogues.new
+      dialogues.resolve
+      dialogues
+    end
+    # Start recognizing words.
+    #
+    def start_input
+      @input = Inputs::Audio.new self
+    end
+    # Start speaking.
+    #
+    def start_output
+      @output = Outputs::Audio.new
+    end
+
+    # Callback method from dialogue.
+    #
+    def say text
+      @output.say text
+    end
+    def hear text
+      @visitor.hear text do |response|
+        say response
+      end
+    end
+    def expects
+      @visitor.expects
+    end
+
+    def listen
+      app = NSApplication.sharedApplication
+      app.delegate = self
+
+      # window = NSWindow.alloc.initWithContentRect([200, 300, 300, 100],
+      #     styleMask:NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask,
+      #     backing:NSBackingStoreBuffered,
+      #     defer:false)
+      # window.title      = 'MacRuby: The Definitive Guide'
+      # window.level      = 3
+      # window.delegate   = app.delegate
+      #
+      # button = NSButton.alloc.initWithFrame([80, 10, 120, 80])
+      # button.bezelStyle = 4
+      # button.title      = 'Hello World!'
+      # button.target     = app.delegate
+      # button.action     = 'say_hello:'
+      #
+      # window.contentView.addSubview(button)
+      #
+      # window.display
+      # window.orderFrontRegardless
+
+      app.delegate.applicationDidFinishLaunching nil
+
+      app.run
+    end
+
+  end
+
+end

data/lib/james/dialogue_api.rb

@@ -0,0 +1,30 @@
+module James
+
+  # A dialog(ue) can be instantiated in two ways:
+  #
+  # James.dialogue do
+  #   # Your dialogue.
+  #   #
+  # end
+  #
+  # class MyDialogue
+  #   include James::Dialogue
+  #
+  #   # Your dialogue.
+  #   #
+  # end
+  #
+  module Dialogue; end
+
+  class << self
+
+    def dialogue &block
+      dialogue = Class.new { include Dialogue }
+      dialogue.class_eval &block
+      dialogue
+    end
+    alias dialog dialogue
+
+  end
+
+end

data/lib/james/dialogue_internals.rb

@@ -0,0 +1,61 @@
+require File.expand_path '../state_api', __FILE__
+require File.expand_path '../state_internals', __FILE__
+require File.expand_path '../dialogues', __FILE__
+
+module James
+
+  # A dialogue is just a container object
+  # for defining states and executing methods.
+  #
+  module Dialogue
+
+    def self.included into
+      into.extend ClassMethods
+      Dialogues << into
+    end
+
+    #
+    #
+    def state_for name
+      self.class.state_for name, self
+    end
+
+    module ClassMethods
+
+      # Defines the entry sentences.
+      #
+      def hear definition
+        define_method :entries do
+          definition
+        end
+      end
+
+      # Defines a state with transitions.
+      #
+      # state :name do
+      #   # state properties (hear, into, exit) go here.
+      # end
+      #
+      attr_reader :states
+      def state name, &block
+        @states       ||= {}
+        @states[name] ||= block if block_given?
+      end
+      def state_for name, instance
+        # Lazily wrap.
+        #
+        if states[name].respond_to?(:call)
+          states[name] = State.new(name, instance, &states[name])
+        end
+        states[name]
+      end
+
+    end
+
+  end
+
+  # We don't care about the spelling.
+  #
+  Dialog = Dialogue
+
+end

data/lib/james/dialogues.rb

@@ -0,0 +1,58 @@
+require File.expand_path '../visitor', __FILE__
+
+module James
+
+  # Registers all dialogues and connects their states.
+  #
+  class Dialogues
+
+    attr_reader :initial, :dialogues
+
+    def initialize
+      @initial   = State.new :__initial_plugin_state__, nil
+      @dialogues = self.class.dialogues.map &:new
+    end
+
+    class << self
+
+      attr_reader :dialogues
+
+      def << dialogue
+        @dialogues ||= []
+        @dialogues << dialogue
+      end
+
+    end
+
+    # Generate the graph for the dialogues.
+    #
+    # Hooks up the entry phrases of all dialogues
+    # into the main dialogue.
+    #
+    # It raises if the hook phrase of a dialogue
+    # is already used.
+    #
+    def resolve
+      # Hook dialogues into initial state.
+      #
+      resolved_entries = {}
+      dialogues.each do |dialogue|
+        dialogue.entries.each do |(phrases, state)|
+          resolved_entries[phrases] = state.respond_to?(:phrases) ? state : dialogue.state_for(state)
+        end
+      end
+
+      initial.hear resolved_entries
+    end
+
+    # Get the visitor.
+    #
+    # Initialized on the initial state.
+    #
+    def visitor
+      @visitor ||= Visitor.new initial
+    end
+
+  end
+
+end

data/lib/james/inputs/audio.rb

@@ -0,0 +1,40 @@
+module James
+
+  module Inputs
+
+    class Audio < Base
+
+      def initialize controller
+        super controller
+        @recognizer = NSSpeechRecognizer.alloc.init
+        @recognizer.setBlocksOtherRecognizers true
+        @recognizer.setListensInForegroundOnly false
+        recognize_new_commands
+        @recognizer.setDelegate self
+      end
+
+      def listen
+        @recognizer.startListening
+      end
+      def heard command
+        super
+
+        # Set recognizable commands.
+        #
+        recognize_new_commands
+      end
+
+      # Callback method from the speech interface.
+      #
+      def speechRecognizer sender, didRecognizeCommand: command
+        heard command
+      end
+      def recognize_new_commands
+        @recognizer.setCommands controller.expects
+      end
+
+    end
+
+  end
+
+end

data/lib/james/inputs/base.rb

@@ -0,0 +1,23 @@
+module James
+
+  module Inputs
+
+    class Base
+
+      attr_reader :controller
+
+      def initialize controller
+        @controller = controller
+      end
+
+      def heard command
+        # Call dialogue.
+        #
+        controller.hear command
+      end
+
+    end
+
+  end
+
+end

data/lib/james/inputs/terminal.rb

@@ -0,0 +1,22 @@
+module James
+
+  module Inputs
+
+    # Terminal input for silent purposes.
+    #
+    class Terminal < Base
+
+      def listen
+        loop do
+          puts %Q{What would you like? Possibilities include\n"#{controller.expects.join('", "')}"}
+          command = gets.chop
+          puts "I heard '#{command}'."
+          heard command if controller.expects.include? command
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/james/main_dialogue.rb

@@ -0,0 +1,15 @@
+module James
+
+  # MainDialogue for first visitor.
+  #
+  module MainDialogue
+
+    extend Dialogue
+
+    def self.included into
+      into.extend ClassMethods
+    end
+
+  end
+
+end

data/lib/james/outputs/audio.rb

@@ -0,0 +1,20 @@
+module James
+
+  module Outputs
+
+    class Audio
+
+
+      def initialize voice = nil
+        @output = NSSpeechSynthesizer.alloc.initWithVoice voice || 'com.apple.speech.synthesis.voice.Alex'
+      end
+
+      def say text
+        @output.startSpeakingString text
+      end
+
+    end
+
+  end
+
+end

data/lib/james/outputs/terminal.rb

@@ -0,0 +1,17 @@
+module James
+
+  module Outputs
+
+    # Terminal output for silent purposes.
+    #
+    class Terminal
+
+      def say text
+        p text
+      end
+
+    end
+
+  end
+
+end

data/lib/james/state_api.rb

@@ -0,0 +1,86 @@
+module James
+
+  # A state is defined in a dialogue.
+  #
+  # It has a name with which it can be targeted.
+  #
+  # A state has three methods:
+  #  * hear: If this phrase (or one of these phrases) is heard, move to that state. Takes a hash.
+  #  * into: A block that is called on entering.
+  #  * exit: A block that is called on exit.
+  #
+  # Example:
+  #   state :time do
+  #     hear ['What time is it?', 'And now?'] => :time
+  #     into { time = Time.now; "It is currently #{time.hour} #{time.min}." }
+  #     exit { "And that was the time." }
+  #   end
+  #
+  class State
+
+    attr_reader :name, :context
+
+    def initialize name, context
+      @name    = name
+      @context = context
+
+      @transitions = {}
+
+      instance_eval(&Proc.new) if block_given?
+    end
+
+    # How do I get from this state to another?
+    #
+    # Example:
+    #   hear 'What time is it?' => :time,
+    #        'What? This late?' => :yes
+    #
+    # Example for staying in the same state:
+    #   hear 'What time is it?' # Implicitly staying.
+    #
+    # Note: We could expand on this with
+    #   hear 'What time is it?' => lambda { Do something here with the time, returns to same state }
+    #
+    def hear transitions
+      transitions = { transitions => name } unless transitions.respond_to?(:to_hash)
+      @transitions = expand transitions
+    end
+
+    # Execute this block when entering this state.
+    #
+    def into &block
+      @into_block = block
+    end
+
+    # Execute this block when exiting this state.
+    #
+    def exit &block
+      @exit_block = block
+    end
+
+    # Description of self using name and transitions.
+    #
+    def to_s
+      "#{self.class.name}(#{name}, #{context}, #{transitions})"
+    end
+
+    # The naughty privates of this class.
+    #
+
+      # Expands a hash in the form
+      #  * [a, b] => c to a => c, b => c
+      # but leaves a non-array key alone.
+      #
+      def expand transitions
+        results = {}
+        transitions.each_pair do |phrases, state_name|
+          [*phrases].each do |phrase|
+            results[phrase] = state_name
+          end
+        end
+        results
+      end
+
+  end
+
+end

data/lib/james/state_internals.rb

@@ -0,0 +1,32 @@
+module James
+
+  class State
+
+    attr_reader :transitions
+
+    # Returns all possible phrases that lead
+    # away from this state.
+    #
+    def phrases
+      transitions.keys
+    end
+
+    # Returns the next state for the given phrase.
+    #
+    # It accesses the context (Dialog(ue)) to get a full object state.
+    #
+    def next_for phrase
+      state = self.transitions[phrase]
+      state.respond_to?(:phrases) ? state : context.state_for(state)
+    end
+
+    def __into__
+      @into_block && context.instance_eval(&@into_block)
+    end
+    def __exit__
+      @exit_block && context.instance_eval(&@exit_block)
+    end
+
+  end
+
+end

data/lib/james/timer.rb

@@ -0,0 +1,14 @@
+module James
+
+  class Timer
+
+    def stop
+
+    end
+    def restart
+
+    end
+
+  end
+
+end

data/lib/james/visitor.rb

@@ -0,0 +1,72 @@
+require File.expand_path '../timer', __FILE__
+
+module James
+
+  # The visitor knows where in the conversation we are.
+  #
+  # It also remembers where it has to go back to if
+  # too much time passes without input.
+  #
+  # Note: A visitor should generally be very stupid.
+  # Note 2: We could call this Hearing, or Ear ;)
+  #
+  class Visitor
+
+    attr_reader   :initial, :timer
+    attr_accessor :current
+
+    # Pass in an initial state to start from.
+    #
+    def initialize initial, timer = nil
+      @current = initial
+
+      @initial = initial
+      @timer   = timer || Timer.new
+    end
+
+    # Escapes the current state back to the initial.
+    #
+    def escape
+      timer.stop
+      self.current = initial
+    end
+
+    # We hear a phrase.
+    #
+    # Also used to start the whole process.
+    #
+    def enter
+      result = current.__into__
+      yield result if result && block_given?
+      result
+    end
+    def exit
+      result = current.__exit__
+      yield result if result && block_given?
+      result
+    end
+    def transition phrase
+      self.current = current.next_for phrase
+    end
+    def check
+      escape && yield("That led nowhere.") unless current
+    end
+    def hear phrase, &block
+      return unless hears? phrase
+      timer.restart
+      exit_text = exit &block
+      transition phrase
+      check &block
+      into_text = enter &block
+      exit_text || into_text
+    end
+    def hears? phrase
+      expects.include? phrase
+    end
+    def expects
+      current.phrases
+    end
+
+  end
+
+end

data/lib/james/visitors.rb

@@ -0,0 +1,37 @@
+module James
+
+  # The visitors class has a number of visitors, whose
+  # dialogues are visited in order of preference.
+  #
+  # Why?
+  # Discussions have multiple points where they can be.
+  # (Politics, then this joke, then back again, finally "Oh, bye I have to go!")
+  #
+  # In James, though, it is much simpler.
+  # We just have a visitor in an entry scenario
+  # (James!, Sleep, Wake up, Something completely different)
+  # and one in any specific user-given scenario.
+  #
+  # Visitors is a proxy object for visitors.
+  #
+  class Visitors
+
+    attr_reader :visitors
+
+    def initialize *visitors
+      @visitors = visitors
+    end
+
+    def hear phrase, &block
+      visitors.each do |visitor|
+        visitor.hear phrase, &block and break
+      end
+    end
+
+    def expects
+      visitors.inject([]) { |expects, visitor| expects + visitor.expects }
+    end
+
+  end
+
+end

data/lib/old/main.rb

@@ -0,0 +1,30 @@
+# Instead of this, check for __main__.
+#
+
+require File.expand_path '../../james', __FILE__
+
+app = NSApplication.sharedApplication
+app.delegate = James::Controller.new
+
+# window = NSWindow.alloc.initWithContentRect([200, 300, 300, 100],
+#     styleMask:NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask,
+#     backing:NSBackingStoreBuffered,
+#     defer:false)
+# window.title      = 'MacRuby: The Definitive Guide'
+# window.level      = 3
+# window.delegate   = app.delegate
+#
+# button = NSButton.alloc.initWithFrame([80, 10, 120, 80])
+# button.bezelStyle = 4
+# button.title      = 'Hello World!'
+# button.target     = app.delegate
+# button.action     = 'say_hello:'
+#
+# window.contentView.addSubview(button)
+#
+# window.display
+# window.orderFrontRegardless
+
+app.delegate.applicationDidFinishLaunching nil
+
+app.run

data/lib/old/main_dialogue.rb

@@ -0,0 +1,47 @@
+module James
+
+  # This is the default main dialogue.
+  #
+  # It is a proxy to the internal dialogues.
+  #
+  class MainDialogue
+    include Dialogue
+
+    hear 'wake up james' => :awake
+
+    # Create Protostate with block. Then, create instance instance_evaling block.
+    #
+    state :awake do
+      hear 'sleep james' => :sleeping
+      hear 'my options?' { |the_next| the_next.phrases.join ' ' }
+      into { "At your service" }
+      exit { "Right away" }
+    end
+
+    state :sleeping do
+      hear 'wake up james' => :awake
+      into { "Good night, Sir" }
+    end
+
+    # state :awake, {
+    #   'sleep james' => :sleeping
+    #   # 'james, my options?' => lambda { || } # stays in this state but executes.
+    # }
+    # state :sleeping, {
+    #   'wake up james' => :awake
+    # }
+    # entry 'wake up james' => :awake
+    #
+    # def enter_sleeping
+    #   "Good night, Sir"
+    # end
+    # def enter_awake
+    #   "At your service"
+    # end
+    # def exit_awake
+    #   "Right away"
+    # end
+
+  end
+
+end

data/spec/integration/test_dialogue_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+#
+require File.expand_path '../../../lib/james', __FILE__
+
+describe 'TestDialogue' do
+
+  context 'unit' do
+    let(:dialogue) do
+
+      Class.new do
+        include James::Dialog
+
+        hear ['test1', 'test2'] => :first
+        
+        state :first do
+          hear 'go' => :second, 'stay' => :first
+        end
+        
+        state :second do
+          hear 'go' => :third, 'back' => :first
+        end
+      end.new
+
+    end
+    let(:visitor) do
+      James::Visitor.new dialogue.state_for(:first)
+    end
+
+    describe "integration" do
+      it 'works correctly' do
+        visitor.current.name.should == :first
+        visitor.hear('go') {}
+        visitor.current.name.should == :second
+        visitor.hear('back') {}
+        visitor.current.name.should == :first
+        visitor.hear('stay') {}
+        visitor.current.name.should == :first
+      end
+      it 'calls the entrance/exits correctly' do
+        dialogue.should_receive(:respond_to?).once.with(:enter_second).and_return true
+        dialogue.should_receive(:enter_second).once
+
+        dialogue.should_receive(:respond_to?).once.with(:exit_second).and_return true
+        dialogue.should_receive(:exit_second).once
+
+        dialogue.should_receive(:respond_to?).once.with(:enter_first).and_return true
+        dialogue.should_receive(:enter_first).once
+
+        dialogue.should_receive(:respond_to?).once.with(:exit_first).and_return true
+        dialogue.should_receive(:exit_first).once
+
+        visitor.hear 'go'
+        visitor.hear 'back'
+      end
+    end
+  end
+  
+  # context 'integration' do
+  #   let(:dialogue) do
+  #     dialogue = Class.new do
+  #       include James::Dialog
+  # 
+  #       hear ['test1', 'test2'] => :first
+  #       state :first do
+  #         hear 'go' => :second, 'stay' => :first
+  #       end
+  #       state :second do
+  #         hear 'go' => :third, 'back' => :first
+  #       end
+  #     end.new
+  #   end
+  #   it 'works correctly' do
+  #     dialogue.state.name.should == :awake
+  #     dialogue.hear 'sleep'
+  #     dialogue.state.name.should == :sleeping
+  #   end
+  #   it 'delegates correctly' do
+  #     dialogue.state.name.should == :awake
+  #     dialogue.hear 'test1'
+  #   end
+  # end
+
+end

data/spec/lib/james/dialogue_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+#
+require File.expand_path '../../../../lib/james/dialogue_api', __FILE__
+require File.expand_path '../../../../lib/james/dialogue_internals', __FILE__
+
+describe James::Dialogue do
+  
+  it 'can haz merkin spellink' do
+    James::Dialogue.should == James::Dialog
+  end
+  
+  context 'units' do
+    let(:dialogue) do
+      James.dialogue do
+        
+        hear 'something' => :first
+        
+        state :first do
+          hear 'something else' => :second
+          into {}
+          exit {}
+        end
+        
+        state :second do
+          hear 'yet something else' => :first
+          into {}
+          exit {}
+        end
+        
+      end
+    end
+    describe 'state_for' do
+      it 'delegates to the class, adding itself' do
+        new_dialogue = dialogue.new
+        dialogue.should_receive(:state_for).once.with :some_name, new_dialogue
+        
+        new_dialogue.state_for :some_name
+      end
+      it 'returns nil on not found' do
+        dialogue.new.state_for(:nonexistent).should == nil
+      end
+    end
+  end
+  
+  describe 'initialization' do
+    it 'can be included' do
+      expect do
+        class Test
+          include James::Dialogue
+          
+          hear 'something' => :some_state
+        end
+      end.to_not raise_error
+    end
+    
+    it 'can be defined' do
+      expect do
+        James.dialogue do
+          
+          hear 'something' => :some_state
+          
+        end
+      end.to_not raise_error
+    end
+    it 'can haz merkin spellink' do
+      expect do
+        James.dialog do
+          
+          hear 'something' => :some_state
+          
+        end
+      end.to_not raise_error
+    end
+  end
+  
+end

data/spec/lib/james/state_spec.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+#
+require File.expand_path '../../../../lib/james/state_api', __FILE__
+require File.expand_path '../../../../lib/james/state_internals', __FILE__
+
+describe James::State do
+  
+  before(:all) do
+    @context = stub :context,
+                    :inspect => 'some_context'
+    class << @context
+      
+      def state_for name
+        {
+          :next_state1 => :some_state_object1,
+          :next_state2 => :some_state_object2,
+          :next_state3 => :some_state_object3,
+        }[name]
+      end
+      
+    end
+  end
+  
+  context 'with no transitions or into or exit' do
+    let(:state) do
+      described_class.new :some_name, @context do
+        # Nothing to see here.
+      end
+    end
+    describe 'phrases' do
+      it { state.phrases.should == [] }
+    end
+    describe 'to_s' do
+      it { state.to_s.should == 'James::State(some_name, some_context, {})' }
+    end
+    describe 'next_for' do
+      it { state.next_for('non-existent').should == nil }
+    end
+    describe 'expand' do
+      it do
+        state.expand([:a, :b] => 1).should == { :a => 1, :b => 1 }
+      end
+      it do
+        state.expand(:a => 1).should == { :a => 1 }
+      end
+    end
+    describe '__into__' do
+      it 'is called' do
+        state.__into__.should == nil
+      end
+    end
+    describe '__exit__' do
+      it 'is conditionally called' do
+        state.__exit__.should == nil
+      end
+    end
+  end
+  
+  context 'of the context' do
+    let(:state) do
+      described_class.new :some_name, @context do
+        hear 'transition one' => :next_state1
+        into { self }
+        exit { self }
+      end
+    end
+    describe '__into__' do
+      it 'is called' do
+        state.__into__.should == @context
+      end
+    end
+    describe '__exit__' do
+      it 'is conditionally called' do
+        state.__exit__.should == @context
+      end
+    end
+  end
+  
+  context 'with 1 transition and into and exit' do
+    let(:state) do
+      described_class.new :some_name, @context do
+        hear 'transition one' => :next_state1
+        into { "hi there" }
+        exit { "good bye" }
+      end
+    end
+    describe 'phrases' do
+      it { state.phrases.should == ['transition one'] }
+    end
+    describe 'to_s' do
+      it { state.to_s.should == 'James::State(some_name, some_context, {"transition one"=>:next_state1})' }
+    end
+    describe 'next_for' do
+      it { state.next_for('transition one').should == :some_state_object1 }
+      it { state.next_for('non-existent').should == nil }
+    end
+    describe '__into__' do
+      it 'is called' do
+        state.__into__.should == 'hi there'
+      end
+    end
+    describe '__exit__' do
+      it 'is conditionally called' do
+        state.__exit__.should == 'good bye'
+      end
+    end
+  end
+  
+  context 'with multiple transition' do
+    let(:state) do
+      described_class.new :some_name, @context do
+        hear 'transition one'   => :next_state1,
+             'transition two'   => :next_state2,
+             'transition three' => :next_state3
+      end
+    end
+    describe 'phrases' do
+      it { state.phrases.should == ['transition one', 'transition two', 'transition three'] }
+    end
+    describe 'to_s' do
+      it { state.to_s.should == 'James::State(some_name, some_context, {"transition one"=>:next_state1, "transition two"=>:next_state2, "transition three"=>:next_state3})' }
+    end
+    it { state.next_for('transition two').should == :some_state_object2 }
+    it { state.next_for('non-existent').should == nil }
+  end
+  
+end

data/spec/lib/james/visitor_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+#
+require File.expand_path '../../../../lib/james/visitor', __FILE__
+
+describe James::Visitor do
+  
+  let(:initial) { stub :state }
+  let(:timer)   { stub :timer }
+  let(:visitor) { described_class.new initial, timer }
+  
+  describe 'current' do
+    it { visitor.current.should == initial }
+  end
+  
+  describe 'enter' do
+    it 'calls enter on the state' do
+      initial.should_receive(:__into__).once
+      
+      visitor.enter
+    end
+    it 'returns the result' do
+      initial.stub! :__into__ => 'some text'
+      
+      visitor.enter.should == 'some text'
+    end
+    it 'yields the result' do
+      initial.stub! :__into__ => 'some text'
+      
+      visitor.enter do |text|
+        text.should == 'some text'
+      end
+    end
+  end
+  
+  describe 'exit' do
+    it 'calls enter on the state' do
+      initial.should_receive(:__exit__).once.with
+      
+      visitor.exit
+    end
+    it 'returns the result' do
+      initial.stub! :__exit__ => 'some text'
+      
+      visitor.exit.should == 'some text'
+    end
+    it 'yields the result' do
+      initial.stub! :__exit__ => 'some text'
+      
+      visitor.exit do |text|
+        text.should == 'some text'
+      end
+    end
+  end
+  
+  describe 'transition' do
+    it 'sets the current state' do
+      initial.stub! :next_for => :some_state
+      
+      visitor.transition 'some phrase'
+      
+      visitor.current.should == :some_state
+    end
+  end
+  
+  describe 'escape' do
+    it 'calls methods in order' do
+      timer.should_receive(:stop).once.with
+      visitor.should_receive(:current=).once.with initial
+      
+      visitor.escape
+    end
+  end
+  
+  describe 'hear' do
+    it 'calls methods in order' do
+      visitor.should_receive(:hears?).once.ordered.with(:some_phrase).and_return true
+      timer.should_receive(:restart).once.ordered.with
+      visitor.should_receive(:exit).once.ordered.with
+      visitor.should_receive(:transition).once.ordered.with :some_phrase
+      # visitor.should_receive(:check).once.ordered.with
+      visitor.should_receive(:enter).once.ordered.with
+      
+      visitor.hear :some_phrase
+    end
+  end
+end

data/spec/lib/james/visitors_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+#
+require File.expand_path '../../../../lib/james/visitors', __FILE__
+
+describe James::Visitors do
+  
+  let(:first)    { stub :first  }
+  let(:second)   { stub :second }
+  let(:visitors) { described_class.new first, second }
+  
+  describe 'hear' do
+    context 'the first has it' do
+      before(:each) do
+        first.stub!  :hear => :something
+        second.stub! :hear => nil
+      end
+      it 'works' do
+        visitors.hear 'some phrase'
+      end
+      it 'calls the second never' do
+        first.should_receive(:hear).once.and_return true
+        second.should_receive(:hear).never
+        
+        visitors.hear 'some phrase'
+      end
+    end
+    context 'the second has it' do
+      before(:each) do
+        first.stub!  :hear => nil
+        second.stub! :hear => :something
+      end
+      it 'works' do
+        visitors.hear 'some phrase'
+      end
+      it 'calls the first hear first' do
+        first.should_receive(:hear).once.ordered.with 'some phrase'
+        second.should_receive(:hear).once.ordered.with 'some phrase'
+        
+        visitors.hear 'some phrase'
+      end
+    end
+  end
+  
+  describe 'expects' do
+    before(:each) do
+      first.stub!  :expects => [:a, :b]
+      second.stub! :expects => [:c, :d, :e]
+    end
+    it { visitors.expects.should == [:a, :b, :c, :d, :e] }
+  end
+
+end

metadata

@@ -5,16 +5,16 @@ version: !ruby/object:Gem::Version
   segments:
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: universal-darwin-10
 authors:
 - Florian Hanke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-05-05 00:00:00 +10:00
-default_executable: 
+date: 2011-05-09 00:00:00 +10:00
+default_executable: james
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -37,11 +37,31 @@ dependencies:
 description: Modular Electronic Butler. Add Dialog(ue)s to it to add more abilities
   to it.
 email: florian.hanke+james@gmail.com
-executables: []
+executables:
+- james
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/james/builtin/main_dialogue.rb
+- lib/james/controller.rb
+- lib/james/dialogue_api.rb
+- lib/james/dialogue_internals.rb
+- lib/james/dialogues.rb
+- lib/james/inputs/audio.rb
+- lib/james/inputs/base.rb
+- lib/james/inputs/terminal.rb
+- lib/james/main_dialogue.rb
+- lib/james/outputs/audio.rb
+- lib/james/outputs/terminal.rb
+- lib/james/state_api.rb
+- lib/james/state_internals.rb
+- lib/james/timer.rb
+- lib/james/visitor.rb
+- lib/james/visitors.rb
 - lib/james.rb
+- lib/old/main.rb
+- lib/old/main_dialogue.rb
+- aux/james/cli.rb
 has_rdoc: true
 homepage: http://floere.github.com/james
 licenses: []
@@ -69,4 +89,9 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: 'James: Modular Electronic Butler.'
-test_files: []
+test_files:
+- spec/integration/test_dialogue_spec.rb
+- spec/lib/james/dialogue_spec.rb
+- spec/lib/james/state_spec.rb
+- spec/lib/james/visitor_spec.rb
+- spec/lib/james/visitors_spec.rb