larynx 0.1.5 → 0.1.6

data/bin/larynx

@@ -5,3 +5,4 @@ unless defined?(Gem)
 end
 
 require 'larynx'
+Larynx::Server.boot

data/lib/larynx.rb

@@ -1,11 +1,10 @@
 require 'rubygems'
 require 'eventmachine'
 require 'active_support'
-require 'logger'
-require 'daemons/daemonize'
 
 require 'larynx/version'
 require 'larynx/logger'
+require 'larynx/server'
 require 'larynx/observable'
 require 'larynx/callbacks'
 require 'larynx/callbacks_with_async'
@@ -15,7 +14,7 @@ require 'larynx/command'
 require 'larynx/commands'
 require 'larynx/prompt'
 require 'larynx/application'
-require 'larynx/fields'
+require 'larynx/field'
 require 'larynx/form'
 require 'larynx/restartable_timer'
 require 'larynx/call_handler'
@@ -23,97 +22,9 @@ require 'larynx/call_handler'
 module Larynx
   class << self
     include Callbacks
-
     define_callback :connect, :answer, :hungup
-
-    def parse_options(args=ARGV)
-      @options = {
-        :ip       => "0.0.0.0",
-        :port     => 8084,
-        :pid_file => "./larynx.pid",
-        :log_file => "./larynx.log"
-      }
-      opts = OptionParser.new
-      opts.banner = "Usage: larynx [options]"
-      opts.separator ''
-      opts.separator "Larynx is a framework to develop FreeSWITCH IVR applications in Ruby."
-      opts.on('-i', '--ip IP',         'Listen for connections on this IP') {|ip| @options[:ip] = ip }
-      opts.on('-p', '--port PORT',     'Listen on this port', Integer)      {|port| @options[:port] = port }
-      opts.on('-d', '--daemonize',     'Run as daemon')                     { @options[:daemonize] = true }
-      opts.on('-l', '--log-file FILE', 'Defaults to /app/root/larynx.log')  {|log| @options[:log_file] = log }
-      opts.on(      '--pid-file FILE', 'Defaults to /app/root/larynx.pid')  {|pid| @options[:pid_file] = pid }
-      opts.on('-h', '--help',          'This is it')                        { $stderr.puts opts; exit 0 }
-      opts.on('-v', '--version')                                            { $stderr.puts "Larynx version #{Larynx::VERSION}"; exit 0 }
-      opts.parse!(args)
-    end
-
-    def setup_logger
-      logger = Larynx::Logger.new(@options[:log_file])
-      logger.level = Logger::INFO
-      Object.const_set "LARYNX_LOGGER", logger
-    end
-
-    def graceful_exit
-      msg = "Shutting down Larynx"
-      $stderr.puts msg unless @options[:daemon]
-      LARYNX_LOGGER.info msg
-
-      EM.stop_server @em_signature
-      @em_signature = nil
-      remove_pid_file if @options[:daemonize]
-      exit 130
-    end
-
-    def daemonize
-      Daemonize.daemonize
-      Dir.chdir LARYNX_ROOT
-      File.open(@options[:pid_file], 'w+') {|f| f.write("#{Process.pid}\n") }
-    end
-
-    def remove_pid_file
-      File.delete @options[:pid_file]
-    end
-
-    def trap_signals
-      trap('TERM') { graceful_exit }
-      trap('INT')  { graceful_exit }
-    end
-
-    def setup_app
-      if ARGV[0].nil?
-        $stderr.puts "You must specify an application file"
-        exit -1
-      end
-      Object.const_set "LARYNX_ROOT", File.expand_path(File.dirname(ARGV[0]))
-      require File.expand_path(ARGV[0])
-    end
-
-    def start_server
-      msg = "Larynx starting up on #{@options[:ip]}:#{@options[:port]}"
-      $stderr.puts msg unless @options[:daemon]
-      LARYNX_LOGGER.info msg
-
-      EM::run {
-        @em_signature = EM::start_server @options[:ip], @options[:port], Larynx::CallHandler
-      }
-    end
-
-    def run
-      parse_options(ARGV)
-      setup_app
-      daemonize if @options[:daemonize]
-      setup_logger
-      trap_signals
-      start_server
-    end
-
-    def running?
-      !@em_signature.nil?
-    end
   end
 
   # Default connect callback is to answer call
   connect {|call| call.answer }
 end
