james 0.5.0

data/aux/james/cli.rb

@@ -0,0 +1,54 @@
+require File.expand_path '../../../lib/james', __FILE__
+
+module James
+
+  class CLI
+
+    def execute *patterns
+      options = extract_options patterns
+
+      dialogs = find_dialogs_for patterns
+
+      puts "James: I haven't found anything to talk about (No files found). Exiting." or exit!(1) if dialogs.empty?
+      puts "James: Using dialogs in #{dialogs.join(', ')} for our conversation, Sir."
+
+      load_all dialogs
+
+      James.listen options
+    end
+
+    # Defines default options and extracts options from
+    # command line.
+    #
+    # Sadly needs to be run before processing the dialog file names.
+    #
+    def extract_options patterns
+      silent        = patterns.delete '-s'
+      silent_input  = patterns.delete '-si'
+      silent_output = patterns.delete '-so'
+
+      options = {}
+      options[:input]  = Inputs::Terminal  if silent || silent_input
+      options[:output] = Outputs::Terminal if silent || silent_output
+
+      options
+    end
+
+    #
+    #
+    def find_dialogs_for patterns
+      patterns = ["**/*_dialog{,ue}.rb"] if patterns.empty?
+      Dir[*patterns]
+    end
+
+    #
+    #
+    def load_all dialogs
+      dialogs.each do |dialog|
+        load File.expand_path dialog, Dir.pwd
+      end
+    end
+
+  end
+
+end

data/bin/james

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+
+# james joke_dialog.rb phonebook_dialog.rb quote_dialog.rb # Uses just the described ones.
+# OR
+# james j*.rb # Uses all the dialogs matching the pattern.
+# OR
+# james # Uses all dialogs it can find in this dir and subdirs.
+#
+# Options:
+#  * -s  # Silent input and output (same as "-si -so").
+#  * -si # Silent input.
+#  * -so # Silent output.
+#
+
+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,50 @@
+module James; end
+
+require File.expand_path '../james/state_api', __FILE__
+require File.expand_path '../james/state_internals', __FILE__
+
+require File.expand_path '../james/markers/marker', __FILE__
+require File.expand_path '../james/markers/current', __FILE__
+require File.expand_path '../james/markers/memory', __FILE__
+require File.expand_path '../james/conversation', __FILE__
+
+require File.expand_path '../james/dialog_api', __FILE__
+require File.expand_path '../james/dialog_internals', __FILE__
+
+require File.expand_path '../james/dialogs', __FILE__
+
+require File.expand_path '../james/inputs/base', __FILE__
+require File.expand_path '../james/inputs/audio', __FILE__
+require File.expand_path '../james/inputs/terminal', __FILE__
+
+require File.expand_path '../james/outputs/audio', __FILE__
+require File.expand_path '../james/outputs/terminal', __FILE__
+
+require File.expand_path '../james/builtin/core_dialog', __FILE__
+
+require File.expand_path '../james/framework', __FILE__
+require File.expand_path '../james/controller', __FILE__
+
+module James
+
+  # Use the given dialogs.
+  #
+  # If called twice or more, will just add more dialogs.
+  #
+  def self.use *dialogs
+    dialogs.each { |dialog| controller << dialog}
+  end
+
+  # Start listening.
+  #
+  def self.listen options
+    controller.listen options
+  end
+
+  # Controller instance.
+  #
+  def self.controller
+    Controller.instance
+  end
+
+end

data/lib/james/builtin/core_dialog.rb

