twilio-ruby 4.13.0 → 5.6.4

data/examples/examples.rb

@@ -1,83 +1,72 @@
-# examples version 3
+# examples version
 
-@account_sid = 'AC043dcf9844e04758bc3a36a84c29761'
-@auth_token = '62ea81de3a5b414154eb263595357c69'
+@account_sid = 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+@auth_token = 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'
 # set up a client
 @client = Twilio::REST::Client.new(@account_sid, @auth_token)
 
 ################ ACCOUNTS ################
 
 # shortcut to grab your account object (account_sid is inferred from the client's auth credentials)
-@account = @client.account
+@account = @client.api.account
 
 # list your (sub)accounts
-@client.accounts.list
+@accounts = @client.api.accounts.each do |account|
+  puts(account)
+end
 
 # grab an account instance resource if you know the sid
-@account = @client.accounts.get(@account_sid)
-# http round trip happens here
-puts @account.friendly_name
+@account = @client.api.accounts(account_sid).fetch
+puts(@account.friendly_name)
 
 # update an account's friendly name
-@client.accounts.get(@account_sid).update(friendly_name: 'A Fabulous Friendly Name')
+@client.api.accounts(account_sid).update(friendly_name: 'A Fabulous Friendly Name')
 
 ################ CALLS ################
 
 # print a list of calls (all parameters optional)
-@account.calls.list(
-  page: 0,
-  page_size: 1000,
-  start_time: '2010-09-01'
-).each do |call|
+@client.calls.list(limit: 10, start_time: '2010-09-01').each do |call|
   puts call.sid
 end
 
 # get a particular call and list its recording urls
-@account.calls.get('CAXXXXXXX').recordings.list.each do |r|
+@client.calls('CAXXXXXXX').recordings.each do |r|
   puts r.wav
 end
 
 # make a new outgoing call. returns a call object just like calls.get