-
-Larynx.run unless defined?(TEST)

data/lib/larynx/field.rb

@@ -0,0 +1,122 @@
+module Larynx
+  class NoPromptDefined < StandardError; end
+
+  class Field
+    include CallbacksWithAsync
+
+    VALID_PROMPT_OPTIONS = [:play, :speak, :phrase, :bargein, :repeats, :interdigit_timeout, :timeout]
+
+    attr_reader :name, :app, :attempt
+    define_callback :setup, :validate, :invalid, :success, :failure, :scope => :app
+
+    def initialize(name, options, &block)
+      @name = name
+      @options = options.reverse_merge(:attempts => 3)
+      @prompt_queue = []
+
+      instance_eval(&block)
+      raise(Larynx::NoPromptDefined, 'A field requires a prompt to be defined') if @prompt_queue.empty?
+    end
+
+    def prompt(options)
+      add_prompt(options)
+    end
+
+    def reprompt(options)
+      raise 'A reprompt can only be used after a prompt' if @prompt_queue.empty?
+      add_prompt(options)
+    end
+
+    def add_prompt(options)
+      options.assert_valid_keys(*VALID_PROMPT_OPTIONS)
+      repeats = options.delete(:repeats) || 1
+      options.merge!(@options.slice(:length, :min_length, :max_length, :interdigit_timeout, :timeout))
+      @prompt_queue += ([options] * repeats)
+    end
+
+    def current_prompt
+      options = (@prompt_queue[@attempt-1] || @prompt_queue.last).dup
+      method  = command_from_options(options)
+      message = options[method].is_a?(Symbol) ? @app.send(options[method]) : options[method]
+      options[method] = message
+
+      Prompt.new(call, options) {|input, result|
+        set_instance_variables(input, result)
+        evaluate_input
+      }
+    end
+
+    def execute_prompt
+      call.execute current_prompt.command
+      send_next_command
+    end
+
+    def increment_attempts
+      @attempt += 1
+    end
+
+    # hook called when callback is complete
+    def callback_complete(callback, result=true)
+      case callback
+      when :validate
+        evaluate_validity(result)
+      when :invalid
+        invalid_input
+      when :success, :failure
+        finalize
+      end
+    end
+
+    def evaluate_input
+      @valid_length ? fire_callback(:validate) : fire_callback(:invalid)
+    end
+
+    def evaluate_validity(result)
+      result ? fire_callback(:success) : fire_callback(:invalid)
+    end
+
+    def invalid_input
+      if last_attempt?
+        fire_callback(:failure)
+      else
+        increment_attempts
+        execute_prompt
+      end
+    end
+
+    def send_next_command
+      call.send_next_command if call.state == :ready
+    end
+
+    def set_instance_variables(input, result)
+      @value, @valid_length = input, result
+      @app.send("#{@name}=", input)
+    end
+
+    def command_from_options(options)
+      (Prompt::COMMAND_OPTIONS & options.keys).first
+    end
+
+    def run(app)
+      @app = app
+      @attempt = 1
+      call.add_observer self
+      fire_callback(:setup)
+      execute_prompt
+    end
+
+    def call
+      @app.call
+    end
+
+    def finalize
+      call.remove_observer self
+      send_next_command
+    end
+
+    def last_attempt?
+      @attempt == @options[:attempts]
+    end
+
+  end
+end

data/lib/larynx/form.rb

