twilio-ruby 4.6.1 → 6.9.0

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

@@ -1,129 +0,0 @@
-require 'json'
-
-module Twilio
-  module TaskRouter
-    class WorkflowConfiguration
-
-      def initialize(rules, default_target)
-        @rules = rules
-        @default_target = default_target
-      end
-
-      def rules
-        @rules
-      end
-
-      def default_target
-        @default_target
-      end
-
-      def to_json
-        filters = Array.new
-        @rules.each do |rule|
-          filters.push(rule.to_json)
-        end
-        
-        task_routing = {filters: filters, default_filter: @default_target.to_json}
-        config = {task_routing: task_routing}
-        config.to_json
-      end
-
-      def self.parse_json(json_data)
-        task_routing = JSON.parse(json_data)['task_routing']
-
-        filters = task_routing['filters']
-        rules = Array.new
-        filters.each do |rule|
-          rules.push(Twilio::TaskRouter::WorkflowRule.parse_json(rule))
-        end
-
-        default_filter = Twilio::TaskRouter::WorkflowRuleTarget.parse_json(task_routing['default_filter'])
-        Twilio::TaskRouter::WorkflowConfiguration.new rules, default_filter
-      end
-    end
-    class WorkflowRule
-
-      def initialize(expression, targets, friendly_name=nil)
-        @expression = expression
-        @targets = targets
-        @friendly_name = friendly_name
-      end
-
-      def expression
-        @expression
-      end
-
-      def targets
-        @targets
-      end
-
-      def friendly_name
-        @friendly_name
-      end
-
-      def to_json
-        rule = {expression: @expression}
-        ruleTargets = Array.new
-        @targets.each do |target|
-          ruleTargets.push(target.to_json)
-        end
-        rule['targets'] = ruleTargets
-        unless @friendly_name.nil?
-          rule['friendly_name'] = @friendly_name
-        end
-        rule
-      end
-
-      def self.parse_json(rule)
-        targets = Array.new
-        rule['targets'].each do |target|
-          targets.push(Twilio::TaskRouter::WorkflowRuleTarget.parse_json(target))
-        end
-        Twilio::TaskRouter::WorkflowRule.new rule['expression'], targets, rule['friendly_name']
-      end
-    end
-    class WorkflowRuleTarget
-
-      def initialize(queue, priority=nil, timeout=nil, expression=nil)
-        @queue = queue
-        @priority = priority
-        @timeout = timeout
-        @expression = expression
-      end
-
-      def queue
-        @queue
-      end
-
-      def priority
-        @priority
-      end
-
-      def timeout
-        @timeout
-      end
-
-      def expression
-        @expression
-      end
-
-      def to_json
-        target = {queue: @queue}
-        unless @priority.nil?
-          target['priority'] = @priority
-        end
-        unless @timeout.nil?
-          target['timeout'] = @timeout
-        end
-        unless @expression.nil?
-          target['expression'] = @expression
-        end
-        target
-      end
-
-      def self.parse_json(target)
-        Twilio::TaskRouter::WorkflowRuleTarget.new target['queue'], target['priority'], target['timeout'], target['expression']
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Twilio
-  module TwiML
-    class Response
-
-      attr_reader :text
-      alias_method :to_xml , :text
-
-      def initialize(&block)
-        xml = Builder::XmlMarkup.new
-        xml.instruct!
-        @text = xml.Response &block
-      end
-
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-module Twilio
-  module Util
-    class Capability
-
-      include Twilio::Util
-
-      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 }
-        @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 }
-        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['params'] = filters unless filters.empty?
-        @capabilities << scope_uri_for('stream', 'subscribe', scope_params)
-      end
-
-      def scope_uri_for(service, privilege, params = {})
-        scope_uri = "scope:#{service}:#{privilege}"
-        scope_uri << "?#{url_encode(params)}" unless params.empty?
-      end
-
-      def generate(ttl = 3600)
-
-        capabilities = @capabilities.clone # we need a local copy to work on
-
-        # 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
-          capabilities << scope_uri_for('client', 'outgoing', params)
-        end
-
-        payload = {
-          'scope' => capabilities.join(' '),
-          'iss' => @account_sid,
-          'exp' => (Time.now.to_i + ttl),
-        }
-
-        JWT.encode payload, @auth_token
-
-      end
-
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-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/request_validator.rb