-@call = @account.calls.create(
+@call = @client.calls.create(
   from: '+14159341234',
   to: '+18004567890',
   url: 'http://example.com/call-handler'
 )
 
 # cancel the call if not already in progress
-@account.calls.get(@call.sid).update(status: 'canceled')
-# or equivalently
-@call.update(status: 'canceled')
-# or simply
-@call.cancel
+@client.calls(@call.sid).update(status: 'canceled')
 
 # redirect and then terminate a call
-@call = @account.calls.get('CA386025c9bf5d6052a1d1ea42b4d16662')
+@call = client.calls('CAXXXXXXX')
 @call.update(url: 'http://example.com/call-redirect')
 @call.update(status: 'completed')
-# or, use the aliases...
-@call.redirect_to('http://example.com/call-redirect')
-@call.hangup
 
 ################ SMS MESSAGES ################
 
-# print a list of messages
-@account.messages.list(date_sent: '2010-09-01').each do |message|
-  puts message.body
+@client.messages.list(date_sent: '2010-09-01').each do |message|
+  puts message.date_created
 end
 
 # print a particular sms message
-puts @account.messages.get('SMXXXXXXXX').body
+puts @client.messages('SMXXXXXXXX').fetch.body
 
 # send an sms
-@account.messages.create(
+@client.messages.create(
   from: '+14159341234',
   to: '+16105557069',
   body: 'Hey there!'
 )
 
 # send an mms
-@account.messages.create(
+@client.messages.create(
   from: '+14159341234',
   to: '+16105557069',
   media_urls: 'http://example.com/media.png'
@@ -86,63 +75,63 @@ puts @account.messages.get('SMXXXXXXXX').body
 ################ PHONE NUMBERS ################
 
 # get a list of supported country codes
-@account.available_phone_numbers.list
+@client.available_phone_numbers.list
 
 # print some available numbers
-@numbers = @account.available_phone_numbers.get('US').local.list(
-  contains: 'AWESOME'
-)
+@client.available_phone_numbers('US').local.list.each do |num|
+  puts num
+end
+
+@numbers = @client.available_phone_numbers('US').local.list(area_code: '908')
 @numbers.each { |num| puts num.phone_number }
 
 # buy the first one
-@account.incoming_phone_numbers.create(phone_number: @numbers[0].phone_number)
+@client.incoming_phone_numbers.create(phone_number: @numbers[0].phone_number)
 
 # update an existing phone number's voice url
-number = @account.incoming_phone_numbers.get('PNdba508c5616a7f5e141789f44f022cc3')
-number.update(voice_url: 'http://example.com/voice')
+@client.incoming_phone_numbers('PNxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx').update(voice_url: 'http://example.com/voice')
 
 # decommission an existing phone number
-numbers = @account.incoming_phone_numbers.list(
-  friendly_name: 'A Fabulous Friendly Name'
-)
-numbers[0].delete
+numbers = @client.incoming_phone_numbers.list(friendly_name: 'A Fabulous Friendly Name')
+number = numbers[0].sid
+@client.incoming_phone_numbers(number).delete
+
 ################ CONFERENCES  ################
 
 # get a particular conference's participants object and stash it
-conference = @account.conferences.get('CFbbe46ff1274e283f7e3ac1df0072ab39')
+conference = @client.conferences('CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx').fetch
 @participants = conference.participants
 
 # list participants
-@participants.list.each do |p|
+@participants.each do |p|
   puts p.sid
 end
 
 # update a conference participant
-@participants.get('CA386025c9bf5d6052a1d1ea42b4d16662').update(muted: 'true')
-# or an easier way
-@participants.get('CA386025c9bf5d6052a1d1ea42b4d16662').mute
-
-# and, since we're lazy loading, this would only incur one http request
-@account.conferences.get('CFbbe46ff1274e283f7e3ac1df0072ab39').participants
-  .get('CA386025c9bf5d6052a1d1ea42b4d16662').update(muted: 'true')
+@client
+  .conferences('CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+  .participants('CAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+  .update(muted: 'true')
 
 ################ QUEUES ###################
 
 # create a new queue
-@queue = @account.queues.create(friendly_name: 'MyQueue', max_size: 50)
+@queue = @client.queues.create(friendly_name: 'MyQueue', max_size: 50)
 
 # get a list of queues for this account
-@queues = @account.queues.list
+@queues = @client.queues.list
 
 # get a particular queue and its members
-@queue = @account.queues.get("QQb6765b0458714964970a73dcaf55efd1")
+@queue = @client.queues('QQxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx').fetch
 @members = @queue.members
 
-#list members
+# list members
 @members.list.each do |m|
   puts m.wait_time
 end
 
 # dequeue a particular user and run twiml at a specific url
-@member = @members.get('CA386025c9bf5d6052a1d1ea42b4d16662')
-@member.dequeue('http://myapp.com/deque')
+@client
+  .queues('QQxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+  .members('CAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+  .update(url: 'http://myapp.com/deque', method: 'POST')

data/examples/{print-call-log.rb → print_call_log.rb}

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'twilio-ruby'
 
 # print a list of all phone calls, what phone number each was to/from, and how
@@ -7,18 +6,19 @@ require 'twilio-ruby'
 # put your Twilio credentials here. you can find your AccountSid and AuthToken
 # at the top of your account dashboard page located at:
 #   https://www.twilio.com/user/account
-account_sid = 'AC043dcf9844e04758bc3a36a84c29761'
-auth_token = '62ea81de3a5b414154eb263595357c69'
+account_sid = 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+auth_token = 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'
 
 # set up a client
 client = Twilio::REST::Client.new(account_sid, auth_token)
 
 calls = client.calls.list
 
-begin
+loop do
   calls.each do |call|
     price = call.price || '0.00' # since apparently prices can be nil...
-    puts call.sid + "\t" + call.from + "\t" + call.to + "\t" + price
+    puts call.sid + "\t" + call.from + "\t" + call.to + "\t" + price.to_s
   end
   calls = calls.next_page
-end while not calls.empty?
+  break if calls.nil?
+end

data/githooks/pre-commit

@@ -0,0 +1 @@
+make test

data/lib/rack/twilio_webhook_authentication.rb

@@ -25,23 +25,22 @@ module Rack
     end
 
     def call(env)
-      return @app.call(env) unless env["PATH_INFO"].match(@path_regex)
+      return @app.call(env) unless env['PATH_INFO'].match(@path_regex)
       request = Rack::Request.new(env)
       original_url = request.url
       params = request.post? ? request.POST : {}
       auth_token = @auth_token || get_auth_token(params['AccountSid'])
-      validator = Twilio::Util::RequestValidator.new(auth_token)
-      signature = env['HTTP_X_TWILIO_SIGNATURE'] || ""
+      validator = Twilio::Security::RequestValidator.new(auth_token)
+      signature = env['HTTP_X_TWILIO_SIGNATURE'] || ''
       if validator.validate(original_url, params, signature)
         @app.call(env)
       else
         [
           403,
-          {'Content-Type' => 'text/plain'},
-          ["Twilio Request Validation Failed."]
+          { 'Content-Type' => 'text/plain' },
+          ['Twilio Request Validation Failed.']
         ]
       end
     end
   end
-
 end

data/lib/twilio-ruby/framework/domain.rb

@@ -0,0 +1,34 @@
+module Twilio
+  module REST
+    class Domain
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+        @host = nil
+        @base_url = nil
+        @port = nil
+      end
+
+      def absolute_url(uri)
+        "#{@base_url.chomp('/')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = uri.match(/^http/) ? uri : absolute_url(uri)
+
+        @client.request(
+          @host,
+          @port,
+          method,
+          url,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/error.rb

@@ -0,0 +1,33 @@
+module Twilio
+  module REST
+    class TwilioError < StandardError
+      attr_reader :message, :body
+
+      def initialize(message, body = nil)
+        @message = message
+        @body = body
+      end
+
+      def to_s
+        "#{@message}: #{@body || 'no body'}"
+      end
+    end
+
+    class RestError < TwilioError
+      attr_reader :message, :code, :status_code
+
+      def initialize(message, code, status_code)
+        @message = message
+        @code = code
+        @status_code = status_code
+      end
+
+      def to_s
+        "[HTTP #{status_code}] #{code} : #{message}"
+      end
+    end
+
+    class ObsoleteError < StandardError
+    end
+  end
+end

data/lib/twilio-ruby/framework/helper.rb

@@ -0,0 +1,9 @@
+module Twilio
+  module REST
+    def url_join(left, right)
+      left = left.sub(/\/+$/, '').sub(/^\/+/, '')
+      right = right.sub(/\/+$/, '').sub(/^\/+/, '')
+      "#{left}/#{right}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/obsolete_client.rb

@@ -0,0 +1,10 @@
+module Twilio
+  module REST
+    class ObsoleteClient
+      def initialize(*)
+        raise ObsoleteError, "#{self.class} has been removed from this version of the library. "\
+                             'Please refer to current documentation for guidance.'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/page.rb

@@ -0,0 +1,101 @@
+module Twilio
+  module REST
+    # Page Base Class
+    class Page
+      include Enumerable
+
+      META_KEYS = [
+        'end',
+        'first_page_uri',
+        'next_page_uri',
+        'last_page_uri',
+        'page',
+        'page_size',
+        'previous_page_uri',
+        'total',
+        'num_pages',
+        'start',
+        'uri'
+      ].freeze
+
+      def initialize(version, response)
+        payload = process_response(response)
+
+        @version = version
+        @payload = payload
+        @solution = {}
+        @records = load_page(payload)
+      end
+
+      def process_response(response)
+        if response.status_code != 200
+          raise Twilio::REST::TwilioError.new('Unable to fetch page', response)
+        end
+
+        response.body
+      end
+
+      def load_page(payload)
+        if payload['meta'] && payload['meta']['key']
+          return payload[payload['meta']['key']]
+        else
+          keys = payload.keys
+          key = keys - META_KEYS
+          return payload[key.first] if key.size == 1
+        end
+
+        raise Twilio::REST::TwilioError, 'Page Records can not be deserialized'
+      end
+
+      def previous_page_url
+        if @payload['meta'] && @payload['meta']['previous_page_url']
+          return @version.domain.absolute_url(URI.parse(@payload['meta']['previous_page_url']).request_uri)
+        elsif @payload['previous_page_uri']
+          return @version.domain.absolute_url(@payload['previous_page_uri'])
+        end
+
+        nil
+      end
+
+      def next_page_url
+        if @payload['meta'] && @payload['meta']['next_page_url']
+          return @version.domain.absolute_url(URI.parse(@payload['meta']['next_page_url']).request_uri)
+        elsif @payload['next_page_uri']
+          return @version.domain.absolute_url(@payload['next_page_uri'])
+        end
+
+        nil
+      end
+
+      def get_instance(payload)
+        raise Twilio::REST::TwilioError, 'Page.get_instance() must be implemented in the derived class'
+      end
+
+      def previous_page
+        return nil unless previous_page_url
+
+        response = @version.domain.request('GET', previous_page_url)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def next_page
+        return nil unless next_page_url
+
+        response = @version.domain.request('GET', next_page_url)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def each
+        @records.each do |record|
+          yield get_instance(record)
+        end
+      end
+
+      def to_s
+        '#<Page>'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/request.rb

@@ -0,0 +1,39 @@
+module Twilio
+  class Request
+    attr_reader :host, :port, :method, :url, :params, :data, :headers, :auth, :timeout
+
+    def initialize(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+      @host = host
+      @port = port
+      @url = url
+      @method = method
+      @params = params
+      @data = data
+      @headers = headers
+      @auth = auth
+      @timeout = timeout
+    end
+
+    def to_s
+      auth = @auth.nil? ? '' : '(' + @auth.join(',') + ')'
+
+      params = ''
+      unless @params.nil? || @params.empty?
+        params = '?' + @params.each.map { |key, value| "#{CGI.escape(key)}=#{CGI.escape(value)}" }.join('&')
+      end
+
+      headers = ''
+      unless @headers.nil? || @headers.empty?
+        headers = "\n" + @headers.each.map { |key, value| "-H \"#{key}\": \"#{value}\"" }.join("\n")
+      end
+
+      data = ''
+      unless @data.nil? || @data.empty?
+        data = @method.equal?('GET') ? "\n -G" : "\n"
+        data += @data.each.map { |key, value| "-d \"#{key}\"=\"#{value}\"" }.join("\n")
+      end
+
+      "#{auth} #{@method} #{@url}#{params}#{data}#{headers}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/resource.rb

@@ -0,0 +1,21 @@
+module Twilio
+  module REST
+    class ListResource
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceContext
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceResource
+      def initialize(version)
+        @version = version
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/response.rb

@@ -0,0 +1,16 @@
+module Twilio
+  class Response
+    attr_accessor :status_code, :body, :headers
+
+    def initialize(status_code, body, headers: nil)
+      @status_code = status_code
+      body = '{}' if !body || body.empty?
+      @body = JSON.parse(body)
+      @headers = !headers ? {} : headers.to_hash
+    end
+
+    def to_s
+      "[#{status_code}] #{body}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/serialize.rb

@@ -0,0 +1,79 @@
+module Twilio
+  def self.serialize_iso8601_date(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      date.iso8601
+    elsif date.is_a?(Time)
+      date.strftime('%Y-%m-%d')
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.serialize_iso8601_datetime(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      Time.new(date.year, date.month, date.day).utc.iso8601
+    elsif date.is_a?(Time)
+      date.utc.iso8601
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.deserialize_rfc2822(date)
+    Time.rfc2822(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_date(date)
+    Date.parse(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_datetime(date)
+    Time.parse(date) unless date.nil?
+  end
+
+  def self.serialize_object(object)
+    if object.is_a?(Hash) || object.is_a?(Array)
+      JSON.generate(object)
+    else
+      object
+    end
+  end
+
+  def self.flatten(map, result = {}, previous = [])
+    map.each do |key, value|
+      if value.is_a? Hash
+        self.flatten(value, result, previous + [key])
+      else
+        result[(previous + [key]).join('.')] = value
+      end
+    end
+
+    result
+  end
+
+  def self.prefixed_collapsible_map(map, prefix)
+    result = {}
+    if map.is_a? Hash
+      flattened = self.flatten(map)
+      result = {}
+      flattened.each do |key, value|
+        result[prefix + '.' + key] = value
+      end
+    end
+
+    result
+  end
+
+  def self.serialize_list(input_list)
+    return input_list unless input_list.is_a? Array
+    result = []
+    input_list.each do |e|
+      result.push yield e
+    end
+    result
+  end
+end

data/lib/twilio-ruby/framework/twilio_response.rb

@@ -0,0 +1,17 @@
+module Twilio
+  class TwilioResponse
+    attr_accessor :status_code, :body
+
+    # @deprecated Use 'Twilio::Response' instead.
+    def initialize(status_code, body)
+      warn "'Twilio::TwilioResponse' has been deprecated. Use 'Twilio::Response' instead."
+      response = Twilio::Response.new(status_code, body)
+      @status_code = response.status_code
+      @body = response.body
+    end
+
+    def to_s
+      "[#{@status_code}] #{@body}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/values.rb

@@ -0,0 +1,7 @@
+module Twilio
+  class Values
+    def self.of(hash)
+      hash.delete_if { |_, v| v.eql?(:unset) }
+    end
+  end
+end