twilio-rb 1.0beta2 → 2.0.0

data/README.md

@@ -1,7 +1,6 @@
-
 # Twilio.rb
 
-Interact with the Twilio API in a nice Ruby way. 
+Interact with the Twilio API in a nice Ruby way.
 
 Twilio.rb is the only library that encapsulates Twilio resources as Ruby objects, has 100% test coverage, and supports the whole API.
 
@@ -9,7 +8,7 @@ It offers an ActiveRecord style API, i.e. one that most Ruby developers are fami
 
 ## Installation
 
-The library has been packaged as a gem and is available from rubygems.org. The version that this readme pertains to is 1.0beta. To install use the `--pre` flag
+The library has been packaged as a gem and is available from rubygems.org. The version that this readme pertains to is 2.0.0.
 
 <pre>gem install twilio-rb --pre</pre>
 
@@ -19,49 +18,146 @@ Please use the Github issue tracker to report any issues or bugs you uncover.
 
 Require the library in your script as
 
-<pre>require 'twilio'</pre>
+<pre>require 'twilio-rb'</pre>
 
 or using bundler:
 
-<pre>gem 'twilio-rb', '1.0beta', :require => 'twilio'</pre>
+<pre>gem 'twilio-rb'</pre>
 
 ## Configuration
 
-Configuration for this library is encapsulated within `Twilio::Config`. One needs to setup with an Account SID and an Auth Token, e.g.
+Configuration for this library is achieved with `Twilio::Config.setup`. One needs to setup with an Account SID and an Auth Token, e.g.
 
 <pre># This should be in an initializer or similar
-Twilio::Config.setup do
-  account_sid   'AC0000000000000000000000000000'
-  auth_token    '000000000000000000000000000000'
+Twilio::Config.setup \
+  :account_sid  => 'AC0000000000000000000000000000',
+  :auth_token   => '000000000000000000000000000000'
 end</pre>
 
 Any method that calls the Twilio API will raise `Twilio::ConfigurationError` if either Account SID or Auth Token are not configured.
 
 # Getting started
 
+## Summary
+
+Twilio resources are represented as Ruby objects. List resources are represnted by classes, e.g. `Twilio::SMS` and operations on list resources are performed using class methods, e.g. `Twilio::SMS.create`. Resource instances are represented by instances of those classes, and operations on those resource instances are perfomed using instance methods.
+
+Resources that can be created via the API, using the HTTP POST verb can be done so in the library using the `.create` class method, e.g.
+
+<pre>Twilio::Call.create :to => '+16465551234', :from => '+19175550000',
+                    :url => "http://example.com/call_handler"</pre>
+
+Resources that can be removed via the API, using the HTTP DELETE verb can be done so in the library using the `#destroy` instance method, e.g.
+
+<pre>
+# Delete all log entries
+Twilio::Notification.all.each &:destroy
+</pre>
+
+Object representations instantiated by the library respond to all methods that match attributes on its corresponding resource. The method names are those of the parameters in snake case (underscored), i.e. as they are returned in the JSON representation.
+
+The Twilio API documentation itself is the canonical reference for which resources have what properties, and which of those can be updated by the API. Please refer to the Twilio REST API documentation for thos information.
+
+## Accessing resource instances
+
+Resource instances can be accessed ad hoc passsing the resource sid to the `.find` class method on the resource class, e.g.
+
+<pre>call = Twilio::Call.find 'CAe1644a7eed5088b159577c5802d8be38'</pre>
+
+This will return an instance of the resource class, in this case `Twilio::Call`, with the attributes of the resource. These attributes are accessed using dynamically defined getter methods, where the method name is the attribute name underscored, i.e. as they are returned in a JSON response from the API.
+
+Sometimes these method name might collide with native Ruby methods, one such example is the `method` parameter colliding with `Object#method`. Native Ruby methods are never overridden by the library as they are lazily defined using `method_missing`. To access these otherwise unreachable attributes, there is another syntax for accessing resource attributes:
+
+<pre>
+call = Twilio::Call.find 'CAe1644a7eed5088b159577c5802d8be38'
+call[:method] # With a symbol or
+call['method'] # or with a string. Access is indifferent.
+</pre>
+
+## Querying list resources
+
+List resources can be accessed ad hoc by calling the `.all` class method on the resource class, e.g.
+
+<pre>calls = Twilio::Call.all</pre>
+
+This will return a collection of objects, each a representation of the corresponding resource.
+
+### Using filter parameters to refine a query
+
+The `.all` class method will ask Twilio for all resource instances on that list resource, this can easily result in a useless response if there are numerous resource instances on a given resource. The `.all` class method accepts a hash of options for parameters to filter the response, e.g.
+
+<pre>Twilio::Call.all :to => '+19175550000', :status => 'complete'</pre>
+
+Twilio does some fancy stuff to implement date ranges, consider the API request:
+
+<pre>GET /2010-04-01/Accounts/AC5ef87.../Calls?StartTime&gt;=2009-07-06&EndTime&lt;=2009-07-10</pre>
+
+This will return all calls started after midnight July 06th 2009 and completed before July 10th 2009. Any call started and ended within that time range matches those criteria and will be returned. To make the same reqest using this library:
+
+<pre>
+require 'date'
+start_date, end_date = Date.parse('2009-07-06'),  Date.parse('2009-07-10')
+
+Twilio::Call.all :started_after => start_date, :ended_before => end_date
+</pre>
+
+All option parameters pertaining to dates accept a string or any object that returns a RFC 2822 date when `#to_s` is called on it, e.g. an instance of `Date`. If a date parameter is not a rnage but absolute, one can of course use the normal option, e.g.
+
+<pre>Twilio::Call.all :start_time => start_date</pre>
+
+The key names for these Date filters are inconsistent across resources, in the library they are:
+
+<pre>
+Twilio::SMS.all :created_before => date, :created_after => date, :sent_before => date, :sent_after # :"created_#{when}" and :"sent_#{when}" are synonomous
+Twilio::Notification.all :created_before => date, :created_after => date
+Twilio::Call.all :started_before => date, :started_after => date, :ended_before => date, :ended_after => date
+</pre>
+
+### Pagination
+
+The Twilio API paginates API responses and by default it will return 30 objects in one response, this can be overridden to return up to a maximum of 1000 per response using the `:page_size` option, If more than 1000 resources instances exist, the `:page` option is available, e.g.
+
+<pre>Twilio::Call.all :started_after => start_date, :ended_before => end_date, :page_size => 1000, :page => 7</pre>
+
+To determine how many resources exist, the `.count` class method exists, which accepts the same options as `.all` in order to constrain the query e.g.
+
+<pre>Twilio::Call.count :started_after => start_date, :ended_before => end_date</pre>
+
+It returns an integer corresponding to how many resource instances exist with those conditions.
+
+## Updating resource attributes
+
+Certain resources have attributes that can be updated with the REST API. Instances of those resources can be updated using either a setter method with a name that corresponds to the attribute, or by using the `#update_attributes`.
+
+<pre>
+call = Twilio::Call.all(:status => 'in-progress').first
+
+call.url = 'http://example.com/in_ur_apiz_hijackin_ur_callz.xml'
+call.update_attributes :url => 'http://example.com/in_ur_apiz_hijackin_ur_callz.xml'
+</pre>
+
+These are both equivalent, i.e. they immediately make an API request and update the state of the object with the API response. The first one in fact uses the second one internally and is just a shortcut. Use the second when there is more than one attribute to be updated in the same HTTP request.
+
 ## Making a telephone call
 
 The API used to make a telephone call is similar to interacting with an ActiveRecord model object.
