whoosh-ruby 0.1.0 → 0.1.2

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+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/values.rb

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

data/lib/twilio-ruby/http/http_client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Twilio
+  module HTTP
+    class Client
+      attr_accessor :adapter
+      attr_reader :timeout, :last_response, :last_request
+
+      def initialize(proxy_prot = nil, proxy_addr = nil, proxy_port = nil, proxy_user = nil, proxy_pass = nil,
+                     ssl_ca_file = nil, timeout: nil)
+        @proxy_prot = proxy_prot
+        @proxy_path = "#{proxy_addr}:#{proxy_port}" if proxy_addr && proxy_port
+        @proxy_auth = "#{proxy_user}:#{proxy_pass}@" if proxy_pass && proxy_user
+        @ssl_ca_file = ssl_ca_file
+        @timeout = timeout
+        @adapter = Faraday.default_adapter
+        @configure_connection_blocks = []
+      end
+
+      def configure_connection(&block)
+        raise ArgumentError, "#{__method__} must be given a block!" unless block_given?
+
+        @configure_connection_blocks << block
+        nil
+      end
+
+      def _request(request) # rubocop:disable Metrics/MethodLength
+        @connection = Faraday.new(url: request.host + ':' + request.port.to_s, ssl: { verify: true }) do |f|
+          f.options.params_encoder = Faraday::FlatParamsEncoder
+          f.request :url_encoded
+          f.headers = request.headers
+          if Faraday::VERSION.start_with?('2.')
+            f.request(:authorization, :basic, request.auth[0], request.auth[1])
+          else
+            f.request(:basic_auth, request.auth[0], request.auth[1])
+          end
+          f.proxy = "#{@proxy_prot}://#{@proxy_auth}#{@proxy_path}" if @proxy_prot && @proxy_path
+          f.options.open_timeout = request.timeout || @timeout
+          f.options.timeout = request.timeout || @timeout
+
+          @configure_connection_blocks.each { |block| block.call(f) }
+          f.adapter @adapter
+        end
+
+        @last_request = request
+        @last_response = nil
+
+        response = send(request)
+        if (500..599).include?(response.status)
+          object = { message: "Server error (#{response.status})", code: response.status }.to_json
+        elsif response.body && !response.body.empty?
+          object = response.body
+        elsif response.status == 400
+          object = { message: 'Bad request', code: 400 }.to_json
+        end
+
+        twilio_response = Twilio::Response.new(response.status, object, headers: response.headers)
+        @last_response = twilio_response
+
+        twilio_response
+      end
+
+      def send(request)
+        @connection.send(request.method.downcase.to_sym,
+                         request.url,
+                         request.method == 'GET' ? request.params : request.data)
+      rescue Faraday::Error => e
+        raise Twilio::REST::TwilioError, e
+      end
+
+      def request(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        request = Twilio::Request.new(host, port, method, url, params, data, headers, auth, timeout)
+        _request(request)
+      end
+    end
+  end
+end

data/lib/twilio-ruby/http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'http/**/*.rb')].sort.each do |file|
+  require file
+end