@@ -0,0 +1,52 @@
+# This is the core dialog every dialog will be hooking into.
+#
+# Eventually, the design should be such that everyone can use
+# the design and core dialog they like best.
+#
+# But to get going, this suffices for now.
+#
+class CoreDialog
+
+  include James::Dialog
+
+  # This core dialog starts at awake.
+  #
+  initially :awake
+
+  # The alert state.
+  # When James is in this state, he should be
+  # open for user dialogs.
+  #
+  state :awake do
+    # If James is awake, he offers more dialogs
+    # on this state, if there are any hooked into this state.
+    #
+    chainable
+
+    hear "Thank you, James."              => :awake,
+         'I need some time alone, James.' => :away,
+         "Good night, James."             => :exit
+    into { "Sir?" }
+  end
+
+  # The away state. James does not listen to any
+  # user dialog hooks, but only for his name
+  # or the good night, i.e. exit phrase.
+  #
+  state :away do
+    hear 'James?'             => :awake,
+         "Good night, James." => :exit
+    into { "Of course, Sir!" }
+  end
+
+  # This is not a real state. It just exists to Kernel.exit
+  # James when he enters this state.
+  #
+  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,106 @@
+module James
+
+  class Controller
+
+    attr_reader :conversation, :listening, :initial
+
+    # Singleton reader.
+    #
+    def self.instance
+      @controller ||= new
+    end
+
+    # This puts together the initial dialog and the user
+    # ones that are hooked into it.
+    #
+    # The initial dialog needs an state defined as initially.
+    # This is where it will start.
+    #
+    # Example:
+    #   initially :awake
+    #   state :awake do
+    #     # ...
+    #   end
+    #
+    # If you don't give it an initial dialog,
+    # James will simply use the built-in CoreDialog.
+    #
+    def initialize dialog = nil
+      @initial      = dialog || CoreDialog.new
+      @conversation = Conversation.new @initial.current
+    end
+
+    # Convenience method to add a dialog to the current system.
+    #
+    # Will add the dialog to the initial dialog passed into the
+    # controller.
+    #
+    def << dialog
+      @initial << dialog
+    end
+
+    # Start listening using the provided options.
+    #
+    # Options:
+    #  * input  # Inputs::Terminal or Inputs::Audio (default).
+    #  * output # Outputs::Terminal or Outputs::Audio (default).
+    #
+    def listen options = {}
+      return if listening
+
+      @listening = true
+
+      @input_class    = options[:input]  || Inputs::Audio
+      @output_class   = options[:output] || Outputs::Audio
+
+      @output_options ||= {}
+      @output_options[:voice] = options[:voice] || 'com.apple.speech.synthesis.voice.Alex'
+
+      app = NSApplication.sharedApplication
+      app.delegate = self
+
+      app.run
+    end
+
+    # The naughty privates of this class.
+    #
+
+      # MacRuby callback functions.
+      #
+      def applicationDidFinishLaunching notification
+        start_output
+        start_input
+      end
+      def windowWillClose notification
+        exit
+      end
+
+      # Start recognizing words.
+      #
+      def start_input
+        @input = @input_class.new self
+        @input.listen
+      end
+      # Start speaking.
+      #
+      def start_output
+        @output = @output_class.new @output_options
+      end
+
+      # Callback method from dialog.
+      #
+      def say text
+        @output.say text
+      end
+      def hear text
+        conversation.hear text do |response|
+          say response
+        end
+      end
+      def expects
+        conversation.expects
+      end
+
+  end
+
+end

data/lib/james/conversation.rb

@@ -0,0 +1,62 @@
+module James
+
+  # A conversation has a number of markers (position in dialog),
+  # whose dialogs are visited in order of preference.
+  #
+  # Why?
+  # Conversations have multiple points where they can be.
+  # (Politics, then this joke, then back again, finally "Oh, bye I have to go!")
+  #
+  class Conversation
+
+    attr_accessor :markers
+
+    # A Conversation keeps a stack of markers with
+    # an initial one.
+    #
+    def initialize initial
+      @markers = [initial]
+    end
+
+    # Hear tries all visitors in order
+    # until one hears a phrase he knows.
+    #
+    # If a dialog boundary has been crossed:
+    # A new visitor is added with the target
+    # state of that heard phrase at the position.
+    #
+    # After that, all remaining visitors are
+    # removed from the current stack (since
+    # we are obviously not in one of the later
+    # dialogs anymore).
+    #
+    def hear phrase, &block
+      self.markers = markers.inject([]) do |remaining, marker|
+        markers = marker.hear phrase, &block
+        remaining = remaining + markers
+        break remaining if remaining.last && remaining.last.current?
+        remaining
+      end
+    end
+
+    # Enter enters the first visitor.
+    #
+    def enter
+      markers.first.enter
+    end
+
+    # Simply returns the sum of what phrases all dialogs do expect, front-to-back.
+    #
+    # Stops as soon as a marker is not on a chainable state anymore.
+    #
+    def expects
+      markers.inject([]) do |expects, marker|
+        total = marker.expects + expects
+        break total unless marker.chainable?
+        total
+      end
+    end
+
+  end
+
+end