@@ -1,37 +0,0 @@
-module Twilio
-  module Util
-    class RequestValidator
-
-      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
-        secure_compare(expected, signature)
-      end
-
-      def build_signature_for(url, params)
-        data = url + params.sort.join
-        digest = OpenSSL::Digest.new('sha1')
-        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/spec/rack/twilio_webhook_authentication_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-require 'rack/mock'
-
-describe Rack::TwilioWebhookAuthentication do
-  before do
-    @app = lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['Hello']] }
-  end
-
-  describe 'new' do
-    it 'should initialize with an app, auth token and a path' do
-      expect {
-        Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/)
-      }.not_to raise_error
-    end
-
-    it 'should initialize with an app, auth token and paths' do
-      expect {
-        Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
-      }.not_to raise_error
-    end
-
-    it 'should initialize with an app, dynamic token and paths' do
-      expect {
-        Rack::TwilioWebhookAuthentication.new(@app, nil, /\/voice/, /\/sms/)
-      }.not_to raise_error
-    end
-  end
-
-  describe 'calling against one path with dynamic auth token' do
-    it 'should allow a request through if it validates' do
-      auth_token = 'qwerty'
-      account_sid = 12345
-      expect_any_instance_of(Rack::Request).to receive(:post?).and_return(true)
-      expect_any_instance_of(Rack::Request).to receive(:POST).and_return({'AccountSid' => account_sid})
-      @middleware = Rack::TwilioWebhookAuthentication.new(@app, nil, /\/voice/) { |asid| auth_token}
-      request_validator = double('RequestValidator')
-      expect(Twilio::Util::RequestValidator).to receive(:new).with(auth_token).and_return(request_validator)
-      expect(request_validator).to receive(:validate).and_return(true)
-      request = Rack::MockRequest.env_for('/voice')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(200)
-    end
-  end
-
-  describe 'calling against one path' do
-    before do
-      @middleware = Rack::TwilioWebhookAuthentication.new(
-        @app, 'ABC', /\/voice/
-      )
-    end
-
-    it 'should not intercept when the path doesn\'t match' do
-      expect(Twilio::Util::RequestValidator).to_not receive(:validate)
-      request = Rack::MockRequest.env_for('/sms')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(200)
-    end
-
-    it 'should allow a request through if it validates' do
-      expect_any_instance_of(Twilio::Util::RequestValidator).to(
-        receive(:validate).and_return(true)
-      )
-      request = Rack::MockRequest.env_for('/voice')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(200)
-    end
-
-    it 'should short circuit a request to 403 if it does not validate' do
-      expect_any_instance_of(Twilio::Util::RequestValidator).to(
-        receive(:validate).and_return(false)
-      )
-      request = Rack::MockRequest.env_for('/voice')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(403)
-    end
-  end
-
-  describe 'calling against many paths' do
-    before do
-      @middleware = Rack::TwilioWebhookAuthentication.new(
-        @app, 'ABC', /\/voice/, /\/sms/
-      )
-    end
-
-    it 'should not intercept when the path doesn\'t match' do
-      expect(Twilio::Util::RequestValidator).to_not receive(:validate)
-      request = Rack::MockRequest.env_for('icesms')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(200)
-    end
-
-    it 'shold allow a request through if it validates' do
-      expect_any_instance_of(Twilio::Util::RequestValidator).to(
-        receive(:validate).and_return(true)
-      )
-      request = Rack::MockRequest.env_for('/sms')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(200)
-    end
-
-    it 'should short circuit a request to 403 if it does not validate' do
-      expect_any_instance_of(Twilio::Util::RequestValidator).to(
-        receive(:validate).and_return(false)
-      )
-      request = Rack::MockRequest.env_for('/sms')
-      status, headers, body = @middleware.call(request)
-      expect(status).to be(403)
-    end
-  end
-end