@@ -1,10 +1,27 @@
 module Larynx
   class Form < Application
-    include Fields
     class_inheritable_accessor :setup_block
 
-    def self.setup(&block)
-      self.setup_block = block
+    class_inheritable_accessor :field_definitions
+    self.field_definitions = []
+
+    attr_accessor :fields
+
+    class << self
+      def setup(&block)
+        self.setup_block = block
+      end
+
+      def field(name, options={}, &block)
+        self.field_definitions <<  {:name => name, :options => options, :block => block}
+        attr_accessor name
+      end
+    end
+
+    def initialize(*args, &block)
+      @fields = self.class.field_definitions.map {|field| Field.new(field[:name], field[:options], &field[:block]) }
+      @field_index = -1
+      super
     end
 
     def run
@@ -16,5 +33,34 @@ module Larynx
       @field_index = -1
       run
     end
+
+    def next_field(field_name=nil)
+      if field_name
+        @field_index = field_index(field_name)
+      else
+        @field_index += 1
+      end
+      if field = current_field
+        field.run(self)
+        field
+      end
+    end
+
+    def current_field
+      @fields[@field_index]
+    end
+
+    def field_index(name)
+      field = @fields.find {|f| f.name == name }
+      @fields.index(field)
+    end
+
+    def attempt
+      current_field.attempt
+    end
+
+    def last_attempt?
+      current_field.last_attempt?
+    end
   end
 end

data/lib/larynx/menu.rb

@@ -0,0 +1,4 @@
+module Larynx
+  class Menu
+  end
+end

data/lib/larynx/version.rb

@@ -1,3 +1,3 @@
 module Larynx
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

data/spec/larynx/field_spec.rb