data/lib/james/dialog_api.rb

@@ -0,0 +1,38 @@
+module James
+
+  # A dialog can be instantiated in two ways:
+  #
+  # The simple way will directly add itself to James.
+  #
+  # James.dialog(optional_args_for_initialize) do
+  #   # Your dialog.
+  #   #
+  # end
+  #
+  # class MyDialog
+  #
+  #   include James::Dialog
+  #
+  #   # Your dialog definition.
+  #   #
+  #
+  # end
+  #
+  # # Tell James to use the dialog.
+  # #
+  # James.use MyDialog.new
+  #
+  module Dialog; end
+
+  class << self
+
+    def dialog *args, &block
+      dialog = Class.new { include James::Dialog }
+      dialog.class_eval &block
+      use dialog.new(*args)
+      dialog
+    end
+
+  end
+
+end

data/lib/james/dialog_internals.rb

@@ -0,0 +1,105 @@
+module James
+
+  # A dialog is just a container object
+  # for defining states and executing methods.
+  #
+  module Dialog
+
+    def self.included into
+      into.extend ClassMethods
+    end
+
+    # Returns a state instance for the given state / or state name.
+    #
+    # Note: Lazily creates the state instances.
+    #
+    def state_for possible_state
+      return possible_state if possible_state.respond_to?(:expects)
+      self.class.state_for possible_state, self
+    end
+
+    # Chain (the states of) this dialog to the given state.
+    #
+    # Creates state instances if it is given names.
+    #
+    # Note: Be careful not to create circular
+    #       state chaining. Except if you really
+    #       want that.
+    #
+    def chain_to state
+      warn "Define a hear => :some_state_name in a dialog to have it be able to chain to another." && return unless respond_to?(:entry_phrases)
+      entry_phrases.each do |(phrases, entry_state)|
+        state.hear phrases => state_for(entry_state)
+      end
+    end
+
+    # Chain the given Dialog(s) to all chainable
+    # states in this Dialog.
+    #
+    # Note: If you only want one state to chain,
+    #       then get it from the otiginating dialog
+    #       using dialog.state_for(:name) and
+    #       append the dialog there:
+    #       dialog.follows preceding_dialog.state_for(:name)
+    #
+    def << dialog_s
+      self.class.states.each do |(name, definition)|
+        state = state_for name # TODO Do not call this everywhere.
+        dialog_s.chain_to(state) if state.chainable?
+      end
+    end
+
+    module ClassMethods
+
+      def initially state_name
+        define_method :current do
+          Markers::Current.new state_for(state_name)
+        end
+      end
+
+      # Defines the entry phrases into this dialog.
+      #
+      # Example:
+      #   hear 'Hello, James!' => :start
+      #
+      def hear definition
+        define_method :entry_phrases do
+          definition
+        end
+      end
+
+      # Defines a state with transitions.
+      #
+      # Example:
+      #   state :name do
+      #     # state properties (hear, into, exit) go here.
+      #   end
+      #
+      def state name, &block
+        @states       ||= {}
+        @states[name] ||= block if block_given?
+        define_method name do
+          state_for name
+        end unless instance_methods.include? name
+      end
+
+      #
+      #
+      attr_reader :states
+
+      # Return a state for this name (and dialog instance).
+      #
+      def state_for name, instance
+        # Lazily wrap in State instance.
+        #
+        if states[name].respond_to?(:call)
+          states[name] = State.new(name, instance, &states[name])
+        end
+        states[name]
+      end
+
+    end
+
+  end
+
+end