-<pre>Twilio::Call.create :to => '+16465551234', :from => '+19175550000', 
+<pre>Twilio::Call.create :to => '+16465551234', :from => '+19175550000',
                     :url => "http://example.com/call_handler"</pre>
 
 The parameter keys should be given as underscored symbols. They will be converted internally to camelized strings prior to an API call being made.
 
-Please see the Twilio REST API documentation for an up to date list of supported parameters. 
+Please see the Twilio REST API documentation for an up to date list of supported parameters.
 
 If the request was successful, an instance of `Twilio::Call` wil be returned
 
 ### Modifying a live telephone call
 
-Once a call has been been created it can be modified with the following methods:
+As well as the the aforementioned setter methods, once a call has been been created it can be modified with the following convenience methods:
 
 `Twilio::Call#cancel!` will terminate the call if its state is `queued` or `ringing`
 `Twilio::Call#complete!` will terminate the call even if its state is `in-progress`
 `Twilio::Call#url=` will immediately redirect the call to a new handler URL
 
-`Twilio::Call#cancel!` and `Twilio::Call#complete!` will raise `Twilio::InvalidStateError` if the call has not been "saved". 
-`Twilio::Call#url=` will updated its state with the new URL ready for when `Twilio::Call#save` is called.
-
 ## Finding an existing telephone call
 
 To retrieve an earlier created call, there is the `Twilio::Call.find` method, which accepts a call SID, e.g.
@@ -73,7 +169,7 @@ This returns an instance of `Twilio::Call` if a call with the given SID was foun
 ## Sending an SMS message
 
 The API used to send an SMS message is similar to interacting with an ActiveRecord model object.
-<pre>Twilio::SMS.create :to => '+16465551234', :from => '+19175550000', 
+<pre>Twilio::SMS.create :to => '+16465551234', :from => '+19175550000',
                    :body => "Hey baby, how was your day? x"</pre>
 
 The parameter keys should be given as underscored symbols. They will be converted internally to camelized strings prior to an API call being made.
@@ -82,7 +178,7 @@ Please see the Twilio REST API documentation for an up to date list of supported
 
 If the request was successful, an instance of `Twilio::SMS` wil be returned
 
-## Finding an existing telephone SMS message
+## Finding an existing SMS message
 
 To retrieve an earlier created SMS message, there is the `Twilio::SMS.find` method, which accepts a SMS message SID, e.g.
 
@@ -90,13 +186,95 @@ To retrieve an earlier created SMS message, there is the `Twilio::SMS.find` meth
 
 This returns an instance of `Twilio::SMS` if a SMS message with the given SID was found, otherwise nil is returned
 
