larynx 0.1.4 → 0.1.5

data/README.rdoc

@@ -212,6 +212,10 @@ together and define another form for unrelated fields.
 Lets look at a simple Form class with empty callbacks in place.
 
   class MyApp < Larynx::Form
+    setup do
+      # Run when the form is first run or restarted.
+    end
+
     field(:my_field, :attempts => 3, :length => 1) do
       prompt :speak => 'Please enter a value.'
 

data/Rakefile

@@ -23,7 +23,6 @@ spec = Gem::Specification.new do |s|
   s.homepage = "http://github.com/adzap/larynx"
 
   s.require_path = 'lib'
-  s.autorequire = GEM_NAME
   s.files = %w(MIT-LICENSE README.rdoc Rakefile) + Dir.glob("{lib,spec,examples}/**/*")
   s.add_dependency "eventmachine",   "~> 0.12.10"
   s.add_dependency "activesupport", "~> 2.3.5"

data/lib/larynx/application.rb

@@ -1,7 +1,9 @@
 module Larynx
   class Application
     attr_reader :call
+
     delegate *Commands.instance_methods << {:to => :call}
+    delegate :session, :to => :call
 
     def self.run(call)
       app = self.new(call)

data/lib/larynx/call_handler.rb

@@ -107,7 +107,7 @@ module Larynx
         finalize_command
         @state = :ready
         Larynx.fire_callback(:answer, self)
-        send_next_command
+        send_next_command if @state == :ready
       when @response.executing?
         log "Executing: #{current_command.name}"
         current_command.setup
@@ -168,6 +168,7 @@ module Larynx
       break! if @state == :executing
       cancel_all_timers
       clear_observers!
+      @session = nil
     end
 
     def log(msg)

data/lib/larynx/callbacks_with_async.rb

@@ -41,7 +41,7 @@ module Larynx
             callback_complete(callback, scope_callback(block, scope).call)
           end
         else
-          callback_complete(callback, nil)
+          callback_complete(callback)
         end
       end
 

data/lib/larynx/fields.rb

@@ -26,30 +26,47 @@ module Larynx
 
       def initialize(*args, &block)
         @fields = self.class.field_definitions.map {|field| Field.new(field[:name], field[:options], &field[:block]) }
-        @current_field = 0
+        @field_index = -1
         super
       end
 
       def next_field(field_name=nil)
-        @current_field = field_index(field_name) if field_name
-        if field = @fields[@current_field]
+        if field_name
+          @field_index = field_index(field_name)
+        else
+          @field_index += 1
+        end
+        if field = current_field
           field.run(self)
-          @current_field += 1
           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
 
-      attr_reader :name, :app
+      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)
@@ -71,7 +88,7 @@ module Larynx
       end
 
       def add_prompt(options)
-        options.assert_valid_keys(:play, :speak, :phrase, :bargein, :repeats, :interdigit_timeout, :timeout)
+        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)
@@ -99,10 +116,9 @@ module Larynx
       end
 
       # hook called when callback is complete
-      def callback_complete(callback, result)
+      def callback_complete(callback, result=true)
         case callback
         when :validate
-          result = result.nil? ? true : result
           evaluate_validity(result)
         when :invalid
           invalid_input
@@ -120,11 +136,11 @@ module Larynx
       end
 
       def invalid_input
-        if @attempt < @options[:attempts]
+        if last_attempt?
+          fire_callback(:failure)
+        else
           increment_attempts
           execute_prompt
-        else
-          fire_callback(:failure)
         end
       end
 
@@ -138,7 +154,7 @@ module Larynx
       end
 
       def command_from_options(options)
-        ([:play, :speak, :phrase] & options.keys).first
+        (Prompt::COMMAND_OPTIONS & options.keys).first
       end
 
       def run(app)
@@ -158,6 +174,10 @@ module Larynx
         send_next_command
       end
 