data/lib/twilio-ruby/jwt/access_token.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Twilio
+  module JWT
+    module AccessTokenGrant
+      def _key
+        raise NotImplementedError
+      end
+
+      def _generate_payload
+        raise NotImplementedError
+      end
+    end
+
+    class AccessToken < BaseJWT
+      attr_accessor :account_sid,
+                    :signing_key_id,
+                    :secret,
+                    :identity,
+                    :grants,
+                    :nbf,
+                    :ttl,
+                    :valid_until,
+                    :region
+
+      def initialize(
+        account_sid,
+        signing_key_sid,
+        secret,
+        grants = [],
+        identity: nil,
+        nbf: nil,
+        ttl: 3600,
+        valid_until: nil,
+        region: nil
+      )
+        super(secret_key: secret,
+              issuer: signing_key_sid,
+              subject: account_sid,
+              nbf: nbf,
+              ttl: ttl,
+              valid_until: valid_until)
+        @account_sid = account_sid
+        @signing_key_sid = signing_key_sid
+        @secret = secret
+        @identity = identity
+        @nbf = nbf
+        @grants = grants
+        @ttl = ttl
+        @valid_until = valid_until
+        @region = region
+      end
+
+      def add_grant(grant)
+        @grants.push(grant)
+      end
+
+      protected
+
+      def _generate_payload
+        now = Time.now.to_i
+        grants = {}
+        grants[:identity] = @identity if @identity
+
+        @grants.each { |grant| grants[grant._key] = grant._generate_payload } unless @grants.empty?
+
+        payload = {
+          jti: "#{@signing_key_sid}-#{now}",
+          grants: grants
+        }
+
+        payload
+      end
+
+      protected
+
+      def _generate_headers
+        headers = {
+          cty: 'twilio-fpa;v=1'
+        }
+
+        headers[:twr] = region unless region&.nil?
+
+        headers
+      end
+
+      class ChatGrant
+        include AccessTokenGrant
+        attr_accessor :service_sid,
+                      :endpoint_id,
+                      :deployment_role_sid,
+                      :push_credential_sid
+
+        def _key
+          'chat'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload[:service_sid] = service_sid if service_sid
+
+          payload[:endpoint_id] = endpoint_id if endpoint_id
+
+          if deployment_role_sid
+            payload[:deployment_role_sid] = deployment_role_sid
+          end
+
+          if push_credential_sid
+            payload[:push_credential_sid] = push_credential_sid
+          end
+
+          payload
+        end
+      end
+
+      class VoiceGrant
+        include AccessTokenGrant
+        attr_accessor :incoming_allow,
+                      :outgoing_application_sid,
+                      :outgoing_application_params,
+                      :push_credential_sid,
+                      :endpoint_id
+
+        def _key
+          'voice'
+        end
+
+        def _generate_payload
+          payload = {}
+          payload[:incoming] = { allow: true } if incoming_allow == true
+
+          if outgoing_application_sid
+            outgoing = {}
+            outgoing[:application_sid] = outgoing_application_sid
+            if outgoing_application_params
+              outgoing[:params] = outgoing_application_params
+            end
+
+            payload[:outgoing] = outgoing
+          end
+
+          if push_credential_sid
+            payload[:push_credential_sid] = push_credential_sid
+          end
+
+          payload[:endpoint_id] = endpoint_id if endpoint_id
+
+          payload
+        end
+      end
+
+      class SyncGrant
+        include AccessTokenGrant
+        attr_accessor :service_sid,
+                      :endpoint_id
+
+        def _key
+          'data_sync'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload['service_sid'] = service_sid if service_sid
+          payload['endpoint_id'] = endpoint_id if endpoint_id
+
+          payload
+        end
+      end
+
+      class VideoGrant
+        include AccessTokenGrant
+        attr_accessor :room
+
+        def _key
+          'video'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload[:room] = room if room
+
+          payload
+        end
+      end
+
+      class TaskRouterGrant
+        include AccessTokenGrant
+        attr_accessor :workspace_sid,
+                      :worker_sid,
+                      :role
+
+        def _key
+          'task_router'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload[:workspace_sid] = workspace_sid if workspace_sid
+
+          payload[:worker_sid] = worker_sid if worker_sid
+
+          payload[:role] = role if role
+
+          payload
+        end
+      end
+
+      class PlaybackGrant
+        include AccessTokenGrant
+        attr_accessor :grant
+
+        def _key
+          'player'
+        end
+
+        def _generate_payload
+          grant
+        end
+      end
+    end
+  end
+end

