twilio-ruby 3.11.5 → 4.0.0

data/lib/twilio-ruby/rest/task_router/statistics.rb

@@ -0,0 +1,26 @@
+module Twilio
+  module REST
+    module TaskRouter
+      module Statistics
+        def statistics(args={})
+          path = "#{@path}/Statistics"
+          response = @client.get(path, args, true)
+          statistics_class.new(path, @client, response)
+        end
+
+        private
+
+        ##
+        # Gets the class for the statistics of the current class.
+        # Should just be Object.const_get("#{self.class.to_s}Statistics") but
+        # Ruby 1.9.3 did not agree. Can be updated if support is dropped.
+        def statistics_class
+          current_class = self.class.to_s.split('::').last
+          statistics_class = Twilio::REST::TaskRouter.const_get(
+            "#{current_class}Statistics"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/task_queues.rb

@@ -0,0 +1,17 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class TaskQueues < Twilio::REST::NextGenListResource
+        def statistics(args={})
+          path = "#{@path}/Statistics"
+          stats = Twilio::REST::TaskRouter::TaskQueuesStatistics.new path, @client
+          stats.list args, true
+        end
+      end
+
+      class TaskQueue < InstanceResource
+        include Statistics
+      end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/task_queues_statistics.rb

@@ -0,0 +1,15 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class TaskQueuesStatistics < Twilio::REST::NextGenListResource
+        def initialize(path, client)
+          @path, @client = path, client
+          @instance_class = Twilio::REST::TaskRouter::TaskQueueStatistics
+          @list_key, @instance_id_key = 'task_queues_statistics', 'task_queue_sid'
+        end
+      end
+
+      class TaskQueueStatistics < InstanceResource; end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/tasks.rb

@@ -0,0 +1,15 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class Tasks < Twilio::REST::NextGenListResource; end
+
+      class Task < InstanceResource
+        def initialize(path, client, params={})
+          super path, client, params
+          @submodule = :TaskRouter
+          resource :reservations
+        end
+      end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/workers.rb

@@ -0,0 +1,13 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class Workers < Twilio::REST::NextGenListResource
+        include Twilio::REST::TaskRouter::Statistics
+      end
+
+      class Worker < InstanceResource
+        include Twilio::REST::TaskRouter::Statistics
+      end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/workers_statistics.rb

@@ -0,0 +1,8 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class WorkersStatistics < Twilio::REST::InstanceResource; end
+      class WorkerStatistics < InstanceResource; end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/workflow_statistics.rb

@@ -0,0 +1,7 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class WorkflowStatistics < InstanceResource; end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/workflows.rb

@@ -0,0 +1,11 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class Workflows < Twilio::REST::NextGenListResource; end
+
+      class Workflow < InstanceResource
+        include Twilio::REST::TaskRouter::Statistics
+      end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/workspace_statistics.rb

@@ -0,0 +1,7 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class WorkspaceStatistics < InstanceResource; end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router/workspaces.rb

@@ -0,0 +1,17 @@
+module Twilio
+  module REST
+    module TaskRouter
+      class Workspaces < Twilio::REST::NextGenListResource; end
+
+      class Workspace < InstanceResource
+        include Twilio::REST::TaskRouter::Statistics
+
+        def initialize(path, client, params={})
+          super path, client, params
+          @submodule = :TaskRouter
+          resource :activities, :events, :task_queues, :tasks, :workers, :workflows
+        end
+      end
+    end
+  end
+end

data/lib/twilio-ruby/rest/task_router_client.rb

@@ -0,0 +1,176 @@
+require 'twilio-ruby/rest/base_client'
+module Twilio
+  module REST
+    class TaskRouterClient < BaseClient
+      API_VERSION = 'v1'
+
+      attr_reader :workspace, :workspace_sid, :workspaces
+
+      host 'taskrouter.twilio.com'
+
+      ##
+      # Instantiate a new HTTP TaskRouter client to talk to Twilio. The parameters
+      # +account_sid+, +auth_token+ and +workspace_sid are required, unless you
+      # have configured them already using the block configure syntax, and used
+      # to generate the HTTP basic auth header in each request. The +options+
+      # parameter is a hash of connection configuration options. the following
+      # keys are supported:
+      #
+      # === <tt>host: 'taskrouter.twilio.com'</tt>
+      #
+      # The domain to which you'd like the client to make HTTP requests. Useful
+      # for testing. Defaults to 'api.twilio.com'.
+      #
+      # === <tt>port: 443</tt>
+      #
+      # The port on which to connect to the above domain. Defaults to 443 and
+      # should be left that way except in testing environments.
+      #
+      # === <tt>use_ssl: true</tt>
+      #
+      # Declare whether ssl should be used for connections to the above domain.
+      # Defaults to true and should be left alone except when testing.
+      #
+      # === <tt>ssl_verify_peer: true</tt>
+      #
+      # Declare whether to verify the host's ssl cert when setting up the
+      # connection to the above domain. Defaults to true, but can be turned off
+      # to avoid ssl certificate verification failures in environments without
+      # the necessary ca certificates.
+      #
+      # === <tt>ssl_ca_file: '/path/to/ca/file'</tt>
+      #
+      # Specify the path to the certificate authority bundle you'd like to use
+      # to verify Twilio's SSL certificate on each request. If not specified, a
+      # certificate bundle extraced from Firefox is packaged with the gem and
+      # used by default.
+      #
+      # === <tt>timeout: 30</tt>
+      #
+      # Set the time in seconds to wait before timing out the HTTP request.
+      # Defaults to 30 seconds. If you aren't fetching giant pages of call or
+      # SMS logs you can safely decrease this to something like 3 seconds or
+      # lower. In paricular if you are sending SMS you can set this to 1 second
+      # or less and swallow the exception if you don't care about the response.
+      #
+      # === <tt>proxy_addr: 'proxy.host.domain'</tt>
+      #
+      # The domain of a proxy through which you'd like the client to make HTTP
+      # requests. Defaults to nil.
+      #
+      # === <tt>proxy_port: 3128</tt>
+      #
+      # The port on which to connect to the above proxy. Defaults to nil.
+      #
+      # === <tt>proxy_user: 'username'</tt>
+      #
+      # The user name to use for authentication with the proxy. Defaults to nil.
+      #
+      # === <tt>proxy_pass: 'password'</tt>
+      #
+      # The password to use for authentication with the proxy. Defaults to nil.
+      #
+      # === <tt>retry_limit: 1</tt>
+      #
+      # The number of times to retry a request that has failed before throwing
+      # an exception. Defaults to one.
+      def initialize(*args)
+        @workspace_sid = args[2]
+        if @workspace_sid.nil?
+          raise ArgumentError, 'Workspace SID is required'
+        end
+        super(*args)
+      end
+
+      def inspect # :nodoc:
+        "<Twilio::REST::TaskRouterClient @account_sid=#{@account_sid}>"
+      end
+
+      ##
+      # Delegate workspace methods from the client. This saves having to call
+      # <tt>client.workspace</tt> every time for resources on the default
+      # workspace.
+      def method_missing(method_name, *args, &block)
+        if workspace.respond_to?(method_name)
+          workspace.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, include_private=false)
+        if workspace.respond_to?(method_name, include_private)
+          true
+        else
+          super
+        end
+      end
+
+      ##
+      # Get statistics of a task queue.
+      def task_queue_statistics(task_queue_sid, *args) # :doc:
+        warn "[DEPRECATED] task_queue_statistics is deprecated. " \
+             "Please call client.task_queue.get(sid).statistics."
+        task_queues.get(task_queue_sid).statistics
+      end
+
+      ##
+      # Get statistics of task queues.
+      def task_queues_statistics(*args) # :doc:
+        warn "[DEPRECATED] task_queues_statistics is deprecated. " \
+             "Please call client.task_queues.statistics."
+        task_queues.statistics
+      end
+
+      ##
+      # Get statistics of a worker.
+      def worker_statistics(worker_sid, *args) # :doc:
+        warn "[DEPRECATED] worker_statistics is deprecated. " \
+             "Please call client.worker.get(sid).statistics."
+        workers.get(worker_sid).statistics
+      end
+
+      ##
+      # Get statistics of workers.
+      def workers_statistics(*args) # :doc:
+        warn "[DEPRECATED] workers_statistics is deprecated. " \
+             "Please call client.workers.statistics."
+        workers.statistics
+      end
+
+      ##
+      # Get statistics of a workflow.
+      def workflow_statistics(workflow_sid, *args) # :doc:
+        warn "[DEPRECATED] workflow_statistics is deprecated. " \
+             "Please call client.workflow.get(sid).statistics."
+        workflows.get(workflow_sid).statistics
+      end
+
+      ##
+      # Get statistics of a workspace.
+      def workspace_statistics(*args) # :doc:
+        warn "[DEPRECATED] worker_statistics is deprecated. " \
+             "Please call client.workspace.statistics."
+        workspace.statistics
+      end
+
+      protected
+
+      ##
+      # Set up +workspace+ and +workspaces+ attributes.
+      def set_up_subresources # :doc:
+        @workspaces = Twilio::REST::TaskRouter::Workspaces.new "/#{API_VERSION}/Workspaces", self
+        @workspace = @workspaces.get @workspace_sid
+      end
+
+      ##
+      # Builds up full request path
+      def build_full_path(path, params, method)
+        path = path.dup
+        path << "?#{url_encode(params)}" if method == :get && !params.empty?
+        path
+      end
+
+    end
+  end
+end