+# Twilio Client
+
+To generate capability tokens for use with Twilio Client you can use `Twilio::CapabilityToken.create`
+
+<pre>
+Twilio::CapabilityToken.create \
+  allow_incoming: 'unique_identifier_for_this_user',
+  allow_outgoing: 'your_application_sid'
+</pre>
+
+You can create capability tokens on arbitrary accounts, e.g. subaccounts. Just pass in those details:
+
+<pre>
+Twilio::CapabilityToken.create \
+  account_sid:    'AC00000000000000000000000',
+  auth_token:     'XXXXXXXXXXXXXXXXXXXXXXXXX',
+  allow_incoming: 'unique_identifier_for_this_user',
+  allow_outgoing: 'your_application_sid'
+</pre>
+
+You can also pass arbitrary parameters into your outgoing privilege, these are sent from Twilio as HTTP request params when it hits your app endpoint for TwiML.
+
+<pre>
+Twilio::CapabilityToken.create allow_outgoing: ['your_application_sid', { :foo => 'bar' }]
+</pre>
+
+By default tokens expire exactly one hour from the time they are generated. You can choose your own token ttl like so:
+
+<pre>
+Twilio::CapabilityToken.create \
+  allow_incoming: 'unique_identifier_for_this_user',
+  allow_outgoing: 'your_application_sid',
+  expires:        10.minutes.from_now
+</pre>
+
+# Associations
+
+Certain resources themselves have subresources, e.g. a call can have many recordings. It would be very convenient to access these via an association proxy, so instead of:
+
+<pre>
+calls = Twilio::Call.all
+recordings = Twilio::Recording.all :call_sid => calls.last.sid
+</pre>
+
+You might prefer:
+
+<pre>
+calls = Twilio::Call.all
+recordings = calls.recordings.all
+</pre>
+
+twilio-rb now supports these association proxies
+
+# Subaccounts
+
+The Twilio REST API supports subaccounts that is discrete accounts owned by a master account. twilio-rb supports this too.o
+
+## Subaccount creation
+
+You can create new subaccounts by using `Twilio::Account.create`
+
+## Performing actions on resources belonging to subaccounts
+
+There are three ways to perform an operation on an account other than the master account: you can pass in the subaccount sid
+
+<pre>Twilio::SMS.create :to => '+19175551234' :from => '+16465550000',
+  :body => 'This will be billed to a subaccount, sucka!' :account => 'ACXXXXXXXXXXXXXXXXXXXXXXXX'</pre>
+
+You can also pass in an object that responds to sid, i.e. an instance of Twilio::Account
+
+<pre>Twilio::SMS.create :to => '+19175551234' :from => '+16465550000',
+  :body => 'This TOO will be billed to a subaccount, sucka!' :account => my_subaccount_object</pre>
+
+By using an association proxy. By chaining the list resource methods, e.g. find, create, etc, on the association proxy, they are scoped to that account
+
+<pre>
+bobs_account = Twilio::Account.find :friendly_name => "Bob's subaccount"
+
+# This will send a SMS message on Bob's subaccount
+bobs_account.sms.create :to => '+16465551234', :from => '+19175550000', :body => "Bob is paying for this text. What a guy!"
+</pre>
+
 # Building TwiML documents
 
 A TwiML document is an XML document. The best way to build XML in Ruby is with Builder, and so it follows that we should use builder for TwiML. `Twilio::TwiML.build` behaves like builder except element names are capitalised for you and attributes are camelized for you as well. This is so you may continue to write beautiful code.
 
 The following Ruby code:
 
-<pre>Twilio::TwiML.build do |res| 
+<pre>Twilio::TwiML.build do |res|
   res.say    'Hey man! Listen to this!', :voice => 'man'
   res.play   'http://foo.com/cowbell.mp3'
   res.say    'What did you think of that?!', :voice => 'man'
@@ -151,109 +329,6 @@ res.say 'Damn this library is so ill dude!'
 
 It's now easier than ever to integrate Twilio in your Rails app cleanly and easily.
 