data/lib/james/dialogs.rb

@@ -0,0 +1,21 @@
+module James
+
+  # Bundles a bunch of dialogs.
+  #
+  class Dialogs
+
+    attr_reader :dialogs
+
+    def initialize *dialogs
+      @dialogs = dialogs
+    end
+
+    #
+    #
+    def chain_to incoming_dialog
+      dialogs.each { |dialog| incoming_dialog << dialog }
+    end
+
+  end
+
+end

data/lib/james/framework.rb

@@ -0,0 +1 @@
+framework 'AppKit'

data/lib/james/inputs/audio.rb

@@ -0,0 +1,47 @@
+module James
+
+  module Inputs
+
+    class Audio < Base
+
+      def initialize controller
+        super controller
+        @recognizer = NSSpeechRecognizer.alloc.init
+        @recognizer.setBlocksOtherRecognizers true
+        @recognizer.setListensInForegroundOnly false
+        @recognizer.setDelegate self
+      end
+
+      def listen
+        @recognizer.startListening
+        recognize_new_commands
+      end
+      def heard command
+        super
+
+        # Set recognizable commands.
+        #
+        recognize_new_commands
+      end
+
+      # Callback method from the speech interface.
+      #
+      # Note: Uses a MacRuby only form.
+      #
+      def speechRecognizer sender, didRecognizeCommand: command
+        heard command
+      end
+      def recognize_new_commands
+        possibilities = controller.expects
+        puts "Possibilities:\n"
+        possibilities.each_with_index do |possibility, index|
+          puts "#{index + 1})  #{possibility}"
+        end
+        @recognizer.setCommands possibilities
+      end
+
+    end
+
+  end
+
+end

data/lib/james/inputs/base.rb

@@ -0,0 +1,32 @@
+module James
+
+  module Inputs
+
+    class Base
+
+      attr_reader :controller
+
+      def initialize controller
+        @controller = controller
+      end
+
+      # Call this method if you heard something in the subclass.
+      #
+      def heard command
+        controller.hear command
+      end
+
+      # Shows possible commands in the terminal.
+      #
+      def show_possibilities possibilities
+        puts "Possibilities:\n"
+        possibilities.each_with_index do |possibility, index|
+          puts "#{index + 1})  #{possibility}"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/james/inputs/terminal.rb

@@ -0,0 +1,37 @@
+module James
+
+  module Inputs
+
+    # Terminal input for silent purposes.
+    #
+    class Terminal < Base
+
+      # Start listening to commands by the user.
+      #
+      def listen
+        sleep 2
+        loop do
+          possibilities = controller.expects
+          show_possibilities possibilities
+          command = get_command
+          puts "I heard '#{command}'."
+          command = possibilities[command.to_i-1] unless command.to_i.zero?
+          heard command if possibilities.include? command
+        end
+      end
+
+      # Get the next command by the user.
+      #
+      def get_command
+        STDIN.gets.chop
+      rescue IOError
+        puts "Wait a second, please, Sir, I am busy."
+        sleep 1
+        retry
+      end
+
+    end
+
+  end
+
+end

data/lib/james/markers/current.rb

@@ -0,0 +1,34 @@
+module James
+
+  module Markers
+
+    # The visitor knows where in the conversation we are.
+    #
+    class Current < Marker
+
+      # Hear a phrase.
+      #
+      # Returns a new marker and self if it crossed a boundary.
+      # Returns itself if not.
+      #
+      def hear phrase, &block
+        return [self] unless hears? phrase
+        last = current
+        process(phrase, &block) ? [Memory.new(last), self] : [self]
+      end
+
+      # Expects all phrases, not just internal.
+      #
+      def expects
+        current.expects
+      end
+
+      def current?
+        true
+      end
+
+    end
+
+  end
+
+end