@@ -0,0 +1,218 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class TestForm < Larynx::Form; end
+
+describe Larynx::Field do
+  attr_reader :call, :form
+
+  before do
+    @call = TestCallHandler.new(1)
+    @form  = define_form.new(@call)
+  end
+
+  it 'should raise exception if field has no prompt' do
+    lambda { field(:guess) {} }.should raise_exception(Larynx::NoPromptDefined)
+  end
+
+  it 'should run setup callback once' do
+    call_me = should_be_called
+    fld = field(:guess) do
+      prompt :speak => 'first'
+      setup &call_me
+    end
+    fld.run form
+  end
+
+  it 'should pass timeout and length options to the prompt object' do
+    fld = field(:guess, :length => 1, :min_length => 1, :max_length => 2, :interdigit_timeout => 1, :timeout => 2) do
+      prompt :speak => 'first'
+    end
+    fld.run(form)
+    prompt = fld.current_prompt
+    prompt.interdigit_timeout.should == 1
+    prompt.timeout.should == 2
+    prompt.minimum_length.should == 1
+    prompt.maximum_length.should == 2
+  end
+
+  it 'should return same prompt all attempts if single prompt' do
+    fld = field(:guess) do
+      prompt :speak => 'first'
+    end
+    fld.run(form)
+    fld.current_prompt.message.should == 'first'
+    fld.increment_attempts
+    fld.current_prompt.message.should == 'first'
+  end
+
+  it 'should return reprompt for subsequent prompts' do
+    fld = field(:guess) do
+      prompt :speak => 'first'
+      reprompt :speak => 'second'
+    end
+    fld.run(form)
+    fld.current_prompt.message.should == 'first'
+    fld.increment_attempts
+    fld.current_prompt.message.should == 'second'
+  end
+
+  it 'should return prompt for given number of repeats before subsequent prompts' do
+    fld = field(:guess) do
+      prompt :speak => 'first', :repeats => 2
+      reprompt :speak => 'second'
+    end
+    fld.run(form)
+    fld.current_prompt.message.should == 'first'
+    fld.increment_attempts
+    fld.current_prompt.message.should == 'first'
+    fld.increment_attempts
+    fld.current_prompt.message.should == 'second'
+  end
+
+  context "#last_attempt?" do
+    it 'should return false when current attempt not equal to max attempts' do
+      fld = field(:guess, :attempts => 2) do
+        prompt :speak => 'first'
+      end
+      fld.run(form)
+      fld.attempt.should == 1
+      fld.last_attempt?.should be_false
+    end
+
+    it 'should return true when current attempt equals max attempts' do
+      fld = field(:guess, :attempts => 2) do
+        prompt :speak => 'first'
+      end
+      fld.run(form)
+      fld.increment_attempts
+      fld.attempt.should == 2
+      fld.last_attempt?.should be_true
+    end
+  end
+
+  context 'input evaluation' do
+    it 'should run validate callback if input minimum length' do
+      call_me = should_be_called
+      fld = field(:guess, :min_length => 1) do
+        prompt :speak => 'first'
+        validate &call_me
+      end
+      fld.run form
+      call.input << '1'
+      fld.current_prompt.finalise
+    end
+
+    it 'should run invalid callback if length not valid' do
+      call_me = should_be_called
+      fld = field(:guess) do
+        prompt :speak => 'first'
+        invalid &call_me
+      end
+      fld.run form
+      fld.current_prompt.finalise
+    end
+
+    it 'should run invalid callback if validate callback returns false' do
+      call_me = should_be_called
+      fld = field(:guess, :min_length => 1) do
+        prompt :speak => 'first'
+        validate { false }
+        invalid &call_me
+      end
+      fld.run form
+      call.input << '1'
+      fld.current_prompt.finalise
+    end
+
+    it 'should run invalid callback if validate callback returns nil' do
+      call_me = should_be_called
+      fld = field(:guess, :min_length => 1) do
+        prompt :speak => 'first'
+        validate { nil }
+        invalid &call_me
+      end
+      fld.run form
+      call.input << '1'
+      fld.current_prompt.finalise
+    end
+
+    it 'should run success callback if length valid and no validate callback' do
+      call_me = should_be_called
+      fld = field(:guess, :min_length => 1) do
+        prompt :speak => 'first'
+        success &call_me
+      end
+      fld.run form
+      call.input << '1'
+      fld.current_prompt.finalise
+    end
+
+    it 'should run success callback if validate callback returns true' do
+      call_me = should_be_called
+      fld = field(:guess, :min_length => 1) do
+        prompt :speak => 'first'
+        validate { true }
+        success &call_me
+      end
+      fld.run form
+      call.input << '1'
+      fld.current_prompt.finalise
+    end
+
+    it 'should run failure callback if not valid and last attempt' do
+      call_me = should_be_called
+      fld = field(:guess, :min_length => 1, :attempts => 1) do
+        prompt :speak => 'first'
+        failure &call_me
+      end
+      fld.run form
+      fld.current_prompt.finalise
+    end
+
+    it 'should increment attempts if not valid' do
+      fld = field(:guess) do
+        prompt :speak => 'first'
+        reprompt :speak => 'second'
+      end
+      fld.run form
+      fld.current_prompt.finalise
+      fld.current_prompt.message.should == 'second'
+    end
+
+    it 'should execute next prompt if not valid' do
+      fld = field(:guess) do
+        prompt :speak => 'first'
+        reprompt :speak => 'second'
+      end
+      fld.run form
+      fld.should_receive(:execute_prompt)
+      fld.current_prompt.finalise
+    end
+
+    context "async callbacks" do
+      # it "should be run in thread" do
+      #   em do
+      #     fld = field(:guess) do
+      #       prompt :speak => 'first'
+      #       validate(:async) { sleep(0.25) }
+      #       success { done }
+      #     end.run(form)
+      #     call.input << '1'
+      #   end
+      #   @callback.should be_nil
+      # end
+    end
+
+  end
+
+  def field(name, options={}, &block)
+    @form.class.class_eval { attr_accessor name }
+    Larynx::Field.new(name, options, &block)
+  end
+
+  def define_form(&block)
+    reset_class(TestForm) do
+      instance_eval &block if block_given?
+    end
+  end
+end