data/lib/twilio-ruby/jwt/client_capability.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Twilio
+  module JWT
+    module Scope
+      def _generate_payload
+        raise 'Not Implemented'
+      end
+    end
+
+    class ClientCapability < BaseJWT
+      attr_accessor :account_sid,
+                    :auth_token,
+                    :client_name,
+                    :scopes
+
+      def initialize(account_sid, auth_token, scopes: [], nbf: nil, ttl: 3600, valid_until: nil)
+        super(secret_key: auth_token, issuer: account_sid, nbf: nbf, ttl: ttl, valid_until: valid_until)
+        @account_sid = account_sid
+        @auth_token = auth_token
+        @client_name = nil
+        @scopes = scopes
+      end
+
+      def add_scope(scope)
+        @scopes.push(scope)
+      end
+
+      protected
+
+      def _generate_payload
+        scope = ''
+        scope = @scopes.map(&:_generate_payload).join(' ') unless @scopes.empty?
+
+        payload = {
+          scope: scope
+        }
+
+        payload
+      end
+
+      class IncomingClientScope
+        include Scope
+
+        def initialize(client_name)
+          @client_name = client_name
+        end
+
+        def _generate_payload
+          prefix = 'scope:client:incoming'
+          suffix = 'clientName=' + CGI.escape(@client_name.to_s)
+
+          [prefix, suffix].join('?')
+        end
+      end
+
+      class OutgoingClientScope
+        include Scope
+
+        def initialize(application_sid, client_name = nil, params = {})
+          @application_sid = application_sid
+          @client_name = client_name
+          @params = params
+        end
+
+        def _generate_payload
+          prefix = 'scope:client:outgoing'
+          application_sid = "appSid=#{CGI.escape(@application_sid)}"
+          unless @client_name.nil?
+            client_name = "clientName=#{CGI.escape(@client_name)}"
+          end
+          unless @params.empty?
+            params = 'appParams=' + @params.map { |k, v| CGI.escape("#{k}=#{v}") }.join(CGI.escape('&'))
+          end
+
+          suffix = [application_sid, client_name, params].compact.join('&')
+          [prefix, suffix].join('?')
+        end
+      end
+
+      class EventStreamScope
+        include Scope
+
+        def initialize(filters = {})
+          @filters = filters
+          @path = '/2010-04-01/Events'
+        end
+
+        def _generate_payload
+          prefix = 'scope:stream:subscribe'
+          path = "path=#{CGI.escape(@path)}"
+          unless @filters.empty?
+            filters = 'params=' + @filters.map { |k, v| CGI.escape("#{k}=#{v}") }.join('&')
+          end
+
+          suffix = [path, filters].compact.join('&')
+          [prefix, suffix].join('?')
+        end
+      end
+    end
+  end
+end

data/lib/twilio-ruby/jwt/jwt.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'jwt'
+
+module Twilio
+  module JWT
+    autoload :AccessToken, File.join(File.dirname(__FILE__), 'access_token.rb')
+    autoload :ClientCapability, File.join(File.dirname(__FILE__), 'client_capability.rb')
+    autoload :TaskRouterCapability, File.join(File.dirname(__FILE__), 'task_router.rb')
+
+    class BaseJWT
+      # valid_until overrides ttl if specified
+      def initialize(secret_key: nil, issuer: nil, subject: nil, nbf: nil, ttl: 3600, valid_until: nil)
+        if secret_key.nil?
+          raise ArgumentError, 'JWT does not have a signing key'
+        end
+
+        @secret_key = secret_key
+        @issuer = issuer
+        @subject = subject
+        @algorithm = 'HS256'
+        @nbf = nbf
+        @ttl = ttl
+        @valid_until = valid_until
+      end
+
+      def _generate_headers
+        {}
+      end
+
+      def _generate_payload
+        raise NotImplementedError
+      end
+
+      def headers
+        headers = _generate_headers.clone
+        headers['typ'] = 'JWT'
+        headers['alg'] = @algorithm
+        headers
+      end
+
+      def payload
+        payload = _generate_payload.clone
+
+        payload[:iss] = @issuer
+        payload[:nbf] = @nbf || Time.now.to_i
+        payload[:exp] = @valid_until.nil? ? Time.now.to_i + @ttl : @valid_until
+        payload[:sub] = @subject unless @subject.nil?
+
+        payload
+      end
+
+      def to_jwt
+        ::JWT.encode payload, @secret_key, @algorithm, headers
+      end
+      alias to_s to_jwt
+    end
+  end
+end