dancroak-twilio 2.3.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Phil Misiowiec, Webficient LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,39 @@
+= Twilio Gem
+
+The Twilio gem provides two major pieces of functionality: (1) a Ruby wrapper for the Twilio REST API and (2) response handlers based on the Twilio Markup XML (TwiML).
+
+See http://www.twilio.com/docs/index for Twilio's API documentation.
+
+For an overview of the Twilio Gem and a sample use case, check out http://www.webficient.com/2009/06/22/hello-this-is-your-rails-app-calling-you.
+
+== Calling the Twilio REST API
+
+First set your credentials by calling the connect method:
+
+  Twilio.connect('my_twilio_sid', 'my_auth_token')
+  
+Now call any of the Twilio classes:
+  
+  Twilio::Call.make('1234567890', '9876543210', 'http://mysite.com/connected_call')
+  Twilio::Recording.list
+  
+== Responding to Twilio
+
+When Twilio calls your application URL, your response must use the Twilio Markup XML (http://www.twilio.com/docs/api_reference/TwiML/). The Twilio gem makes this very easy 
+by providing a Twilio Verb class. 
+
+For example, in a Ruby on Rails application, you could do the following inside a controller class:
+
+  Twilio::Verb.dial('415-123-4567')
+  
+and you can nest multiple verbs inside a block:
+
+  verb = Twilio::Verb.new { |v|
+    v.say("The time is #{Time.now}")
+    v.hangup
+  }
+  verb.response
+
+== Copyright
+
+Copyright (c) 2009 Phil Misiowiec, Webficient LLC. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "twilio"
+    gem.summary = %Q{Twilio API Client}
+    gem.email = "github@webficient.com"
+    gem.homepage = "http://github.com/webficient/twilio"
+    gem.authors = ["Phil Misiowiec"]
+    gem.add_dependency 'builder'
+    gem.add_dependency 'httparty'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'twilio'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 2
+:minor: 3

data/lib/twilio.rb

@@ -0,0 +1,42 @@
+$:.unshift(File.dirname(__FILE__))
+
+#--
+# Copyright (c) 2009 Phil Misiowiec, phil@webficient.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'rubygems'
+gem 'httparty', '>= 0.4.3'
+require 'httparty'
+gem 'builder', '>= 2.1.2'
+require 'builder'
+
+require 'twilio/twilio_object'
+require 'twilio/account'
+require 'twilio/call'
+require 'twilio/connection'
+require 'twilio/incoming_phone_number'
+require 'twilio/local_phone_number'
+require 'twilio/notification'
+require 'twilio/outgoing_caller_id'
+require 'twilio/recording'
+require 'twilio/toll_free_phone_number'
+require 'twilio/verb'

data/lib/twilio/account.rb

@@ -0,0 +1,12 @@
+module Twilio
+  # The Account resource represents your Twilio Account. 
+  class Account < TwilioObject
+    def get
+      Twilio.get('') 
+    end
+    
+    def update_name(name)
+      Twilio.put('', :body => {:FriendlyName => name}) 
+    end
+  end
+end

data/lib/twilio/call.rb

@@ -0,0 +1,33 @@
+module Twilio
+    # A Call represenents a connection between a telephone and Twilio. This may be 
+    # inbound, when a person calls your application, or outbound when your application 
+    # initiates the call, either via the REST API, or during a call via the Dial Verb. 
+  class Call < TwilioObject
+    #  Example:
+    #  Twilio.connect('my_twilio_sid', 'my_auth_token')
+    #  Twilio::Call.make(CALLER_ID, user_number, 'http://myapp.com/twilio_response_handler')
+    def make(caller, called, url, optional = {})
+      Twilio.post("/Calls", :body => {:Caller => caller, :Called => called, :Url => url}.merge(optional))
+    end
+
+    def list(optional = {})
+      Twilio.get("/Calls", :query => optional)  
+    end
+        
+    def get(call_sid)
+      Twilio.get("/Calls/#{call_sid}")
+    end
+    
+    def segments(call_sid, call_segment_sid = nil)
+      Twilio.get("/Calls/#{call_sid}/Segments#{ '/' + call_segment_sid if call_segment_sid }")
+    end
+    
+    def recordings(call_sid)
+      Twilio.get("/Calls/#{call_sid}/Recordings")
+    end
+    
+    def notifications(call_sid)
+      Twilio.get("/Calls/#{call_sid}/Notifications")
+    end
+  end
+end

data/lib/twilio/connection.rb

@@ -0,0 +1,24 @@
+module Twilio
+  include HTTParty
+  TWILIO_URL = "https://api.twilio.com/2008-08-01/Accounts"
+    
+  # The connect method caches your Twilio account id and authentication token
+  # Example:
+  #  Twilio.connect('AC309475e5fede1b49e100272a8640f438', '3a2630a909aadbf60266234756fb15a0')
+  def self.connect(account_sid, auth_token)
+    self.base_uri "#{TWILIO_URL}/#{account_sid}"
+    self.basic_auth account_sid, auth_token
+  end
+  
+  # DEPRECATED - use Twilio.connect
+  class Connection
+    include HTTParty
+    TWILIO_URL = "https://api.twilio.com/2008-08-01/Accounts"
+    
+    def initialize(account_sid, auth_token)
+      self.class.base_uri "#{TWILIO_URL}/#{account_sid}"
+      self.class.basic_auth account_sid, auth_token     
+    end
+  end
+  
+end

data/lib/twilio/incoming_phone_number.rb

@@ -0,0 +1,16 @@
+module Twilio
+  # An IncomingPhoneNumber resource represents a phone number given to you by 
+  # Twilio to receive incoming phone calls. 
+  # Example:
+  #   Twilio.connect('my_twilio_sid', 'my_auth_token')
+  #   Twilio::IncomingPhoneNumber.list
+  class IncomingPhoneNumber < TwilioObject
+    def list(optional = {})
+      Twilio.get("/IncomingPhoneNumbers", :query => optional) 
+    end
+    
+    def get(incoming_sid)
+      Twilio.get("/IncomingPhoneNumbers/#{incoming_sid}") 
+    end
+  end
+end

data/lib/twilio/local_phone_number.rb

@@ -0,0 +1,21 @@
+module Twilio
+  # This sub-resource represents only Local phone numbers, or in other words, not toll-free numbers. 
+  # Also allows you to request a new local phone number be added to your account.
+  # Example:
+  #   Twilio.connect('my_twilio_sid', 'my_auth_token')
+  #   Twilio::LocalPhoneNumber.list
+  class LocalPhoneNumber < TwilioObject
+    def create(url, area_code = nil, method = 'POST', friendly_name = nil)
+      Twilio.post("/IncomingPhoneNumbers/Local", :body => {
+        :Url => url, 
+        :AreaCode => area_code, 
+        :Method => method,
+        :FriendlyName => friendly_name 
+      })
+    end
+    
+    def list
+      Twilio.get("/IncomingPhoneNumbers/Local")
+    end
+  end
+end

data/lib/twilio/notification.rb

@@ -0,0 +1,20 @@
+module Twilio
+  # A Notification represenents a log entry made by Twilio in the course of handling 
+  # your calls or using the REST API.
+  # Example:
+  #   Twilio.connect('my_twilio_sid', 'my_auth_token')
+  #   Twilio::Notification.list
+  class Notification < TwilioObject
+    def list(optional = {})
+      Twilio.get('/Notifications', :query => optional)
+    end
+    
+    def get(notification_sid)
+      Twilio.get("/Notifications/#{notification_sid}")
+    end
+    
+    def delete(notification_sid)
+      Twilio.delete("/Notifications/#{notification_sid}")
+    end
+  end
+end

data/lib/twilio/outgoing_caller_id.rb

@@ -0,0 +1,32 @@
+module Twilio
+  # An OutgoingCallerId resource represents an outgoing Caller ID that you have 
+  # registered with Twilio for use when making an outgoing call or using the Dial Verb.
+  # Example:
+  #   Twilio.connect('my_twilio_sid', 'my_auth_token')
+  #   Twilio::OutgoingCallerId.list
+  class OutgoingCallerId < TwilioObject
+    def create(phone_number, friendly_name = phone_number, call_delay = 0)
+      Twilio.post("/OutgoingCallerIds", :body => {
+        :PhoneNumber => phone_number, 
+        :FriendlyName => friendly_name, 
+        :CallDelay => call_delay 
+      })
+    end
+
+    def list(optional = {})
+      Twilio.get("/OutgoingCallerIds", :query => optional) 
+    end
+        
+    def get(callerid_sid)
+      Twilio.get("/OutgoingCallerIds/#{callerid_sid}") 
+    end
+    
+    def update_name(callerid_sid, name)
+      Twilio.put("/OutgoingCallerIds/#{callerid_sid}", :body => {:FriendlyName => name})
+    end
+    
+    def delete(callerid_sid)
+      Twilio.delete("/OutgoingCallerIds/#{callerid_sid}")
+    end
+  end
+end

data/lib/twilio/recording.rb

@@ -0,0 +1,24 @@
+module Twilio
+  # Recordings are generated when you use the Record Verb. Those recordings are 
+  # hosted on Twilio's REST API for you to access. 
+  # Example:
+  #   Twilio.connect('my_twilio_sid', 'my_auth_token')
+  #   Twilio::Recording.list
+  class Recording < TwilioObject    
+    def list(optional = {})
+      Twilio.get("/Recordings", :query => optional)  
+    end
+    
+    def get(recording_sid)
+      Twilio.get("/Recordings/#{recording_sid}")  
+    end
+    
+    def delete(recording_sid)
+      Twilio.delete("/Recordings/#{recording_sid}")
+    end
+    
+    def transcriptions(recording_sid, transcription_sid = nil)
+      Twilio.get("/Recordings/#{recording_sid}/Transcriptions#{ '/' + transcription_sid if transcription_sid }") 
+    end
+  end
+end

data/lib/twilio/toll_free_phone_number.rb

@@ -0,0 +1,21 @@
+module Twilio
+  # This sub-resource represents only Toll Free phone numbers, or in other words, not local numbers. 
+  # Also allows you to request a new toll free phone number be added to your account. 
+  # Example:
+  #   Twilio.connect('my_twilio_sid', 'my_auth_token')
+  #   Twilio::TollFreePhoneNumber.list
+  class TollFreePhoneNumber < TwilioObject
+    def create(url, area_code = nil, method = 'POST', friendly_name = nil)
+      Twilio.post("/IncomingPhoneNumbers/TollFree", :body => {
+        :Url => url, 
+        :AreaCode => area_code, 
+        :Method => method,
+        :FriendlyName => friendly_name 
+      })
+    end
+    
+    def list
+      Twilio.get("/IncomingPhoneNumbers/TollFree")
+    end
+  end
+end

data/lib/twilio/twilio_object.rb

@@ -0,0 +1,16 @@
+module Twilio
+  class TwilioObject  #:nodoc: all    
+    attr_reader :connection
+    
+    def initialize(connection = nil)
+      @connection = connection
+    end
+    
+    class << self
+      def method_missing(method_id, *args) #:nodoc:
+        o = self.new
+        o.send(method_id, *args)
+      end
+    end
+  end
+end

data/lib/twilio/verb.rb

@@ -0,0 +1,315 @@
+module Twilio
+  # Twilio Verbs enable your application to respond to Twilio requests (to your app) with XML responses.
+  # There are 5 primary verbs (say, play, gather, record, dial) and 3 secondary (hangup, pause, redirect).
+  # Verbs can be chained and, in some cases, nested.
+  #
+  # If your response consists of a single verb, you can call a Verb class method:
+  #
+  #   Twilio::Verb.say('The time is 9:35 PM.')
+  #
+  # But if you need to chain several verbs together, just wrap them in an instance block and call the 'response' attribute:
+  #
+  #   verb = Twilio::Verb.new { |v|
+  #     v.dial('415-123-4567')
+  #     v.redirect('http://www.foo.com/nextInstructions')
+  #   }
+  #   verb.response
+  class Verb
+    
+    attr_reader :response
+    
+    class << self
+      def method_missing(method_id, *args) #:nodoc:
+        v = Verb.new
+        v.send(method_id, *args)
+      end
+    end
+        
+    def initialize(&block)
+      @xml = Builder::XmlMarkup.new
+      @xml.instruct!
+      
+      if block_given?
+        @chain = true
+        @response = @xml.Response { block.call(self) }
+      end
+    end
+        
+    # The Say verb converts text to speech that is read back to the caller. 
+    # Say is useful for dynamic text that is difficult to prerecord. 
+    #
+    # Examples:
+    #   Twilio::Verb.say('The time is 9:35 PM.')
+    #   Twilio::Verb.say('The time is 9:35 PM.', :loop => 3)
+    #
+    # With numbers, 12345 will be spoken as "twelve thousand three hundred forty five" while
+    # 1 2 3 4 5 will be spoken as "one two three four five."
+    #
+    #   Twilio::Verb.say('Your PIN is 1234', :loop => 4)
+    #   Twilio::Verb.say('Your PIN is 1 2 3 4', :loop => 4)
+    # 
+    # If you need a longer pause between each loop, instead of explicitly calling the Pause
+    # verb within a block, you can set the convenient pause option:
+    #
+    #   Twilio::Verb.say('Your PIN is 1 2 3 4', :loop => 4, :pause => true)
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/say) are passed in as a hash:
+    #
+    #   Twilio::Verb.say('The time is 9:35 PM.', :voice => 'woman')
+    #   Twilio::Verb.say('The time is 9:35 PM.', {:voice => 'woman', :language => 'es'})
+    def say(*args)
+      options = {:voice => 'man', :language => 'en', :loop => 1}
+      args.each do |arg|
+        case arg
+        when String
+          options[:text_to_speak] = arg
+        when Hash
+          options.merge!(arg)
+        else
+          raise ArgumentError, 'say expects String or Hash argument'
+        end
+      end
+      
+      output {
+        if options[:pause]
+          loop_with_pause(options[:loop], @xml) do
+            @xml.Say(options[:text_to_speak], :voice => options[:voice], :language => options[:language])
+          end
+        else
+          @xml.Say(options[:text_to_speak], :voice => options[:voice], :language => options[:language], :loop => options[:loop])
+        end
+      }
+    end
+    
+    # The Play verb plays an audio URL back to the caller. 
+    # Examples:
+    #   Twilio::Verb.play('http://foo.com/cowbell.mp3')
+    #   Twilio::Verb.play('http://foo.com/cowbell.mp3', :loop => 3)
+    #
+    # If you need a longer pause between each loop, instead of explicitly calling the Pause
+    # verb within a block, you can set the convenient pause option:
+    #
+    #   Twilio::Verb.play('http://foo.com/cowbell.mp3', :loop => 3, :pause => true)
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/play) are passed in as a hash,
+    # but only 'loop' is currently supported.
+    def play(*args)
+      options = {:loop => 1}
+      args.each do |arg|
+        case arg
+        when String
+          options[:audio_url] = arg
+        when Hash
+          options.merge!(arg)
+        else
+          raise ArgumentError, 'play expects String or Hash argument'
+        end
+      end
+
+      output {
+        if options[:pause]
+          loop_with_pause(options[:loop], @xml) do
+            @xml.Play(options[:audio_url])
+          end
+        else
+          @xml.Play(options[:audio_url], :loop => options[:loop])
+        end          
+      }
+    end
+    
+    # The Gather verb collects digits entered by a caller into their telephone keypad. 
+    # When the caller is done entering data, Twilio submits that data to a provided URL, 
+    # as either a HTTP GET or POST request, just like a web browser submits data from an HTML form. 
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/gather) are passed in as a hash
+    #
+    # Examples:
+    #   Twilio::Verb.gather
+    #   Twilio::Verb.gather(:action => 'http://foobar.com')
+    #   Twilio::Verb.gather(:finishOnKey => '*') 
+    #   Twilio::Verb.gather(:action => 'http://foobar.com', :finishOnKey => '*') 
+    #
+    # Gather also lets you nest the Play, Say, and Pause verbs:
+    #
+    #   verb = Twilio::Verb.new { |v|
+    #     v.gather(:action => '/process_gather', :method => 'GET) {
+    #       v.say('Please enter your account number followed by the pound sign')
+    #     }
+    #     v.say("We didn't receive any input. Goodbye!")
+    #   }
+    #   verb.response # represents the final xml output
+    def gather(*args, &block)
+      options = args.shift || {}
+      output { 
+        if block_given?
+          @xml.Gather(options) { block.call }
+        else
+          @xml.Gather(options)          
+        end
+      }
+    end
+    
+    #play, say, pause
+    
+    # The Record verb records the caller's voice and returns a URL that links to a file 
+    # containing the audio recording.
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/record) are passed in as a hash
+    #
+    # Examples:
+    #   Twilio::Verb.record
+    #   Twilio::Verb.record(:action => 'http://foobar.com')
+    #   Twilio::Verb.record(:finishOnKey => '*') 
+    #   Twilio::Verb.record(:transcribe => true, :transcribeCallback => '/handle_transcribe')
+    def record(*args)
+      options = args.shift
+      output { @xml.Record(options) }
+    end
+    
+    # The Dial verb connects the current caller to an another phone. If the called party picks up, 
+    # the two parties are connected and can communicate until one hangs up. If the called party does 
+    # not pick up, if a busy signal is received, or the number doesn't exist, the dial verb will finish.
+    #
+    # If an action verb is provided, Twilio will submit the outcome of the call attempt to the action URL. 
+    # If no action is provided, Dial will fall through to the next verb in the document.
+    #
+    # Note: this is different than the behavior of Record and Gather. Dial does not submit back to the 
+    # current document URL if no action is provided.
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/dial) are passed in as a hash
+    #
+    # Examples:
+    #   Twilio::Verb.dial('415-123-4567')
+    #   Twilio::Verb.dial('415-123-4567', :action => 'http://foobar.com')
+    #   Twilio::Verb.dial('415-123-4567', {:timeout => 10, :callerId => '858-987-6543'}) 
+    #
+    # Twilio also supports an alternate form in which a Number object is nested inside Dial:
+    #
+    #   verb = Twilio::Verb.new { |v|
+    #     v.dial {
+    #       v.number('415-123-4567')
+    #       v.number('415-123-4568')
+    #       v.number('415-123-4569')
+    #     }
+    #   }
+    #   verb.response # represents the final xml output
+    def dial(*args, &block)
+      number_to_dial = ''
+      options = {}
+      args.each do |arg|
+        case arg
+        when String
+          number_to_dial = arg
+        when Hash
+          options.merge!(arg)
+        else
+          raise ArgumentError, 'dial expects String or Hash argument'
+        end
+      end
+      
+      output { 
+        if block_given?
+          @xml.Dial(options) { block.call }
+        else
+          @xml.Dial(number_to_dial, options)           
+        end
+      }
+    end
+        
+    # The Pause (secondary) verb waits silently for a number of seconds. 
+    # It is normally chained with other verbs. 
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/pause) are passed in as a hash
+    #
+    # Examples:
+    #   verb = Twilio::Verb.new { |v|
+    #     v.say('greetings')
+    #     v.pause(:length => 2)
+    #     v.say('have a nice day')
+    #   }
+    #   verb.response
+    def pause(*args)
+      options = args.shift
+      output { @xml.Pause(options) }
+    end
+    
+    # The Redirect (secondary) verb transfers control to a different URL.
+    # It is normally chained with other verbs.
+    #
+    # Options (see http://www.twilio.com/docs/api_reference/TwiML/redirect) are passed in as a hash
+    #
+    # Examples:
+    #   verb = Twilio::Verb.new { |v|
+    #     v.dial('415-123-4567')
+    #     v.redirect('http://www.foo.com/nextInstructions')
+    #   }
+    #   verb.response
+    def redirect(*args)
+      redirect_to_url = ''
+      options = {}
+      args.each do |arg|
+        case arg
+        when String
+          redirect_to_url = arg
+        when Hash
+          options.merge!(arg)
+        else
+          raise ArgumentError, 'dial expects String or Hash argument'
+        end
+      end
+      
+      output { @xml.Redirect(redirect_to_url, options) }
+    end
+    
+    # The Hangup (secondary) verb ends the call. 
+    # 
+    # Examples:
+    #   If your response is only a hangup:
+    #
+    #   Twilio::Verb.hangup
+    #
+    #   If your response is chained:
+    #
+    #   verb = Twilio::Verb.new { |v|
+    #     v.say("The time is #{Time.now}")
+    #     v.hangup
+    #   }
+    #   verb.response
+    def hangup
+      output { @xml.Hangup }
+    end
+    
+    # The Number element specifies a phone number. The number element has two optional attributes: sendDigits and url.
+    # Number elements can only be nested in Dial verbs
+    def number(*args)
+      number_to_dial = ''
+      options = {}
+      args.each do |arg|
+        case arg
+        when String
+          number_to_dial = arg
+        when Hash
+          options.merge!(arg)
+        else
+          raise ArgumentError, 'dial expects String or Hash argument'
+        end
+      end
+      
+      output { @xml.Number(number_to_dial, options) }
+    end
+          
+    private
+    
+      def output
+        @chain ? yield : @xml.Response { yield }
+      end 
+    
+      def loop_with_pause(loop_count, xml, &verb_action)
+        last_iteration = loop_count-1                               
+        loop_count.times do |i|
+          yield verb_action
+          xml.Pause unless i == last_iteration
+        end
+      end
+  end
+end