-# Basics
-
-Each super-resource, e.g. Calls, OutgoingCallerIds, etc has a Ruby object in the Twilio namespace representing it, Twilio::Call, Twilio::OutgoingCallerId, etc.
-
-## Summary
-
-Resources that can be created via the API, using the HTTP POST verb can be done so in the library using the `.create` class method, e.g.
-
-<pre>Twilio::Call.create :to => '+16465551234', :from => '+19175550000', 
-                    :url => "http://example.com/call_handler"</pre>
-
-Resources that can be removed via the API, using the HTTP DELETE verb can be done so in the library using the `#destroy` instance method, e.g.
-
-<pre>
-# Delete all log entries
-Twilio::Notification.all.each &:destroy
-</pre>
-
-Object representations instantiated by the library respond to all methods that match attributes on its corresponding resource. The method names are those of the parameters in snake case (underscored), i.e. as they are returned in the JSON representation. 
-
-The Twilio API documentation itself is the canonical reference for which resources have what properties, and which of those can be updated by the API. Please refer to the Twilio REST API documentation for thos information.
-
-## Accessing resource instances
-
-Resource instances can be accessed ad hoc passsing the resource sid to the `.find` class method on the resource class, e.g.
-
-<pre>call = Twilio::Call.find 'CAe1644a7eed5088b159577c5802d8be38'</pre>
-
-This will return an instance of the resource class, in this case `Twilio::Call`, with the attributes of the resource. These attributes are accessed using dynamically defined getter methods, where the method name is the attribute name underscored, i.e. as they are returned in a JSON response from the API. 
-
-Sometimes these method name might collide with native Ruby methods, one such example is the `method` parameter colliding with `Object#method`. Native Ruby methods are never overridden by the library as they are lazily defined using `method_missing`. To access these otherwise unreachable attributes, there is another syntax for accessing resource attributes:
-
-
-<pre>
-call = Twilio::Call.find 'CAe1644a7eed5088b159577c5802d8be38'
-call[:method] # With a symbol or 
-call['method'] # or with a string. Access is indifferent.
-</pre>
-
-## Querying list resources
-
-List resources can be accessed ad hoc by calling the `.all` class method on the resource class, e.g.
-
-<pre>calls = Twilio::Call.all</pre>
-
-This will return a collection of objects, each a representation of the corresponding resource.
-
-### Using filter parameters to refine a query
-
-The `.all` class method will ask Twilio for all resource instances on that list resource, this can easily result in a useless response if there are numerous resource instances on a given resource. The `.all` class method accepts a hash of options for parameters to filter the response, e.g.
-
-<pre>Twilio::Call.all :to => '+19175550000', :status => 'complete'</pre>
-
-Twilio does some fancy stuff to implement date ranges, consider the API request:
-
-<pre>GET /2010-04-01/Accounts/AC5ef87.../Calls?StartTime&gt;=2009-07-06&EndTime&lt;=2009-07-10</pre>
-
-This will return all calls started after midnight July 06th 2009 and completed before July 10th 2009. Any call started and ended within that time range matches those criteria and will be returned. To make the same reqest using this library:
-
-<pre>
-require 'date'
-start_date, end_date = Date.parse('2009-07-06'),  Date.parse('2009-07-10')
-
-Twilio::Call.all :started_after => start_date, :ended_before => end_date
-</pre>
-
-All option parameters pertaining to dates accept a string or any object that returns a RFC 2822 date when `#to_s` is called on it, e.g. an instance of `Date`. If a date parameter is not a rnage but absolute, one can of course use the normal option, e.g.
-
-<pre>Twilio::Call.all :start_time => start_date</pre>
-
-The key names for these Date filters are inconsistent across resources, in the library they are:
-
-<pre>
-Twilio::SMS.all :created_before => date, :created_after => date, :sent_before => date, :sent_after # :"created_#{when}" and :"sent_#{when}" are synonomous
-Twilio::Notification.all :created_before => date, :created_after => date
-Twilio::Call.all :started_before => date, :started_after => date, :ended_before => date, :ended_after => date
-</pre>
-
-### Pagination
-
-The Twilio API paginates API responses and by default it will return 30 objects in one response, this can be overridden to return up to a maximum of 1000 per response using the `:page_size` option, If more than 1000 resources instances exist, the `:page` option is available, e.g.
-
-<pre>Twilio::Call.all :started_after => start_date, :ended_before => end_date, :page_size => 1000, :page => 7</pre>
-
-To determine how many resources exist, the `.count` class method exists, which accepts the same options as `.all` in order to constrain the query e.g.
-
-<pre>Twilio::Call.count :started_after => start_date, :ended_before => end_date</pre>
-
-It returns an integer corresponding to how many resource instances exist with those conditions.
-
-## Updating resource attributes
-
-Certain resources have attributes that can be updated with the REST API. Instances of those resources can be updated using either a setter method with a name that corresponds to the attribute, or by using the `#update_attributes`.
-
-<pre>
-call = Twilio::Call.all(:status => 'in-progress').first
-
-call.url = 'http://example.com/in_ur_apiz_hijackin_ur_callz.xml'
-call.update_attributes :url => 'http://example.com/in_ur_apiz_hijackin_ur_callz.xml'
-</pre>
-
-These are both equivalent, i.e. they immediately make an API request and update the state of the object with the API response. The first one in fact uses the second one internally and is just a shortcut. Use the second when there is more than one attribute to be updated in the same HTTP request.
-
 ## Manipulating conference participants
 
 The participants list resource is a subresource of a conference resource instance:
@@ -272,26 +347,17 @@ Participants can be removed from the conference using the '#destroy instance met
 
 # Singleton resources
 
-The Twilio API in its current incarnation has two singleton (scoped per account) resources, correspondingly there are the Twilio::Account, and Twilio::Sandbox singleton objects.
+The Twilio API in its current incarnation has one singleton (scoped per account) resource, correspondingly there is Twilio::Sandbox singleton objects.
 
 To access properties of a singleton object the property name should be called as a method on the object itself, e.g.
 
-<pre>Twilio::Account.friendly_name</pre>
+<pre>Twilio::Sandobox.friendly_name</pre>
 
 The first time a method is invoked on the object an API call is made to retrieve the data. The methods themselves are not defined until they are called, i.e. lazy evaluation. This strategy means that addtional properties added to subsequent versions of the API should not break the library.
 
 To reload the data when needed `Twilio::Account.reload!` will make another API call and update its own internal state.
 
-The account has a predicate method i.e.  ending in `?`, it maps directly to the status of the account, e.g. `Twilio::Account.suspended?` returns true if Twilio have suspended your account. Again, this is defined on the fly.
-
-The only account property that can be modified via the REST API is the friendly name, e.g.
-
-<pre>Twilio::Account.friendly_name = "I'm so vain, I had to change my name!"</pre>
-<pre>Twilio::Account.update_attributes :friendly_name => "I'm so vain, I had to change my name!"</pre>
-
-This will update the API immediately with a POST request.
-
-Twilio::Sandbox supports more options. Please refer to the Twilio REST API documentation for an up to date list of properties.
+Please refer to the Twilio REST API documentation for an up to date list of properties that the sandbox resource implements
 
 # Searching for and purchasing available phone numbers
 
@@ -311,6 +377,11 @@ Twilio::IncomingPhoneNumber.create :phone_number => numbers.first.phone_number,
 
 # Recordings
 
-A recording resource instance has an extra instance method: `#mp3` this returns a publicly accessible URL for the MP3 representation of the resource instance. 
+A recording resource instance has an extra instance method: `#mp3` this returns a publicly accessible URL for the MP3 representation of the resource instance.
 
+# Contributors
 
+* Stevie Graham
+* TJ Singleton
+* Christopher Durtschi
+* Dan Imrie-Situnayake

data/lib/railtie.rb

@@ -11,7 +11,7 @@ module Twilio
               def compile(template)
                 <<-EOS
                 controller.content_type = 'text/xml'