data/spec/larynx/form_spec.rb

@@ -9,6 +9,16 @@ describe Larynx::Form do
     @call = TestCallHandler.new(1)
   end
 
+  it 'should add field class method' do
+    Larynx::Form.should respond_to(:field)
+  end
+
+  it 'should add instance accessor for field name' do
+    form_class = define_form 
+    form_class.field(:guess) { prompt :speak => 'hello' }
+    form_class.methods.include?(:guess)
+  end
+
   context "#run" do
     it 'should call setup block' do
       this_should_be_called = should_be_called
@@ -40,6 +50,40 @@ describe Larynx::Form do
     end
   end
 
+  context '#next_field' do
+    let(:form) {
+      define_form do
+        field(:field1) { prompt :speak => 'hello' }
+        field(:field2) { prompt :speak => 'hello' }
+        field(:field3) { prompt :speak => 'hello' }
+      end.new(call)
+    }
+
+    it 'should iterate over defined fields' do
+      form.next_field.name.should == :field1
+      form.next_field.name.should == :field2
+      form.next_field.name.should == :field3
+    end
+
+    it 'should jump to field name if supplied' do
+      form.next_field(:field2).name.should == :field2
+    end
+  end
+
+  context "#current_field" do
+    it 'should return field of current position' do
+      form = define_form do
+        field(:field1) { prompt :speak => 'hello' }
+        field(:field2) { prompt :speak => 'hello' }
+      end.new(call)
+      form.run
+
+      form.current_field.should == form.fields[0]
+      form.next_field
+      form.current_field.should == form.fields[1]
+    end
+  end
+
   def define_form(&block)
     reset_class(TestForm) do
       instance_eval &block if block_given?

data/spec/larynx/menu_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Larynx::Menu do
+
+  it 'should' do
+  end
+
+  def define_menu(&block)
+    Class.new(Larynx::Menu, &block)
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: larynx
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 1
-  - 5
-  version: 0.1.5
+  - 6
+  version: 0.1.6
 platform: ruby
 authors: 
 - Adam Meehan
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-03 00:00:00 +10:00
+date: 2010-09-04 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -100,9 +100,10 @@ files:
 - lib/larynx/callbacks_with_async.rb
 - lib/larynx/command.rb
 - lib/larynx/commands.rb
-- lib/larynx/fields.rb
+- lib/larynx/field.rb
 - lib/larynx/form.rb
 - lib/larynx/logger.rb
+- lib/larynx/menu.rb
 - lib/larynx/observable.rb
 - lib/larynx/prompt.rb
 - lib/larynx/response.rb
@@ -122,8 +123,9 @@ files:
 - spec/larynx/call_handler_spec.rb
 - spec/larynx/command_spec.rb
 - spec/larynx/eventmachince_spec.rb
-- spec/larynx/fields_spec.rb
+- spec/larynx/field_spec.rb
 - spec/larynx/form_spec.rb
+- spec/larynx/menu_spec.rb
 - spec/larynx/prompt_spec.rb
 - spec/larynx_spec.rb
 - spec/spec_helper.rb

data/lib/larynx/fields.rb