data/lib/twilio-ruby/rest/tokens.rb

@@ -0,0 +1,7 @@
+module Twilio
+  module REST
+    class Tokens < ListResource; end
+
+    class Token < InstanceResource; end
+  end
+end

data/lib/twilio-ruby/rest/usage/records.rb

@@ -2,8 +2,8 @@ module Twilio
   module REST
     class Records < ListResource
 
-      SUBRESOURCES = [:daily, :monthly, :yearly, :all_time, :today, :yesterday,
-        :this_month, :last_month]
+      SUBRESOURCES = [:daily, :monthly, :yearly, :all_time, :today,
+                      :yesterday, :this_month, :last_month]
 
       def initialize(path, client)
         super

data/lib/twilio-ruby/rest/utils.rb

@@ -3,23 +3,47 @@ module Twilio
     module Utils
 
       def twilify(something)
-        if something.is_a? Hash
-          Hash[*something.to_a.map! {|a| [twilify(a[0]).to_sym, a[1]]}.flatten(1)]
-        else
-          something.to_s.split('_').map! do |s|
-            [s[0,1].capitalize, s[1..-1]].join
-          end.join
-        end
+        return key_map(something, :twilify) if something.is_a? Hash
+        string = something.to_s
+        string.split('_').map do |string_part|
+          string_part[0,1].capitalize + string_part[1..-1]
+        end.join
       end
 
       def detwilify(something)