-                Twilio::TwiML.build {|res| #{template.source} }
+                Twilio::TwiML.build { |res| #{template.source} }
                 EOS
               end
             end
@@ -19,6 +19,8 @@ module Twilio
         end
       end
 
+      ActionController::Base.class_eval { before_filter Twilio::RequestFilter }
+
       ::ActionView::Template.register_template_handler(:voice, ActionView::Template::Handlers::TwiML)
       ::Mime::Type.register_alias 'text/xml', :voice
     end

data/lib/twilio/account.rb

@@ -1,25 +1,22 @@
 module Twilio
-  module Account
+  class Account
     include Twilio::Resource
-    @attributes = {}.with_indifferent_access
+    include Twilio::Persistable
+    extend Twilio::Associations
+    extend Twilio::Finder
 
-    def attributes
-      @attributes.empty? ? reload! : @attributes
-    end
+    mutable_attributes :friendly_name, :status
 
-    def reload!
-      handle_response get path
-    end
+    has_many :calls, :sms, :recordings, :conferences, :incoming_phone_numbers,
+      :notifications, :outgoing_caller_ids, :transcriptions
 
-    def friendly_name=(name)
-      update_attributes :friendly_name => name
+    class << self
+      private
+      def resource_path(account_sid)
+        "/Accounts"
+      end
     end
 
-    private
-    def path
-      "/Accounts/#{Twilio::ACCOUNT_SID}.json"
-    end
-
-    extend self
   end
 end
+

data/lib/twilio/application.rb

@@ -0,0 +1,14 @@
+module Twilio
+  class Application
+    extend Twilio::Finder
+    include Twilio::Resource
+    include Twilio::Persistable
+    include Twilio::Deletable
+
+    mutable_attributes :friendly_name, :api_version, :voice_url, :voice_method, :voice_fallback_url,
+      :voice_fallback_method, :status_callback, :status_callback_method, :sms_url, :sms_method,
+      :sms_fallback_url, :sms_fallback_method
+
+  end
+end
+

data/lib/twilio/association_proxy.rb

@@ -0,0 +1,22 @@
+require 'active_support/core_ext/string'
+
+module Twilio
+  class AssociationProxy
+    instance_methods.each { |meth| undef_method meth unless meth.to_s =~ /^__/ }
+    def initialize(delegator, target)
+      @delegator, @target = delegator, target
+      @delegator_name = @delegator.class.name.demodulize.downcase
+    end
+
+    def inspect
+      @target.all :"#{@delegator_name}_sid" => @delegator.sid
+    end
+
+    def method_missing(meth, *args, &blk)
+      options = args.empty? ? args.<<({})[-1] : args[-1]
+      options.update :"#{@delegator_name}_sid" => @delegator.sid
+      @target.__send__ meth, *args, &blk
+    end
+  end
+end
+

data/lib/twilio/associations.rb

@@ -0,0 +1,14 @@
+require 'active_support/core_ext/string'
+
+module Twilio
+  module Associations
+    def has_many(*collection)
+      collection.each do |objects|
+        define_method(objects) do
+          klass = Twilio.const_get objects.to_s.singularize.camelize
+          Twilio::AssociationProxy.new self, klass
+        end
+      end
+    end
+  end
+end

data/lib/twilio/call.rb

@@ -2,7 +2,12 @@ module Twilio
   class Call
     include Twilio::Resource
     include Twilio::Persistable
-    extend Twilio::Finder
+    extend  Twilio::Finder
+    extend  Twilio::Associations
+
+    has_many :recordings
+
+    mutable_attributes :url, :method, :status
 
     class << self
       alias old_create create
@@ -17,11 +22,10 @@ module Twilio
       private
       def prepare_params(opts) # :nodoc:
         pairs = opts.map do |k,v|
-          if [:started_before, :started_after, :ended_before, :ended_after].include? k
-            k = k.to_s
+          if %w(started_before started_after ended_before ended_after).include? k
             # Fancy schmancy-ness to handle Twilio <= URI operator for dates
             comparator = k =~ /before$/ ? '<=' : '>='
-            delineator = k =~ /started/ ? 'Start' : 'End' 
+            delineator = k =~ /started/ ? 'Start' : 'End'
             CGI.escape(delineator << "Time" << comparator << v.to_s)
           else
             "#{k.to_s.camelize}=#{CGI.escape v.to_s}"
@@ -40,11 +44,5 @@ module Twilio
       update_attributes :status => 'completed'
     end
 
-    # Update Handler URL
-    def url=(url)
-      # If this attribute exists it is assumed the API call to create a call has been made, so we need to tell Twilio.
-      update_attributes :url => url if self[:status]
-      self[:url] = url
-    end
   end
-end
+end

data/lib/twilio/capability.rb

@@ -0,0 +1,51 @@
+module Twilio
+  module CapabilityToken
+    def create(opts={})
+      opts.stringify_keys!
+      account_sid, auth_token = *credentials_for(opts)
+      payload = {
+        :exp   => (opts.delete('expires') || 1.hour.from_now).to_i,
+        :scope => opts.map { |k,v| send k, v, opts }.join(' '),
+        :iss   => account_sid
+      }
+      JWT.encode payload, auth_token
+    end
+
+    private
+
+    def credentials_for(opts)
+      if opts['account_sid'] && opts['auth_token']
+        [opts.delete('account_sid'), opts.delete('auth_token')]
+      else
+        [Twilio::ACCOUNT_SID, Twilio::AUTH_TOKEN]
+      end
+    end
+
+    def allow_incoming(client_id, opts)
+      token_for 'client', 'incoming', { 'clientName' => client_id }
+    end
+
+    def allow_outgoing(payload, opts)
+      p = {}
+      if payload.respond_to? :each
+        p['appSid']    = payload.shift
+        p['appParams'] = uri_encode payload.pop
+      else # it's a string
+        p['appSid'] = payload
+      end
+      p['clientName'] = opts['allow_incoming'] if opts['allow_incoming']
+      token_for 'client', 'outgoing', p
+    end
+
+    def uri_encode(hash)
+      hash.map { |k,v| "#{CGI.escape k.to_s}=#{CGI.escape v}" }.join '&'
+    end
+
+    def token_for(service, privilege, params = {})
+      token = "scope:#{service}:#{privilege}"
+      token << "?#{uri_encode params}" if params.any?
+    end
+
+    extend self
+  end
+end

data/lib/twilio/config.rb

@@ -1,7 +1,16 @@
 module Twilio
   module Config
-    def setup &blk
-      instance_eval &blk
+    def setup(opts={}, &blk)
+      if block_given?
+        instance_eval &blk
+        warn 'The block syntax for configuration is deprecated. Use an options hash instead, e.g. Twilio::Config.setup account_sid: "AC00000000000000000000000", auth_token: "xxxxxxxxxxxxxxxxxxx"'
+      else
+        opts.map do |k,v|
+          const = k.to_s.upcase
+          Twilio.const_set(const, v) unless Twilio.const_defined? const
+        end
+      end
+
     end
 
     def method_missing(meth, *args, &blk)
@@ -11,4 +20,4 @@ module Twilio
 
     extend self
   end
-end
+end

data/lib/twilio/finder.rb

@@ -1,7 +1,10 @@
 module Twilio
   module Finder
-    def find(id)
-      res  = get "/Accounts/#{Twilio::ACCOUNT_SID}/#{resource_fragment}/#{id}.json"
+    def find(id, opts={})
+      opts        = opts.with_indifferent_access
+      # Support subaccounts by optionally passing in an account_sid or account object
+      account_sid = opts.delete('account_sid') || opts.delete('account').try(:sid) || Twilio::ACCOUNT_SID
+      res  = get "#{resource_path(account_sid)}/#{id}.json"
       hash = res.parsed_response
       if (200..299).include? res.code
         hash['api_version'] = hash['api_version'].to_s # api_version parsed as a date by http_party
@@ -10,27 +13,34 @@ module Twilio
     end
 
     def count(opts={})
-      params = prepare_params opts if opts.any?
-      get("/Accounts/#{Twilio::ACCOUNT_SID}/#{resource_fragment}.json#{params}").parsed_response['total']
+      opts        = opts.with_indifferent_access
+      # Support subaccounts by optionally passing in an account_sid or account object
+      account_sid = opts.delete('account_sid') || opts.delete('account').try(:sid) || Twilio::ACCOUNT_SID
+      params      = prepare_params opts if opts.any?
+      get("#{resource_path(account_sid)}.json#{params}").parsed_response['total']
     end
 
     def all(opts={})
-      params = prepare_params opts if opts.any?
-      handle_response get "/Accounts/#{Twilio::ACCOUNT_SID}/#{resource_fragment}.json#{params}"
+      opts        = opts.with_indifferent_access
+      # Support subaccounts by optionally passing in an account_sid or account object
+      account_sid = opts.delete('account_sid') || opts.delete('account').try(:sid) || Twilio::ACCOUNT_SID
+      params      = prepare_params opts if opts.any?
+      handle_response get "#{resource_path(account_sid)}.json#{params}"
     end
 
     private
 
-    def resource_fragment # :nodoc:
-      # All Twilio resources follow a convention, except SMS :(
-      klass_name = name.demodulize
-      resource   = klass_name == 'SMS' ? "#{klass_name}/Messages" : klass_name.pluralize
+    def resource_path(account_sid)
+      "/Accounts/#{account_sid}/#{resource_name}"
+    end
+
+    def resource_name
+      name.demodulize.pluralize
     end
 
     def prepare_params(opts) # :nodoc:
       pairs = opts.map do |k,v|
-        if [:updated_before, :created_before, :updated_after, :created_after].include? k
-          k = k.to_s
+        if %w(updated_before created_before updated_after created_after).include? k
           # Fancy schmancy-ness to handle Twilio <= URI operator for dates
           comparator = k =~ /before$/ ? '<=' : '>='
           CGI.escape("Date" << k.gsub(/\_\w+$/, '').capitalize << comparator << v.to_s)

data/lib/twilio/incoming_phone_number.rb

@@ -5,10 +5,9 @@ module Twilio
     include Twilio::Persistable
     include Twilio::Deletable
 
-    %w<friendly_name api_version voice_url voice_method voice_fallback_url voice_fallback_method status_callback status_callback_method sms_url sms_method sms_fallback_url sms_fallback_method voice_caller_id_lookup>.each do |meth|
-      define_method "#{meth}=" do |arg|
-        update_attributes meth => arg 
-      end
-    end
+    mutable_attributes :friendly_name, :api_version, :voice_url, :voice_method,
+      :voice_fallback_url, :voice_fallback_method, :status_callback, :status_callback_method,
+      :sms_url, :sms_method, :sms_method, :sms_fallback_url, :sms_fallback_method, :voice_caller_id_lookup
+
   end
 end

data/lib/twilio/notification.rb

@@ -8,8 +8,7 @@ module Twilio
       private
       def prepare_params(opts) # :nodoc:
         pairs = opts.map do |k,v|
-          if [:created_before, :created_after].include? k
-            k = k.to_s
+          if %w(created_before created_after).include? k
             # Fancy schmancy-ness to handle Twilio <= URI operator for dates
             comparator = k =~ /before$/ ? '<=' : '>='
             CGI.escape("MessageDate" << comparator << v.to_s)

data/lib/twilio/outgoing_caller_id.rb

@@ -5,8 +5,6 @@ module Twilio
     include Twilio::Persistable
     extend Twilio::Finder
 
-    def friendly_name=(value)
-      update_attributes :friendly_name => value
-    end
+    mutable_attributes :friendly_name
   end
 end

data/lib/twilio/participant.rb

@@ -3,6 +3,8 @@ module Twilio
     include Twilio::Resource
     include Twilio::Deletable
 
+    mutable_attributes :muted
+
     alias kick! destroy
 
     def mute!

data/lib/twilio/persistable.rb

@@ -2,23 +2,31 @@ module Twilio
   module Persistable
 
     def self.included(base)
-      base.class_eval do
-        class << base
-          def create(attrs={})
-            # All Twilio resources follow a convention, except SMS :(
-            resource = name.demodulize
-            resource = name == 'Twilio::SMS' ? "SMS/Messages" : resource + 's'
-            res = post "/Accounts/#{Twilio::ACCOUNT_SID}/#{resource}.json", :body => Hash[attrs.map { |k,v| [k.to_s.camelize, v]}]
-            if (400..599).include? res.code
-              raise Twilio::APIError.new "Error ##{res.parsed_response['code']}: #{res.parsed_response['message']}"
-            else
-              res.parsed_response['api_version'] = res.parsed_response['api_version'].to_s
-              new res.parsed_response
-            end
+      base.instance_eval do
+        def create(attrs={})
+          attrs       = attrs.with_indifferent_access
+          # Support subaccounts by optionally passing in an account_sid or account object
+          account_sid = attrs.delete('account_sid') || attrs.delete('account').try(:sid) || Twilio::ACCOUNT_SID
+
+          res = post "#{resource_path(account_sid)}.json", :body => Hash[attrs.map { |k,v| [k.to_s.camelize, v]}]
+
+          if (400..599).include? res.code
+            raise Twilio::APIError.new "Error ##{res.parsed_response['code']}: #{res.parsed_response['message']}"
+          else
+            res.parsed_response['api_version'] = res.parsed_response['api_version'].to_s
+            new res.parsed_response
           end
         end
+
+        private
+        def resource_path(account_sid)
+          "/Accounts/#{account_sid}/#{resource_name}"
+        end
+
+        def resource_name
+          name.demodulize.pluralize
+        end
       end
     end
-
   end
 end

data/lib/twilio/request_filter.rb

@@ -0,0 +1,25 @@
+require 'base64'
+require 'openssl'
+require 'digest/sha1'
+
+module Twilio
+  module RequestFilter
+    def filter(controller)
+      request = controller.request
+      if request.format.voice? && request.ssl?
+        controller.head(:forbidden) if expected_signature_for(request) != request.env['X-Twilio-Signature']
+      end
+    end
+
+    private
+    def expected_signature_for(request)
+      string_to_sign = request.url + request.params.sort.join
+      digest         = OpenSSL::Digest::Digest.new 'sha1'
+      hash           = OpenSSL::HMAC.digest digest, Twilio::AUTH_TOKEN, string_to_sign
+
+      Base64.encode64(hash).strip
+    end
+
+    extend self
+  end
+end

data/lib/twilio/resource.rb

@@ -7,6 +7,10 @@ module Twilio
       @attributes = attrs.with_indifferent_access
     end
 
+    def inspect
+      "#<#{self.class} #{@attributes.map { |k,v| "#{k}: #{v.inspect}" }.join ', '}>"
+    end
+
     def [](key)
       attributes[key]
     end
@@ -22,6 +26,10 @@ module Twilio
     end
 
     private
+    def resource_name
+      klass.name.demodulize.pluralize
+    end
+
     def klass
       self.class == Module ? self : self.class
     end
@@ -34,8 +42,8 @@ module Twilio
       end
     end
 
-    def path # :nodoc:
-      "/Accounts/#{Twilio::ACCOUNT_SID}/#{klass.name.demodulize.pluralize}/#{self[:sid]}.json"
+    def path
+      uri[11,uri.length]
     end
 
     def handle_response(res) # :nodoc:
@@ -55,7 +63,7 @@ module Twilio
       elsif meth =~ /^#{meth}\?$/i
         add_predicate meth
         send meth
-      elsif attributes.keys.include? meth 
+      elsif attributes.keys.include? meth
         add_attr_reader meth
         send meth
       else
@@ -95,12 +103,20 @@ module Twilio
 
       class << base
         # decorate http methods with authentication
-        %w<post get put delete>.each do |meth| 
-          define_method(meth) do |*args| # splatted args necessary hack since <= 1.8.7 does not support optional block args 
+        %w<post get put delete>.each do |meth|
+          define_method(meth) do |*args| # splatted args necessary hack since <= 1.8.7 does not support optional block args
             opts = args[1] || {}
             super args.first, opts.merge(:basic_auth => { :username => Twilio::ACCOUNT_SID, :password => Twilio::AUTH_TOKEN })
           end
         end
+
+        def mutable_attributes(*attrs)
+          attrs.each do |attr|
+            define_method "#{attr}=" do |arg|
+              update_attributes attr => arg
+            end
+          end
+        end
       end
     end
   end

data/lib/twilio/short_code.rb

@@ -0,0 +1,23 @@
+module Twilio
+  class ShortCode
+    include Twilio::Resource
+    extend Twilio::Finder
+
+    class << self
+      private
+
+      def resource_name
+        "SMS/ShortCodes"
+      end
+    end
+
+    mutable_attributes :friendly_name, :api_version, :sms_url, :sms_method,
+      :sms_fallback_url, :sms_fallback_method
+
+    private
+    def resource_name
+      "SMS/ShortCodes"
+    end
+
+  end
+end

data/lib/twilio/sms.rb

@@ -6,10 +6,13 @@ module Twilio
 
     class << self
       private
+      def resource_name
+        "SMS/Messages"
+      end
+
       def prepare_params(opts) # :nodoc:
         pairs = opts.map do |k,v|
-          if [:created_before, :created_after, :sent_before, :sent_after].include? k
-            k = k.to_s
+          if %w(created_before created_after sent_before sent_after).include? k
             # Fancy schmancy-ness to handle Twilio <= URI operator for dates
             comparator = k =~ /before$/ ? '<=' : '>='
             URI.encode("DateSent" << comparator << v.to_s)

data/lib/twilio-rb.rb

@@ -0,0 +1,23 @@
+%w<rubygems active_support active_support/inflector cgi jwt yajl yajl/json_gem httparty builder>.each  { |lib| require lib }
+%w<resource finder persistable deletable associations association_proxy>.each { |lib| require File.join(File.dirname(__FILE__), 'twilio', "#{lib}.rb") }
+
+module Twilio
+  API_ENDPOINT        = 'https://api.twilio.com/2010-04-01'
+  APIError            = Class.new StandardError
+  ConfigurationError  = Class.new StandardError
+  InvalidStateError   = Class.new StandardError
+
+  class << self
+    def const_missing(const_name)
+      if [:ACCOUNT_SID, :AUTH_TOKEN].include? const_name
+        raise Twilio::ConfigurationError.new "Cannot complete request. Please set #{const_name.to_s.downcase} with Twilio::Config.setup first!"
+      else
+        super
+      end
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'twilio', '*.rb')].each { |lib| require lib }
+
+require File.join(File.dirname(__FILE__), 'railtie.rb') if Object.const_defined?(:Rails) && Rails.version =~ /^3/