+      def last_attempt?
+        @attempt == @options[:attempts]
+      end
+
     end
 
   end

data/lib/larynx/form.rb

@@ -1,19 +1,19 @@
 module Larynx
   class Form < Application
     include Fields
-    @@setup = nil
+    class_inheritable_accessor :setup_block
 
     def self.setup(&block)
-      @@setup = block
+      self.setup_block = block
     end
 
     def run
-      instance_eval &@@setup if @@setup
+      instance_eval &self.class.setup_block if self.class.setup_block
       next_field
     end
 
     def restart_form
-      @current_field = 0
+      @field_index = -1
       run
     end
   end

data/lib/larynx/prompt.rb

@@ -13,6 +13,8 @@ module Larynx
   class Prompt
     attr_reader :call
 
+    COMMAND_OPTIONS = [:play, :speak, :phrase]
+
     def initialize(call, options, &block)
       @call, @options, @block = call, options, block
       @options.reverse_merge!(:bargein => true, :timeout => 10, :interdigit_timeout => 3, :termchar => '#')
@@ -21,8 +23,9 @@ module Larynx
 
     def command
       @command ||= AppCommand.new(command_name, message, :bargein => @options[:bargein]).
-        before { call.clear_input }.
+        before { call.clear_input unless @options[:bargein] }.
         after  {
+          call.clear_input unless @options[:bargein]
           if prompt_finished?
             finalise
           else
@@ -62,7 +65,7 @@ module Larynx
     end
 
     def command_name
-      ([:play, :speak, :phrase] & @options.keys).first.to_s
+      (COMMAND_OPTIONS & @options.keys).first.to_s
     end
 
     def message

data/lib/larynx/server.rb

@@ -0,0 +1,95 @@
+require 'logger'
+require 'daemons/daemonize'
+
+module Larynx
+  module Server
+    class << self
+
+      def boot
+        parse_options(ARGV)
+        setup_app
+        daemonize if @options[:daemonize]
+        setup_logger
+        trap_signals
+        start_server
+      end
+
+      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] app_file"
+        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 running?
+        !@em_signature.nil?
+      end
+
+    end
+  end
+end

data/lib/larynx/session.rb

@@ -12,6 +12,10 @@ module Larynx
       end
     end
 
+    def []=(key, value)
+      @variables[key] = value
+    end
+
     def [](key)
       @variables[key]
     end

data/lib/larynx/version.rb

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

data/spec/larynx/call_handler_spec.rb

@@ -198,6 +198,18 @@ describe Larynx::CallHandler do
       end
     end
 
+    it "should send next command if state is ready" do
+      call.should_receive(:send_next_command)
+      answer_call
+    end
+
+    it "should not send next command if answer callback changed state" do
+      call.should_not_receive(:send_next_command)
+      with_global_callback(:answer, lambda { call.state = :sending }) do
+        answer_call
+      end
+    end
+
     def answer_call
       call.send_response :answered
     end

data/spec/larynx/fields_spec.rb

@@ -25,7 +25,7 @@ describe Larynx::Fields do
     end
   end
 
-  context 'next_field' do
+  context '#next_field' do
     before do
       @app = define_app do
         field(:field1) { prompt :speak => 'hello' }
@@ -45,6 +45,21 @@ describe Larynx::Fields do
     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)
@@ -105,6 +120,27 @@ describe Larynx::Fields do
       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
@@ -139,6 +175,18 @@ describe Larynx::Fields do
         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