data/lib/james/markers/marker.rb

@@ -0,0 +1,94 @@
+module James
+
+  module Markers
+
+    # A marker is a point in conversation
+    # where we once were and might go back.
+    #
+    # TODO: Rename to ?.
+    #
+    class Marker
+
+        attr_accessor :current
+
+        # Pass in an current state.
+        #
+        def initialize current
+          @current = current
+        end
+
+        # Resets the current state back to the initial.
+        #
+        def reset
+          # Never moves, thus never reset.
+        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
+          state_or_lambda = current.next_for phrase
+          if state_or_lambda.respond_to?(:call)
+            result = current.__transition__ &state_or_lambda # Don't transition.
+            yield result if result && block_given?
+            result
+          else
+            self.current = state_or_lambda
+          end
+        end
+
+        #
+        #
+        def check
+          yield("Whoops. That led nowhere. Perhaps you didn't define the target state?") unless self.current
+        end
+
+        # Returns falsy if it stays the same.
+        #
+        def process phrase, &block
+          exit_text = exit &block
+          last_context = current.context
+          transition phrase, &block
+          check &block
+          into_text = enter &block
+          last_context != current.context
+        end
+
+        #
+        #
+        def hears? phrase
+          expects.include? phrase
+        end
+
+        # Does the current state allow penetration into another dialog?
+        #
+        def chainable?
+          current.chainable?
+        end
+
+        def to_s
+          "#{self.class.name}(#{initial}, current: #{current})"
+        end
+
+      end
+
+    end
+
+end

data/lib/james/markers/memory.rb

@@ -0,0 +1,37 @@
+module James
+
+  module Markers
+
+    # A marker is a point in conversation
+    # where we once were and might go back.
+    #
+    # TODO: Rename to ?.
+    #
+    class Memory < Marker
+
+        # Hear a phrase.
+        #
+        # Returns a new Current if it heard.
+        # Returns itself if not.
+        #
+        def hear phrase, &block
+          return [self] unless hears? phrase
+          last = current
+          process(phrase, &block) ? [Memory.new(last), Current.new(current)] : [Current.new(current)]
+        end
+
+        # A marker does not care about phrases that cross dialog boundaries.
+        #
+        def expects
+          current.internal_expects
+        end
+
+        def current?
+          false
+        end
+
+      end
+
+    end
+
+end

data/lib/james/outputs/audio.rb

@@ -0,0 +1,31 @@
+module James
+
+  module Outputs
+
+    class Audio
+
+      # Create a new audio output.
+      #
+      # Options:
+      #  * voice # Default is 'com.apple.speech.synthesis.voice.Alex'.
+      #
+      def initialize options = {}
+        @output = NSSpeechSynthesizer.alloc.initWithVoice options[:voice] || 'com.apple.speech.synthesis.voice.Alex'
+      end
+
+      # Say the given text out loud.
+      #
+      # Waits for the last text to be finished
+      #
+      def say text
+        while @output.isSpeaking
+          sleep 0.1
+        end
+        @output.startSpeakingString text
+      end
+
+    end
+
+  end
+
+end

data/lib/james/outputs/terminal.rb

@@ -0,0 +1,27 @@
+module James
+
+  module Outputs
+
+    # Terminal output for silent purposes.
+    #
+    class Terminal
+
+      #
+      #
+      def initialize options = {}
+
+      end
+
+      # Say the given text in the terminal.
+      #
+      def say text
+        puts
+        p text
+        puts
+      end
+
+    end
+
+  end
+
+end

data/lib/james/state_api.rb