data/lib/twilio.rb

@@ -1,23 +1,3 @@
-%w<rubygems active_support active_support/inflector cgi yajl yajl/json_gem httparty builder>.each  { |lib| require lib }
-%w<resource finder persistable deletable>.each { |lib| require File.join(File.dirname(__FILE__), 'twilio', "#{lib}.rb") }
+require File.dirname(__FILE__) +'/twilio-rb.rb'
+warn    'require "twilio" is deprecated and will be removed in a future release. Use require "twilio-rb" instead.'
 
-module Twilio
-  API_ENDPOINT        = 'https://api.twilio.com/2010-04-01'
-  APIError            = Class.new StandardError
-  ConfigurationError  = Class.new StandardError
-  InvalidStateError   = Class.new StandardError
-
-  class << self
-    def const_missing(const_name)
-      if [:ACCOUNT_SID, :AUTH_TOKEN].include? const_name
-        raise Twilio::ConfigurationError.new "Cannot complete request. Please set #{const_name.to_s.downcase} with Twilio::Config.setup first!"
-      else
-        super
-      end
-    end
-  end
-end
-
-Dir[File.join(File.dirname(__FILE__), 'twilio', '*.rb')].each { |lib| require lib }
-
-require File.join(File.dirname(__FILE__), 'railtie.rb') if Object.const_defined?(:Rails) && Rails.version =~ /^3/

