twilio-ruby 5.0.0.alpha1 → 5.0.0.rc2

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

@@ -1,35 +1,34 @@
 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
+          'end',
+          'first_page_uri',
+          'next_page_uri',
+          'last_page_uri',
+          'page',
+          'page_size',
+          'previous_page_uri',
+          'total',
+          'num_pages',
+          'start',
+          'uri'
+      ]
 
       def initialize(version, response)
-        payload = process_response(response)
+        payload = self.process_response(response)
 
         @version = version
         @payload = payload
         @solution = {}
-        @records = load_page(payload)
+        @records = self.load_page(payload)
       end
 
       def process_response(response)
         if response.status_code != 200
-          raise Twilio::REST::TwilioError.new('Unable to fetch page', response)
+          raise Twilio::REST::TwilioException.new('Unable to fetch page', response)
         end
 
         response.body
@@ -41,17 +40,19 @@ module Twilio
         else
           keys = payload.keys
           key = keys - META_KEYS
-          return payload[key.first] if key.size == 1
+          if key.size == 1
+            return payload[key.first]
+          end
         end
 
-        raise Twilio::REST::TwilioError, 'Page Records can not be deserialized'
+        raise Twilio::REST::TwilioException.new('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)
+          return URI.parse(@payload['meta']['previous_page_url']).path
         elsif @payload['previous_page_uri']
-          return @version.domain.absolute_url(@payload['previous_page_uri'])
+          return @payload['previous_page_uri']
         end
 
         nil
@@ -59,37 +60,37 @@ module Twilio
 
       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)
+          return URI.parse(@payload['meta']['next_page_url']).path
         elsif @payload['next_page_uri']
-          return @version.domain.absolute_url(@payload['next_page_uri'])
+          return @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'
+        raise Twilio::REST::TwilioException.new('Page.get_instance() must be implemented in the derived class')
       end
 
       def previous_page
-        return nil unless previous_page_url
+        return nil unless self.previous_page_url
 
-        response = @version.domain.request('GET', previous_page_url)
+        response = @version.domain.request('GET', self.previous_page_url)
 
         self.class.new(@version, response, @solution)
       end
 
       def next_page
-        return nil unless next_page_url
+        return nil unless self.next_page_url
 
-        response = @version.domain.request('GET', next_page_url)
+        response = @version.domain.request('GET', self.next_page_url)
 
         self.class.new(@version, response, @solution)
       end
 
       def each
         @records.each do |record|
-          yield get_instance(record)
+          yield self.get_instance(record)
         end
       end
 
@@ -99,3 +100,4 @@ module Twilio
     end
   end
 end
+

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

@@ -8,13 +8,13 @@ module Twilio
 
     class InstanceContext
       def initialize(version)
-        @version = version
+          @version = version
       end
     end
 
     class InstanceResource
       def initialize(version)
-        @version = version
+          @version = version
       end
     end
   end

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

@@ -1,70 +1,19 @@
 module Twilio
-  def self.serialize_iso8601_date(date)
-    if date.eql?(:unset)
-      date
-    elsif date.is_a?(Date)
+  def self.serialize_iso8601(date)
+    if 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
+    unless date.nil?
+      Time.rfc2822(date)
     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
+  def self.deserialize_iso8601(date)
+    unless date.nil?
+      Time.parse(date)
     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
 end

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

@@ -7,7 +7,7 @@ module Twilio
       body = '{}' if !body || body.empty?
       @body = JSON.parse(body)
     end
-
+    
     def to_s
       "[#{status_code}] #{body}"
     end

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

@@ -1,6 +1,8 @@
 module Twilio
   module REST
     class Version
+      MAX_PAGE_SIZE = 1000
+
       attr_accessor :domain
 
       class RecordStream
@@ -10,20 +12,21 @@ module Twilio
           @page = page
           @limit = limit
           @page_limit = page_limit
+
         end
 
         def each
-          current_record = 0
+          current_record = 1
           current_page = 1
 
           while @page
             @page.each do |record|
               yield record
               current_record += 1
-              return nil if @limit && @limit <= current_record
+              return if @limit && @limit <= current_record
             end
 
-            return nil if @page_limit && @page_limit <= current_page
+            return if @page_limit && @page_limit <= current_page
 
             @page = @page.next_page
             current_page += 1
@@ -37,35 +40,30 @@ module Twilio
       end
 
       def absolute_url(uri)
-        @domain.absolute_url(relative_uri(uri))
+        @domain.absolute_url(self.relative_uri(uri))
       end
 
       def relative_uri(uri)
         "#{@version.chomp('/').gsub(/^\//, '')}/#{uri.chomp('/').gsub(/^\//, '')}"
       end
 