-        if something.is_a? Hash
-          Hash[*something.to_a.map! {|pair| [detwilify(pair[0]).to_sym, pair[1]]}.flatten]
-        else
-          something.to_s.gsub(/[A-Z][a-z]*/) {|s| "_#{s.downcase}"}.gsub(/^_/, '')
+        return key_map(something, :detwilify) if something.is_a? Hash
+        string = something.to_s
+        string = string[0,1].downcase + string[1..-1]
+        string.gsub(/[A-Z][a-z]*/) { |s| "_#{s.downcase}" }
+      end
+
+      protected
+
+      def resource(*resources)
+        custom_resource_names = { sms: 'SMS', sip: 'SIP' }
+        resources.each do |r|
+          resource = twilify r
+          relative_path = custom_resource_names.fetch(r, resource)
+          path = "#{@path}/#{relative_path}"
+          enclosing_module = if @submodule == nil
+            Twilio::REST
+          else
+            Twilio::REST.const_get(@submodule)
+          end
+          resource_class = enclosing_module.const_get resource
+          instance_variable_set("@#{r}", resource_class.new(path, @client))
         end
+        self.class.instance_eval { attr_reader *resources }
       end
 
+      private
+
+      def key_map(something, method)
+        something = something.to_a.flat_map do |pair|
+          [send(method, pair[0]).to_sym, pair[1]]
+        end
+        Hash[*something]
+      end
     end
   end
 end