metadata

@@ -1,120 +1,152 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: twilio-rb
-version: !ruby/object:Gem::Version 
-  prerelease: 3
-  version: 1.0beta2
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Stevie Graham
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-08 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-09-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activesupport
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70298512157240 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: i18n
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512157240
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70298512130420 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: 0.5.0
+      - !ruby/object:Gem::Version
+        version: '0.5'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yajl-ruby
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512130420
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70298512129800 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.7.7
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: httparty
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512129800
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &70298512129220 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.6.1
   type: :runtime
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *70298512129220
+- !ruby/object:Gem::Dependency
   name: builder
+  requirement: &70298512128620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512128620
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: &70298512127920 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.1.2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
   type: :runtime
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: webmock
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512127920
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70298512127380 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.6.1
   type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512127380
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70298512126660 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.2.0
   type: :development
-  version_requirements: *id007
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  version_requirements: *70298512126660
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70298512126060 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.9.10
   type: :development
-  version_requirements: *id008
+  prerelease: false
+  version_requirements: *70298512126060
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70298512125460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :development
+  prerelease: false
+  version_requirements: *70298512125460
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70298512124880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *70298512124880
 description: A nice Ruby wrapper for the Twilio REST API
 email: sjtgraham@mac.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README.md
 - lib/railtie.rb
 - lib/twilio/account.rb
+- lib/twilio/application.rb
+- lib/twilio/association_proxy.rb
+- lib/twilio/associations.rb
 - lib/twilio/available_phone_number.rb
 - lib/twilio/call.rb
+- lib/twilio/capability.rb
 - lib/twilio/conference.rb
 - lib/twilio/config.rb
 - lib/twilio/deletable.rb
@@ -125,39 +157,37 @@ files:
 - lib/twilio/participant.rb
 - lib/twilio/persistable.rb
 - lib/twilio/recording.rb
+- lib/twilio/request_filter.rb
 - lib/twilio/resource.rb
 - lib/twilio/sandbox.rb
+- lib/twilio/short_code.rb
 - lib/twilio/sms.rb
 - lib/twilio/transcription.rb
 - lib/twilio/twiml.rb
+- lib/twilio-rb.rb
 - lib/twilio.rb
-has_rdoc: true
 homepage: http://github.com/stevegraham/twilio-rb
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 1.3.1
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Interact with the Twilio API in a nice Ruby way.
 test_files: []
-