utils.rb in twitter-5.6.0

- old
+ new

@@ -1,33 +1,19 @@
 require 'addressable/uri'
 require 'twitter/arguments'
-require 'twitter/cursor'
+require 'twitter/request'
 require 'twitter/user'
 require 'twitter/utils'
 
 module Twitter
   module REST
     module API
       module Utils
-        DEFAULT_CURSOR = -1
+        include Twitter::Utils
         URI_SUBSTRING = '://'
+        DEFAULT_CURSOR = -1
 
-        class << self
-          def included(base)
-            base.extend(ClassMethods)
-          end
-        end
-
-        module ClassMethods
-          def deprecate_alias(new_name, old_name)
-            define_method(new_name) do |*args, &block|
-              warn "#{Kernel.caller.first}: [DEPRECATION] ##{new_name} is deprecated. Use ##{old_name} instead."
-              send(old_name, *args, &block)
-            end
-          end
-        end
-
       private
 
         # Take a URI string or Twitter::Identity object and return its ID
         #
         # @param object [Integer, String, URI, Twitter::Identity] An ID, URI, or object.
@@ -45,119 +31,105 @@
           end
         end
 
         # @param request_method [Symbol]
         # @param path [String]
+        # @param options [Hash]
+        # @param klass [Class]
+        def perform_with_object(request_method, path, options, klass)
+          request = Twitter::Request.new(self, request_method, path, options)
+          request.perform_with_object(klass)
+        end
+
+        # @param request_method [Symbol]
+        # @param path [String]
+        # @param options [Hash]
+        # @param klass [Class]
+        def perform_with_objects(request_method, path, options, klass)
+          request = Twitter::Request.new(self, request_method, path, options)
+          request.perform_with_objects(klass)
+        end
+
+        # @param request_method [Symbol]
+        # @param path [String]
+        # @param options [Hash]
+        # @param klass [Class]
+        def perform_with_cursor(request_method, path, options, collection_name, klass = nil) # rubocop:disable ParameterLists
+          merge_default_cursor!(options)
+          request = Twitter::Request.new(self, request_method, path, options)
+          request.perform_with_cursor(collection_name.to_sym, klass)
+        end
+
+        # @param request_method [Symbol]
+        # @param path [String]
         # @param args [Array]
         # @return [Array<Twitter::User>]
         def parallel_user_objects_from_response(request_method, path, args)
           arguments = Twitter::Arguments.new(args)
-          Twitter::Utils.parallel_map(arguments) do |user|
-            object_from_response(Twitter::User, request_method, path, merge_user(arguments.options, user))
+          parallel_map(arguments) do |user|
+            perform_with_object(request_method, path, merge_user(arguments.options, user), Twitter::User)
           end
         end
 
         # @param request_method [Symbol]
         # @param path [String]
         # @param args [Array]
         # @return [Array<Twitter::User>]
         def user_objects_from_response(request_method, path, args)
           arguments = Twitter::Arguments.new(args)
           merge_user!(arguments.options, arguments.pop || screen_name) unless arguments.options[:user_id] || arguments.options[:screen_name]
-          objects_from_response(Twitter::User, request_method, path, arguments.options)
+          perform_with_objects(request_method, path, arguments.options, Twitter::User)
         end
 
         # @param klass [Class]
         # @param request_method [Symbol]
         # @param path [String]
         # @param args [Array]
         # @return [Array]
-        def objects_from_response_with_user(klass, request_method, path, args) # rubocop:disable ParameterLists
+        def objects_from_response_with_user(klass, request_method, path, args)
           arguments = Twitter::Arguments.new(args)
           merge_user!(arguments.options, arguments.pop)
-          objects_from_response(klass, request_method, path, arguments.options)
+          perform_with_objects(request_method, path, arguments.options, klass)
         end
 
         # @param klass [Class]
         # @param request_method [Symbol]
         # @param path [String]
-        # @param options [Hash]
-        # @return [Array]
-        def objects_from_response(klass, request_method, path, options = {}) # rubocop:disable ParameterLists
-          response = send(request_method.to_sym, path, options)[:body]
-          objects_from_array(klass, response)
-        end
-
-        # @param klass [Class]
-        # @param array [Array]
-        # @return [Array]
-        def objects_from_array(klass, array)
-          array.map do |element|
-            klass.new(element)
-          end
-        end
-
-        # @param klass [Class]
-        # @param request_method [Symbol]
-        # @param path [String]
         # @param args [Array]
         # @return [Array]
-        def parallel_objects_from_response(klass, request_method, path, args) # rubocop:disable ParameterLists
+        def parallel_objects_from_response(klass, request_method, path, args)
           arguments = Twitter::Arguments.new(args)
-          Twitter::Utils.parallel_map(arguments) do |object|
-            id = extract_id(object)
-            object_from_response(klass, request_method, path, arguments.options.merge(:id => id))
+          parallel_map(arguments) do |object|
+            perform_with_object(request_method, path, arguments.options.merge(:id => extract_id(object)), klass)
           end
         end
 
-        # @param klass [Class]
-        # @param request_method [Symbol]
-        # @param path [String]
-        # @param options [Hash]
-        # @return [Object]
-        def object_from_response(klass, request_method, path, options = {}) # rubocop:disable ParameterLists
-          response = send(request_method.to_sym, path, options)
-          klass.from_response(response)
-        end
-
         # @param collection_name [Symbol]
         # @param klass [Class]
         # @param request_method [Symbol]
         # @param path [String]
         # @param args [Array]
         # @return [Twitter::Cursor]
         def cursor_from_response_with_user(collection_name, klass, request_method, path, args) # rubocop:disable ParameterLists
           arguments = Twitter::Arguments.new(args)
           merge_user!(arguments.options, arguments.pop || screen_name) unless arguments.options[:user_id] || arguments.options[:screen_name]
-          cursor_from_response(collection_name, klass, request_method, path, arguments.options)
+          perform_with_cursor(request_method, path, arguments.options, collection_name, klass)
         end
 
-        # @param collection_name [Symbol]
-        # @param klass [Class]
-        # @param request_method [Symbol]
-        # @param path [String]
-        # @param options [Hash]
-        # @return [Twitter::Cursor]
-        def cursor_from_response(collection_name, klass, request_method, path, options) # rubocop:disable ParameterLists
-          merge_default_cursor!(options)
-          response = send(request_method.to_sym, path, options)
-          Twitter::Cursor.from_response(response, collection_name.to_sym, klass, self, request_method, path, options)
-        end
-
         def handle_forbidden_error(klass, error)
           error = klass.new(error) if error.message == klass::MESSAGE
           fail(error)
         end
 
-        def merge_default_cursor!(options)
-          options[:cursor] = DEFAULT_CURSOR unless options[:cursor]
-        end
-
         def screen_name
           @screen_name ||= verify_credentials.screen_name
         end
 
+        def merge_default_cursor!(options)
+          options[:cursor] = DEFAULT_CURSOR unless options[:cursor]
+        end
+
         # Take a user and merge it into the hash with the correct key
         #
         # @param hash [Hash]
         # @param user [Integer, String, Twitter::User] A Twitter user ID, screen name, URI, or object.
         # @return [Hash]
@@ -185,10 +157,10 @@
           when Twitter::User
             set_compound_key('user_id', user.id, hash, prefix)
           end
         end
 
-        def set_compound_key(key, value, hash, prefix = nil) # rubocop:disable ParameterLists
+        def set_compound_key(key, value, hash, prefix = nil)
           compound_key = [prefix, key].compact.join('_').to_sym
           hash[compound_key] = value
           hash
         end
 