data/spec/larynx/form_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class TestForm < Larynx::Form; end
+
+describe Larynx::Form do
+  attr_reader :call
+
+  before do
+    @call = TestCallHandler.new(1)
+  end
+
+  context "#run" do
+    it 'should call setup block' do
+      this_should_be_called = should_be_called
+      define_form do
+        setup &this_should_be_called
+      end.run(call)
+    end
+  end
+
+  context "#restart_form" do
+    it 'should call form setup block' do
+      this_should_be_called = should_be_called
+      form = define_form do
+        setup &this_should_be_called
+      end.new(call)
+      form.restart_form
+    end
+
+    it 'should run the first field again' do
+      form = define_form do
+        field(:test1) { prompt :speak => '' }
+        field(:test2) { prompt :speak => '' }
+      end.new(call)
+
+      form.fields[0].should_receive(:run).twice
+      form.run
+      form.next_field
+      form.restart_form
+    end
+  end
+
+  def define_form(&block)
+    reset_class(TestForm) do
+      instance_eval &block if block_given?
+    end
+  end
+
+end

data/spec/larynx/prompt_spec.rb

@@ -39,6 +39,27 @@ describe Larynx::Prompt do
       @prompt.input.should == '1'
     end
   end
+  context "command" do
+    it "should return command object for command name" do
+      cmd = new_prompt.command
+      cmd.should be_kind_of(Larynx::AppCommand)
+      cmd.command.should == 'speak'
+    end
+  end
+
+  context "before callback" do
+    it "should clear input on execution if no bargein allowed" do
+      call.input << '1'
+      before_callback new_prompt(:speak => 'hello', :bargein => false)
+      call.input.should be_empty
+    end
+
+    it "should clear input on execution if bargein allowed" do
+      call.input << '1'
+      before_callback new_prompt(:speak => 'hello', :bargein => true)
+      call.input.should_not be_empty
+    end
+  end
 
   context "prompt_finished?" do
     it "should return true if input length reached" do
@@ -66,23 +87,28 @@ describe Larynx::Prompt do
     end
   end
 
-  context "command" do
-    it "should return command object for command name" do
-      cmd = new_prompt.command
-      cmd.should be_kind_of(Larynx::AppCommand)
-      cmd.command.should == 'speak'
-    end
-  end
 
-  context "before callback" do
-    it "should clear input on execution" do
-      call.input << '1'
-      before_callback new_prompt
-      call.input.should be_empty
+  context "after callback" do
+    context "bargein" do
+      it 'should clear input before prompt status evaluated if false' do
+        prompt = new_prompt(:speak => 'hello', :length => 1, :bargein => false)
+        call.input << '1'
+        em do
+          after_callback prompt
+          prompt.prompt_finished?.should be_false
+          done
+        end
+      end
+
+      it 'should not clear input before prompt status evaluated if true' do
+        prompt = new_prompt(:speak => 'hello', :length => 1, :bargein => true) { done }
+        call.input << '1'
+        em do
+          after_callback prompt
+        end
+      end
     end
-  end
 
-  context "after callback" do
     context "input completed" do
       it "should not add timers if reached length" do
         prompt = new_prompt
@@ -146,9 +172,10 @@ describe Larynx::Prompt do
     end
 
     it "should clear input" do
+      call.input << '1'
       prompt = new_prompt
-      call.should_receive(:clear_input)
       prompt.finalise
+      call.input.should be_empty
     end
   end
 

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification 
 name: larynx
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 1
-  - 4
-  version: 0.1.4
+  - 5
+  version: 0.1.5
 platform: ruby
 authors: 
 - Adam Meehan
-autorequire: larynx
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-08-26 00:00:00 +10:00
+date: 2010-09-03 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -107,6 +107,7 @@ files:
 - lib/larynx/prompt.rb
 - lib/larynx/response.rb
 - lib/larynx/restartable_timer.rb
+- lib/larynx/server.rb
 - lib/larynx/session.rb
 - lib/larynx/version.rb
 - lib/larynx.rb
@@ -122,6 +123,7 @@ files:
 - spec/larynx/command_spec.rb
 - spec/larynx/eventmachince_spec.rb
 - spec/larynx/fields_spec.rb
+- spec/larynx/form_spec.rb
 - spec/larynx/prompt_spec.rb
 - spec/larynx_spec.rb
 - spec/spec_helper.rb