data/lib/twilio-ruby/task_router/capability.rb

@@ -0,0 +1,87 @@
+module Twilio
+  module TaskRouter
+    class Capability
+
+      TASK_ROUTER_BASE_URL = 'https://taskrouter.twilio.com'
+      TASK_ROUTER_VERSION = 'v1'
+      TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.twilio.com/v1/wschannels'
+
+      REQUIRED = {required: true}
+      OPTIONAL = {required: false}
+
+      def initialize(account_sid, auth_token, workspace_sid, worker_sid)
+        @account_sid = account_sid
+        @auth_token = auth_token
+        @workspace_sid = workspace_sid
+        @worker_sid = worker_sid
+        @policies = []
+        allow_websocket_requests
+        allow_activity_list_fetch
+      end
+
+      def workspace_url
+        "#{TASK_ROUTER_BASE_URL}/#{TASK_ROUTER_VERSION}/Workspaces/#{@workspace_sid}"
+      end
+
+      def worker_url
+        "#{workspace_url}/Workers/#{@worker_sid}"
+      end
+
+      def allow_worker_activity_updates
+        add_policy(worker_url, "POST", nil, {ActivitySid: REQUIRED})
+      end
+
+      def allow_worker_fetch_attributes
+        add_policy(worker_url, "GET")
+      end
+
+      def allow_task_reservation_updates
+        task_url = "#{workspace_url}/Tasks/**"
+        add_policy(task_url, "POST", nil, {ReservationStatus: REQUIRED})
+      end
+
+      def add_policy(url, method, query_filters = nil, post_filters = nil, allowed = true)
+        policy = {
+          url: url,
+          method: method,
+          query_filter: query_filters || {},
+          post_filter: post_filters || {},
+          allow: allowed
+        }
+
+        @policies.push(policy)
+      end
+
+      def generate_token(ttl = 3600)
+        payload = {
+          iss: @account_sid,
+          exp: (Time.now.to_i + ttl),
+          version: @version,
+          friendly_name: @worker_sid,
+          policies: @policies,
+          account_sid: @account_sid,
+          worker_sid: @worker_sid,
+          channel: @worker_sid,
+          workspace_sid: @workspace_sid
+        }
+
+        JWT.encode payload, @auth_token
+      end
+
+      protected
+
+      def allow_websocket_requests
+        worker_url = "#{TASK_ROUTER_WEBSOCKET_BASE_URL}/#{@account_sid}/#{@worker_sid}"
+        ['GET', 'POST'].each do |meth|
+          add_policy(worker_url, meth)
+        end
+      end
+
+      def allow_activity_list_fetch
+        url = "#{workspace_url}/Activities"
+        add_policy(url, 'GET')
+      end
+
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ module Twilio
     class Response
 
       attr_reader :text
+      alias_method :to_xml , :text
 
       def initialize(&block)
         xml = Builder::XmlMarkup.new

data/lib/twilio-ruby/util/capability.rb

@@ -4,28 +4,31 @@ module Twilio
 
       include Twilio::Util
 