-      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
-        url = relative_uri(uri)
-        params = params.delete_if { |_k, v| v.nil? }
-        data = data
-        @domain.request(method, url, params, data, headers, auth, timeout)
-      end
-
-      def exception(response, header)
-        message = header
-        code = response.status_code
-
-        if response.body.key?('message')
-          message += ": #{response.body['message']}"
-        end
-
-        code = response.body['code'] if response.body.key?('code')
-
-        Twilio::REST::RestError.new(message, code, response.status_code)
+      def request(method, uri, params={}, data={}, headers={}, auth=nil, timeout=nil)
+        url = self.relative_uri(uri)
+        params = params.delete_if {|k,v| v.nil?}
+        data = data.delete_if {|k,v| v.nil?}
+        @domain.request(
+          method,
+          url,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
       end
 
-      def fetch(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
-        response = request(
+      def fetch(method, uri, params={}, data={}, headers={}, auth=nil, timeout=nil)
+        response = self.request(
           method,
           uri,
           params,
@@ -75,15 +73,15 @@ module Twilio
           timeout
         )
 
-        if response.status_code < 200 || response.status_code >= 300
-          raise exception(response, 'Unable to fetch record')
+        if response.status_code != 200
+          raise Twilio::REST::TwilioException.new('Unable to fetch record')
         end
 
         response.body
       end
 
       def update(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
-        response = request(
+        response = self.request(
           method,
           uri,
           params,
@@ -93,15 +91,15 @@ module Twilio
           timeout
         )
 
-        if response.status_code < 200 || response.status_code >= 300
-          raise exception(response, 'Unable to update record')
+        if response.status_code != 200
+          raise TwilioException.new('Unable to update record')
         end
 
         response.body
       end
 
-      def delete(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
-        response = request(
+      def delete(method, uri, params={}, data={}, headers={}, auth=nil, timeout=nil)
+        response = self.request(
           method,
           uri,
           params,
@@ -111,31 +109,31 @@ module Twilio
           timeout
         )
 
-        if response.status_code < 200 || response.status_code >= 300
-          raise exception(response, 'Unable to delete record')
+        if 500 <= response.status_code && response.status_code < 600
+          raise TwilioException.new('Unable to delete record')
         end
 
         response.status_code == 204
       end
 
-      def read_limits(limit = nil, page_size = nil)
+      def read_limits(limit=nil, page_size=nil)
         page_limit = nil
 
         unless limit.nil?
           # If there is no user-specified page_size, pick the most network efficient size
-          page_size = limit
+          page_size ||= [limit, MAX_PAGE_SIZE].min
           page_limit = (limit / page_size.to_f).ceil
         end
 
         {
           limit: limit || nil,
           page_size: page_size || nil,
-          page_limit: page_limit
+          page_limit: page_limit,
         }
       end
 
-      def page(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
-        request(
+      def page(method, uri, params={}, data={}, headers={}, auth=nil, timeout=nil)
+        self.request(
           method,
           uri,
           params,
@@ -151,13 +149,20 @@ module Twilio
       end
 
       def create(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
-        response = request(method, uri, params, data, headers, auth, timeout)
-
-        if response.status_code < 200 || response.status_code >= 300
-          raise exception(response, 'Unable to create record')
+        response = self.request(
+                    method,
+                    uri,
+                    params,
+                    data,
+                    headers,
+                    auth,
+                    timeout)
+
+        unless [200, 201].include?(response.status_code)
+          raise TwilioException.new("[#{response.status_code}] Unable to create record\n#{response.body}")
         end
 
-        response.body
+        return response.body
       end
     end
   end

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

@@ -5,26 +5,25 @@ module Twilio
     class Client
       attr_accessor :adapter
 
-      def initialize(proxy_addr = nil, proxy_port = nil, proxy_user = nil, proxy_pass = nil, ssl_ca_file = nil)
+      def initialize(proxy_addr=nil, proxy_port=nil, proxy_user=nil, proxy_pass=nil, ssl_ca_file=nil)
         @proxy_addr = proxy_addr
         @proxy_port = proxy_port
         @proxy_user = proxy_user
         @proxy_pass = proxy_pass
         @ssl_ca_file = ssl_ca_file
         @adapter = Faraday.default_adapter
-
-        # Set default params encoder
-        Faraday::Utils.default_params_encoder = Faraday::FlatParamsEncoder
       end
 
-      def request(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
-        @connection = Faraday.new(url: host + ':' + port.to_s, ssl: { verify: true }) do |f|
+      def request(host, port, method, url, params={}, data={}, headers={}, auth=nil, timeout=nil)
+        puts host
+        puts url
+        @connection = Faraday.new(url: host + ":" + port.to_s, ssl: {verify: true}) do |f|
           f.request :url_encoded
           f.adapter @adapter
           f.headers = headers
           f.basic_auth(auth[0], auth[1])
           if @proxy_addr
-            f.proxy '#{@proxy_user}:#{@proxy_pass}@#{@proxy_addr}:#{@proxy_port}'
+            f.proxy "#{@proxy_user}:#{@proxy_pass}@#{@proxy_addr}:#{@proxy_port}"
           end
           f.options.open_timeout = timeout
           f.options.timeout = timeout
@@ -33,7 +32,7 @@ module Twilio
         response = @connection.send(method.downcase.to_sym, url, method == 'GET' ? params : data)
 
         @last_response = response
-        if response.body && !response.body.empty?
+        if response.body and !response.body.empty?
           object = response.body
         elsif response.status == 400
           object = { message: 'Bad request', code: 400 }.to_json
@@ -42,5 +41,6 @@ module Twilio
         TwilioResponse.new(response.status, object)
       end
     end
+
   end
 end