@@ -0,0 +1,123 @@
+module James
+
+  # A state is defined in a dialog.
+  #
+  # 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.
+    #
+    # Example for staying in the same state and doing something:
+    #   hear 'What time is it?' => ->() { "I'm staying in the same state" }
+    #
+    def hear transitions
+      transitions = { transitions => name } unless transitions.respond_to?(:to_hash)
+      @transitions = expand(transitions).merge @transitions
+    end
+
+    # Execute this block or say the text when entering this state.
+    #
+    # Examples:
+    #   into "Yes, Sir?"
+    #   into { "A random number is #{rand(10)}" }
+    #
+    def into text = nil, &block
+      @into_block = block ||
+                    text && lambda { text } ||
+                    raise_no_text_or_block(__method__)
+    end
+
+    # Execute this block or say the text when exiting this state.
+    #
+    # Examples:
+    #   exit "Yes, Sir?"
+    #   exit { "A random number is #{rand(10)}" }
+    #
+    def exit text = nil, &block
+      @exit_block = block ||
+                    text && lambda { text } ||
+                    raise_no_text_or_block(__method__)
+    end
+
+    # Chain the given dialog to this state.
+    #
+    def << dialog
+      dialog.chain_to self
+    end
+
+    # A chainable state is a state from which other
+    # Dialogs can be reached.
+    #
+    def chainable
+      @chainable = true
+    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
+
+      # Raise an ArgumentError for the given method if it needs either a text or a block.
+      #
+      def raise_no_text_or_block on_method
+        raise ArgumentError.new("Neither block nor text given to ##{on_method} call in #{caller[1]}.")
+      end
+
+      # By default, a state is not chainable.
+      #
+      def chainable?
+        !!@chainable
+      end
+
+  end
+
+end

data/lib/james/state_internals.rb

@@ -0,0 +1,59 @@
+module James
+
+  class State
+
+    # Transitions are internal transitions & external transitions.
+    #
+    def transitions
+      @transitions
+    end
+
+    #
+    #
+    def expects
+      transitions.keys
+    end
+
+    #
+    #
+    def internal_expects
+      transitions.select { |phrase, target| target.respond_to?(:to_sym) || target == self.context }.keys
+    end
+
+
+    # Returns the next state for the given phrase.
+    #
+    # It accesses the context (aka Dialog) to get a full object state.
+    #
+    # If it is a Symbol, James will try to get the real state.
+    # If not, it will just return it (a State already, or lambda).
+    #
+    def next_for phrase
+      state = self.transitions[phrase]
+      state.respond_to?(:id2name) ? context.state_for(state) : state
+    end
+
+    # The naughty privates.
+    #
+
+      # Called by the visitor visiting this state.
+      #
+      def __into__
+        @into_block && context.instance_eval(&@into_block)
+      end
+
+      # Called by the visitor visiting this state.
+      #
+      def __exit__
+        @exit_block && context.instance_eval(&@exit_block)
+      end
+
+      # Called by the visitor visiting this state.
+      #
+      def __transition__ &block
+        context.instance_eval &block
+      end
+
+  end
+
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: james
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Florian Hanke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-15 00:00:00 +10:00
+default_executable: james
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Modular Electronic Butler. Using a simple dialog system where you can easily add more dialogs.
+email: florian.hanke+james@gmail.com
+executables: 
+- james
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/james/builtin/core_dialog.rb
+- lib/james/controller.rb
+- lib/james/conversation.rb
+- lib/james/dialog_api.rb
+- lib/james/dialog_internals.rb
+- lib/james/dialogs.rb
+- lib/james/framework.rb
+- lib/james/inputs/audio.rb
+- lib/james/inputs/base.rb
+- lib/james/inputs/terminal.rb
+- lib/james/markers/current.rb
+- lib/james/markers/marker.rb
+- lib/james/markers/memory.rb
+- lib/james/outputs/audio.rb
+- lib/james/outputs/terminal.rb
+- lib/james/state_api.rb
+- lib/james/state_internals.rb
+- lib/james.rb
+- aux/james/cli.rb
+- bin/james
+has_rdoc: true
+homepage: http://floere.github.com/james
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: "James: Modular Electronic Butler with modular Dialogs."
+test_files: []
+