@@ -1,184 +0,0 @@
-module Larynx
-  class NoPromptDefined < StandardError; end
-
-  module Fields
-
-    def self.included(base)
-      base.extend ClassMethods
-      base.class_eval do
-        include InstanceMethods
-        class_inheritable_accessor :field_definitions
-        self.field_definitions = []
-        attr_accessor :fields
-      end
-    end
-
-    module ClassMethods
-
-      def field(name, options={}, &block)
-        self.field_definitions <<  {:name => name, :options => options, :block => block}
-        attr_accessor name
-      end
-
-    end
-
-    module InstanceMethods
-
-      def initialize(*args, &block)
-        @fields = self.class.field_definitions.map {|field| Field.new(field[:name], field[:options], &field[:block]) }
-        @field_index = -1
-        super
-      end
-
-      def next_field(field_name=nil)
-        if field_name
-          @field_index = field_index(field_name)
-        else
-          @field_index += 1
-        end
-        if field = current_field
-          field.run(self)
-          field
-        end
-      end
-
-      def current_field
-        @fields[@field_index]
-      end
-
-      def field_index(name)
-        field = @fields.find {|f| f.name == name }
-        @fields.index(field)
-      end
-
-      def attempt
-        current_field.attempt
-      end
-
-      def last_attempt?
-        current_field.last_attempt?
-      end
-
-    end
-
-    class Field
-      include CallbacksWithAsync
-
-      VALID_PROMPT_OPTIONS = [:play, :speak, :phrase, :bargein, :repeats, :interdigit_timeout, :timeout]
-
-      attr_reader :name, :app, :attempt
-      define_callback :setup, :validate, :invalid, :success, :failure, :scope => :app
-
-      def initialize(name, options, &block)
-        @name = name
-        @options = options.reverse_merge(:attempts => 3)
-        @prompt_queue = []
-
-        instance_eval(&block)
-        raise(Larynx::NoPromptDefined, 'A field requires a prompt to be defined') if @prompt_queue.empty?
-      end
-
-      def prompt(options)
-        add_prompt(options)
-      end
-
-      def reprompt(options)
-        raise 'A reprompt can only be used after a prompt' if @prompt_queue.empty?
-        add_prompt(options)
-      end
-
-      def add_prompt(options)
-        options.assert_valid_keys(*VALID_PROMPT_OPTIONS)
-        repeats = options.delete(:repeats) || 1
-        options.merge!(@options.slice(:length, :min_length, :max_length, :interdigit_timeout, :timeout))
-        @prompt_queue += ([options] * repeats)
-      end
-
-      def current_prompt
-        options = (@prompt_queue[@attempt-1] || @prompt_queue.last).dup
-        method  = command_from_options(options)
-        message = options[method].is_a?(Symbol) ? @app.send(options[method]) : options[method]
-        options[method] = message
-
-        Prompt.new(call, options) {|input, result|
-          set_instance_variables(input, result)
-          evaluate_input
-        }
-      end
-
-      def execute_prompt
-        call.execute current_prompt.command
-        send_next_command
-      end
-
-      def increment_attempts
-        @attempt += 1
-      end
-
-      # hook called when callback is complete
-      def callback_complete(callback, result=true)
-        case callback
-        when :validate
-          evaluate_validity(result)
-        when :invalid
-          invalid_input
-        when :success, :failure
-          finalize
-        end
-      end
-
-      def evaluate_input
-        @valid_length ? fire_callback(:validate) : fire_callback(:invalid)
-      end
-
-      def evaluate_validity(result)
-        result ? fire_callback(:success) : fire_callback(:invalid)
-      end
-
-      def invalid_input
-        if last_attempt?
-          fire_callback(:failure)
-        else
-          increment_attempts
-          execute_prompt
-        end
-      end
-
-      def send_next_command
-        call.send_next_command if call.state == :ready
-      end
-
-      def set_instance_variables(input, result)
-        @value, @valid_length = input, result
-        @app.send("#{@name}=", input)
-      end
-
-      def command_from_options(options)
-        (Prompt::COMMAND_OPTIONS & options.keys).first
-      end
-
-      def run(app)
-        @app = app
-        @attempt = 1
-        call.add_observer self
-        fire_callback(:setup)
-        execute_prompt
-      end
-
-      def call
-        @app.call
-      end
-
-      def finalize
-        call.remove_observer self
-        send_next_command
-      end
-
-      def last_attempt?
-        @attempt == @options[:attempts]
-      end
-
-    end
-
-  end
-end