data/spec/rest/account_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::REST::Account do
-
-  before do
-    @account = Twilio::REST::Account.new('someUri', 'someClient')
-  end
-
-  it 'sets up incoming phone numbers resources object' do
-    expect(@account).to respond_to(:incoming_phone_numbers)
-    expect(@account.incoming_phone_numbers.instance_variable_get('@path')).to(
-      eq('someUri/IncomingPhoneNumbers')
-    )
-  end
-
-  it 'sets up an available phone numbers resources object' do
-    expect(@account).to respond_to(:available_phone_numbers)
-    expect(@account.available_phone_numbers.instance_variable_get('@path')).to(
-      eq('someUri/AvailablePhoneNumbers')
-    )
-  end
-
-  it 'sets up an outgoing caller ids resources object' do
-    expect(@account).to respond_to(:outgoing_caller_ids)
-    expect(@account.outgoing_caller_ids.instance_variable_get('@path')).to eq(
-      'someUri/OutgoingCallerIds'
-    )
-  end
-
-  it 'sets up a calls resources object' do
-    expect(@account).to respond_to(:calls)
-    expect(@account.calls.instance_variable_get('@path')).to eq('someUri/Calls')
-  end
-
-  it 'sets up a conferences resources object' do
-    expect(@account).to respond_to(:conferences)
-    expect(@account.conferences.instance_variable_get('@path')).to eq(
-      'someUri/Conferences'
-    )
-  end
-
-  it 'sets up a queues resources object' do
-    expect(@account).to respond_to(:queues)
-    expect(@account.queues.instance_variable_get('@path')).to eq(
-      'someUri/Queues'
-    )
-  end
-
-  it 'sets up a sms resource object' do
-    expect(@account).to respond_to(:sms)
-    expect(@account.sms.instance_variable_get('@path')).to eq('someUri/SMS')
-  end
-
-  it 'sets up a recordings resources object' do
-    expect(@account).to respond_to(:recordings)
-    expect(@account.recordings.instance_variable_get('@path')).to eq(
-      'someUri/Recordings'
-    )
-  end
-
-  it 'sets up a transcriptions resources object' do
-    expect(@account).to respond_to(:transcriptions)
-    expect(@account.transcriptions.instance_variable_get('@path')).to eq(
-      'someUri/Transcriptions'
-    )
-  end
-
-  it 'sets up a notifications resources object' do
-    expect(@account).to respond_to(:notifications)
-    expect(@account.notifications.instance_variable_get('@path')).to eq(
-      'someUri/Notifications'
-    )
-  end
-
-  it 'sets up a tokens resources object' do
-    expect(@account).to respond_to(:tokens)
-    expect(@account.tokens.instance_variable_get('@path')).to eq(
-      'someUri/Tokens'
-    )
-  end
-
-  it 'sets up an addresses resources object' do
-    expect(@account).to respond_to(:addresses)
-    expect(@account.addresses.instance_variable_get('@path')).to eq(
-      'someUri/Addresses'
-    )
-  end
-
-end

data/spec/rest/address_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::REST::Address do
-  it 'should set up a dependent phone numbers resources object' do
-    address = Twilio::REST::Address.new('someUri', 'someClient')
-    expect(address).to respond_to(:dependent_phone_numbers)
-    expect(address.dependent_phone_numbers.instance_variable_get('@path')).to eq(
-      'someUri/DependentPhoneNumbers'
-    )
-  end
-end

data/spec/rest/call_feedback_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::REST::Feedback do
-  before do
-    @call = Twilio::REST::Call.new('someUri', 'someClient')
-  end
-
-  it 'sets up a feedback resources object' do
-    expect(@call).to respond_to(:feedback)
-    expect(@call.feedback.instance_variable_get('@path')).to eq('someUri/Feedback')
-  end
-end

data/spec/rest/call_feedback_summary_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::REST::FeedbackSummary do
-  it 'creates a feedback summary object' do
-    calls = Twilio::REST::Calls.new('someUri', 'someClient')
-    expect(calls).to respond_to(:feedback_summary)
-    expect(calls.feedback_summary.instance_variable_get('@path')).to eq('someUri/FeedbackSummary')
-  end
-end

data/spec/rest/call_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::REST::Call do
-
-  before do
-    @call = Twilio::REST::Call.new('someUri', 'someClient')
-  end
-
-  it 'sets up a recordings resources object' do
-    expect(@call).to respond_to(:recordings)
-    expect(@call.recordings.instance_variable_get('@path')).to eq(
-      'someUri/Recordings'
-    )
-  end
-
-  it 'sets up a notifications resources object' do
-    expect(@call).to respond_to(:notifications)
-    expect(@call.notifications.instance_variable_get('@path')).to eq(
-      'someUri/Notifications'
-    )
-  end
-end