-      def initialize(account_sid, auth_token)
-        @account_sid = account_sid
-        @auth_token = auth_token
+      def initialize(account_sid = nil, auth_token = nil)
+        @account_sid = account_sid || Twilio.account_sid
+        @auth_token = auth_token || Twilio.auth_token
+        if @account_sid.nil? || @auth_token.nil?
+          raise ArgumentError, 'Account SID and auth token are required'
+        end
         @capabilities = []
       end
 
       def allow_client_incoming(client_name)
         @client_name = client_name # stash for use in outgoing
-        scope_params = {'clientName' => client_name}
+        scope_params = { 'clientName' => client_name }
         @capabilities << scope_uri_for('client', 'incoming', scope_params)
       end
 
       def allow_client_outgoing(app_sid, params = {})
         @allow_client_outgoing = true
-        @outgoing_scope_params = {'appSid' => app_sid}
+        @outgoing_scope_params = { 'appSid' => app_sid }
         unless params.empty?
           @outgoing_scope_params['appParams'] = url_encode params
         end
       end
 
       def allow_event_stream(filters = {})
-        scope_params = {'path' => '/2010-04-01/Events'}
+        scope_params = { 'path' => '/2010-04-01/Events' }
         scope_params['params'] = filters unless filters.empty?
         @capabilities << scope_uri_for('stream', 'subscribe', scope_params)
       end
@@ -42,7 +45,7 @@ module Twilio
         # build the outgoing scope lazily so that we can use @client_name
         if @allow_client_outgoing
           params = @outgoing_scope_params
-          params.merge!({'clientName' => @client_name}) if @client_name
+          params.merge!('clientName' => @client_name) if @client_name
           capabilities << scope_uri_for('client', 'outgoing', params)
         end
 

data/lib/twilio-ruby/util/client_config.rb

@@ -0,0 +1,29 @@
+module Twilio
+  module Util
+    class ClientConfig
+      DEFAULTS = {
+          host: 'api.twilio.com',
+          port: 443,
+          use_ssl: true,
+          ssl_verify_peer: true,
+          ssl_ca_file: File.dirname(__FILE__) + '/../../../conf/cacert.pem',
+          timeout: 30,
+          proxy_addr: nil,
+          proxy_port: nil,
+          proxy_user: nil,
+          proxy_pass: nil,
+          retry_limit: 1
+      }
+
+      DEFAULTS.each_key do |attribute|
+        attr_accessor attribute
+      end
+
+      def initialize(opts={})
+        DEFAULTS.each do |attribute, value|
+          send("#{attribute}=".to_sym, opts.fetch(attribute, value))
+        end
+      end
+    end
+  end
+end

data/lib/twilio-ruby/util/configuration.rb

@@ -0,0 +1,7 @@
+module Twilio
+  module Util
+    class Configuration
+      attr_accessor :account_sid, :auth_token
+    end
+  end
+end

data/lib/twilio-ruby/util/request_validator.rb

@@ -2,13 +2,14 @@ module Twilio
   module Util
     class RequestValidator
 
-      def initialize(auth_token)
-        @auth_token = auth_token
+      def initialize(auth_token = nil)
+        @auth_token = auth_token || Twilio.auth_token
+        raise ArgumentError, 'Auth token is required' if @auth_token.nil?
       end
 
       def validate(url, params, signature)
         expected = build_signature_for url, params
-        expected == signature
+        secure_compare(expected, signature)
       end
 
       def build_signature_for(url, params)
@@ -17,6 +18,20 @@ module Twilio
         Base64.encode64(OpenSSL::HMAC.digest(digest, @auth_token, data)).strip
       end
 
+      private
+
+      # Compares two strings in constant time to avoid timing attacks.
+      # Borrowed from ActiveSupport::MessageVerifier.
+      # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/message_verifier.rb
+      def secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack("C#{a.bytesize}")
+
+        res = 0
+        b.each_byte { |byte| res |= byte ^ l.shift }
+        res == 0
+      end
     end
   end
 end

data/lib/twilio-ruby/version.rb

@@ -1,3 +1,3 @@
 module Twilio
-  VERSION = '3.11.5'
+  VERSION = '4.0.0'
 end