data/spec/larynx/fields_spec.rb

@@ -1,271 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-class TestApp < Larynx::Application; end
-
-describe Larynx::Fields do
-  attr_reader :call, :app
-
-  before do
-    @call = TestCallHandler.new(1)
-    @app  = define_app.new(@call)
-  end
-
-  context 'module' do
-    before do
-      @app_class = define_app
-    end
-
-    it 'should add field class method' do
-      @app_class.should respond_to(:field)
-    end
-
-    it 'should add instance accessor for field name' do
-      @app_class.field(:guess) { prompt :speak => 'hello' }
-      @app_class.methods.include?(:guess)
-    end
-  end
-
-  context '#next_field' do
-    before do
-      @app = define_app do
-        field(:field1) { prompt :speak => 'hello' }
-        field(:field2) { prompt :speak => 'hello' }
-        field(:field3) { prompt :speak => 'hello' }
-      end.new(call)
-    end
-
-    it 'should iterate over defined fields' do
-      app.next_field.name.should == :field1
-      app.next_field.name.should == :field2
-      app.next_field.name.should == :field3
-    end
-
-    it 'should jump to field name if supplied' do
-      app.next_field(:field2).name.should == :field2
-    end
-  end
-
-  context "#current_field" do
-    it 'should return field of current position' do
-      @app = define_app do
-        field(:field1) { prompt :speak => 'hello' }
-        field(:field2) { prompt :speak => 'hello' }
-      end.new(call)
-      app.run
-
-      app.next_field
-      app.current_field.should == app.fields[0]
-      app.next_field
-      app.current_field.should == app.fields[1]
-    end
-  end
-
-  context 'field object' do
-    it 'should raise exception if field has no prompt' do
-      lambda { field(:guess) {} }.should raise_exception(Larynx::NoPromptDefined)
-    end
-
-    it 'should run setup callback once' do
-      call_me = should_be_called
-      fld = field(:guess) do
-        prompt :speak => 'first'
-        setup &call_me
-      end
-      fld.run app
-    end
-
-    it 'should pass timeout and length options to the prompt object' do
-      fld = field(:guess, :length => 1, :min_length => 1, :max_length => 2, :interdigit_timeout => 1, :timeout => 2) do
-        prompt :speak => 'first'
-      end
-      fld.run(app)
-      prompt = fld.current_prompt
-      prompt.interdigit_timeout.should == 1
-      prompt.timeout.should == 2
-      prompt.minimum_length.should == 1
-      prompt.maximum_length.should == 2
-    end
-
-    it 'should return same prompt all attempts if single prompt' do
-      fld = field(:guess) do
-        prompt :speak => 'first'
-      end
-      fld.run(app)
-      fld.current_prompt.message.should == 'first'
-      fld.increment_attempts
-      fld.current_prompt.message.should == 'first'
-    end
-
-    it 'should return reprompt for subsequent prompts' do
-      fld = field(:guess) do
-        prompt :speak => 'first'
-        reprompt :speak => 'second'
-      end
-      fld.run(app)
-      fld.current_prompt.message.should == 'first'
-      fld.increment_attempts
-      fld.current_prompt.message.should == 'second'
-    end
-
-    it 'should return prompt for given number of repeats before subsequent prompts' do
-      fld = field(:guess) do
-        prompt :speak => 'first', :repeats => 2
-        reprompt :speak => 'second'
-      end
-      fld.run(app)
-      fld.current_prompt.message.should == 'first'
-      fld.increment_attempts
-      fld.current_prompt.message.should == 'first'
-      fld.increment_attempts
-      fld.current_prompt.message.should == 'second'
-    end
-
-    context "#last_attempt?" do
-      it 'should return false when current attempt not equal to max attempts' do
-        fld = field(:guess, :attempts => 2) do
-          prompt :speak => 'first'
-        end
-        fld.run(app)
-        fld.attempt.should == 1
-        fld.last_attempt?.should be_false
-      end
-
-      it 'should return true when current attempt equals max attempts' do
-        fld = field(:guess, :attempts => 2) do
-          prompt :speak => 'first'
-        end
-        fld.run(app)
-        fld.increment_attempts
-        fld.attempt.should == 2
-        fld.last_attempt?.should be_true
-      end
-    end
-
-    context 'input evaluation' do
-      it 'should run validate callback if input minimum length' do
-        call_me = should_be_called
-        fld = field(:guess, :min_length => 1) do
-          prompt :speak => 'first'
-          validate &call_me
-        end
-        fld.run app
-        call.input << '1'
-        fld.current_prompt.finalise
-      end
-
-      it 'should run invalid callback if length not valid' do
-        call_me = should_be_called
-        fld = field(:guess) do
-          prompt :speak => 'first'
-          invalid &call_me
-        end
-        fld.run app
-        fld.current_prompt.finalise
-      end
-
-      it 'should run invalid callback if validate callback returns false' do
-        call_me = should_be_called
-        fld = field(:guess, :min_length => 1) do
-          prompt :speak => 'first'
-          validate { false }
-          invalid &call_me
-        end
-        fld.run app
-        call.input << '1'
-        fld.current_prompt.finalise
-      end
-
-      it 'should run invalid callback if validate callback returns nil' do
-        call_me = should_be_called
-        fld = field(:guess, :min_length => 1) do
-          prompt :speak => 'first'
-          validate { nil }
-          invalid &call_me
-        end
-        fld.run app
-        call.input << '1'
-        fld.current_prompt.finalise
-      end
-
-      it 'should run success callback if length valid and no validate callback' do
-        call_me = should_be_called
-        fld = field(:guess, :min_length => 1) do
-          prompt :speak => 'first'
-          success &call_me
-        end
-        fld.run app
-        call.input << '1'
-        fld.current_prompt.finalise
-      end
-
-      it 'should run success callback if validate callback returns true' do
-        call_me = should_be_called
-        fld = field(:guess, :min_length => 1) do
-          prompt :speak => 'first'
-          validate { true }
-          success &call_me
-        end
-        fld.run app
-        call.input << '1'
-        fld.current_prompt.finalise
-      end
-
-      it 'should run failure callback if not valid and last attempt' do
-        call_me = should_be_called
-        fld = field(:guess, :min_length => 1, :attempts => 1) do
-          prompt :speak => 'first'
-          failure &call_me
-        end
-        fld.run app
-        fld.current_prompt.finalise
-      end
-
-      it 'should increment attempts if not valid' do
-        fld = field(:guess) do
-          prompt :speak => 'first'
-          reprompt :speak => 'second'
-        end
-        fld.run app
-        fld.current_prompt.finalise
-        fld.current_prompt.message.should == 'second'
-      end
-
-      it 'should execute next prompt if not valid' do
-        fld = field(:guess) do
-          prompt :speak => 'first'
-          reprompt :speak => 'second'
-        end
-        fld.run app
-        fld.should_receive(:execute_prompt)
-        fld.current_prompt.finalise
-      end
-    end
-
-    context "async callbacks" do
-      # it "should be run in thread" do
-      #   em do
-      #     fld = field(:guess) do
-      #       prompt :speak => 'first'
-      #       validate(:async) { sleep(0.25) }
-      #       success { done }
-      #     end.run(app)
-      #     call.input << '1'
-      #   end
-      #   @callback.should be_nil
-      # end
-    end
-
-  end
-
-  def field(name, options={}, &block)
-    @app.class.class_eval { attr_accessor name }
-    Larynx::Fields::Field.new(name, options, &block)
-  end
-
-  def define_app(&block)
-    reset_class(TestApp) do
-      include Larynx::Fields
-      instance_eval &block if block_given?
-    end
-  end
-end