twitter_friendly 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd3aedc3bbfeb41ae92a95b3ca8a4a654c03d1332540396d85ff883871456f8d
-  data.tar.gz: 2554445ef8a39dce0be467d006f9f1fea19aa6ce265a0612e71350f27aca3007
+  metadata.gz: 01532d5c3cc176a719499e7680cb7df3127c45a4f745ece3f05d703158aa4dcc
+  data.tar.gz: 04cc82c2474a4d7e63d232f13750aeed2a2da072654605fb90c3ab2fc43ed6c4
 SHA512:
-  metadata.gz: 69ce0e002321247a430df087a6efad1868c5fd7397c86940f8c4bf9043e089c8d7077acda3699926d29b8b69d9b24cc511313e072f515e2897c62cbdc6df3927
-  data.tar.gz: a2b958451a785d063b23becc9bde00c3fb52c89f25e646a95b4c98126c2969771ad3a8b7fed3ee80e64cc8618ba0f1f99dd3fdd9121f01c3f1075071e564789a
+  metadata.gz: e8f28b5369b73869cdf39cc6165550b8a75d7fe5acff766ee0f1cfd9e6d965acb15c9bd00281cc3b1a1d3424a829e1ad6c005b2befcb55e4944faaa2d7e7ed95
+  data.tar.gz: e905e22b816779c8ce367e1c3ed5028a957289b15b1ba7b44d42d4bfe67457f1cbafa7febb1b0c00b99b20029d1b81d44af11310329d939c0f50ac642a57c6e8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    twitter_friendly (0.3.0)
+    twitter_friendly (1.0.0)
       activesupport (>= 4.2, < 6.0)
       oj (~> 3.7.6)
       parallel (~> 1.12.1)

data/README.md

@@ -3,7 +3,32 @@
 [![Gem Version](https://badge.fury.io/rb/twitter_friendly.png)](https://badge.fury.io/rb/twitter_friendly)
 [![Build Status](https://travis-ci.org/ts-3156/twitter_friendly.svg?branch=master)](https://travis-ci.org/ts-3156/twitter_friendly)
 
-A twitter-friendly Ruby interface to the Twitter API. This twitter_friendly gem provides multiple features.
+The twitter_friendly is a gem to crawl many friends/followers with minimal code. When you want to get a list of friends/followers for a user, all you need to write is the below.
+
+```
+require 'twitter_friendly'
+
+client =
+    TwitterFriendly::Client.new(
+        consumer_key: 'CONSUMER_KEY',
+        consumer_secret: 'CONSUMER_SECRET',
+        access_token: 'ACCESS_TOKEN',
+        access_token_secret: 'ACCESS_TOKEN_SECRET',
+        expires_in: 86400 # 1day
+    )
+
+ids = []
+
+begin
+  ids = client.follower_ids('yousuck2020')
+rescue Twitter::Error::TooManyRequests => e
+  sleep client.rate_limit.follower_ids[:reset_in]
+  retry
+end
+
+puts "ids #{ids.size}"
+File.write('ids.txt', ids.join("\n"))
+```
 
 - Auto pagination
 - Auto caching
@@ -156,30 +181,16 @@ client.followers
 Fetch the timeline of Tweets (by screen name or user ID, or by implicit authenticated user)
 
 ```ruby
-client.user_timeline('gem')
-client.user_timeline(213747670)
-client.user_timeline
+tweets = client.user_timeline('screen_name')
 
-result.size
+tweets.size
 # => 588
 
-result.first.text
+tweets[0][:text]
 # => "Your tweet text..."
 
-result.first.user.screen_name
-# => "your_screen_name"
-```
-
-Fetch the timeline of Tweets from the authenticated user's home page
-
-```ruby
-client.home_timeline
-```
-
-Fetch the timeline of Tweets mentioning the authenticated user
-
-```ruby
-client.mentions_timeline
+tweets[0][:user][:screen_name]
+# => "screen_name"
 ```
 
 ## Contributing

data/lib/twitter_friendly/cache_key.rb

@@ -2,16 +2,28 @@ require 'digest/md5'
 
 module TwitterFriendly
   class CacheKey
-    DELIM = ':'
+    DELIM = '__'
     VERSION = '1'
 
     class << self
-      def gen(method, user, options = {})
-        [version,
-         method,
-         method_identifier(method, user, options),
-         options_identifier(method, options)
-        ].compact.join(DELIM)
+      def gen(method_name, args, cache_options = {})
+        args_array = args.dup
+        options = args_array.extract_options!
+        user = method_name == :friendship? ? args_array[0, 2] : args_array[0]
+
+        key =
+            [version,
+             method_name,
+             method_identifier(method_name, user, options, cache_options),
+             options_identifier(method_name, options, cache_options)
+            ].compact.join(DELIM)
+
+        if ENV['SAVE_CACHE_KEY']
+          $last_cache_key = key
+          puts key
+        end
+
+        key
       end
 
       private
@@ -20,17 +32,19 @@ module TwitterFriendly
         'v' + VERSION
       end
 
-      def method_identifier(method, user, options)
-          case
-          when method == :search                    then "query#{DELIM}#{user}"
-          when method == :friendship?               then "from#{DELIM}#{user[0]}#{DELIM}to#{DELIM}#{user[1]}"
-          when method == :list_members              then "list_id#{DELIM}#{user}"
-          when method == :collect_with_max_id       then method_identifier(extract_super_operation(options), user, options)
-          when method == :collect_with_cursor       then method_identifier(extract_super_operation(options), user, options)
-          when user.nil? && options[:hash].present? then "token-hash#{DELIM}#{options[:hash]}"
-          else user_identifier(user)
-          end
+      def method_identifier(method, user, options, cache_options)
+        raise ArgumentError.new('You must specify method.') unless method
+        case
+        when method == :search                 then "query#{DELIM}#{user}"
+        when method == :friendship?            then "from#{DELIM}#{user[0]}#{DELIM}to#{DELIM}#{user[1]}"
+        when method == :list_members           then "list_id#{DELIM}#{user}"
+        when method == :collect_with_max_id    then super_operation_identifier(cache_options[:super_operation], user, options, cache_options)
+        when method == :collect_with_cursor    then super_operation_identifier(cache_options[:super_operation], user, options, cache_options)
+        when user.nil? && cache_options[:hash] then "token-hash#{DELIM}#{options[:hash]}"
+        else user_identifier(user)
+        end
       end
+      alias_method :super_operation_identifier, :method_identifier
 
       def user_identifier(user)
         case
@@ -43,28 +57,20 @@ module TwitterFriendly
         end
       end
 
-      def options_identifier(method, options)
+      def options_identifier(method, options, cache_options)
         # TODO 内部的な値はすべてprefix _tf_ をつける
         opt = options.except(:hash, :call_count, :call_limit, :super_operation, :super_super_operation, :recursive, :parallel)
-        opt[:in] = extract_super_operation(options) if %i(collect_with_max_id collect_with_cursor).include?(method)
+        opt[:in] = cache_options[:super_operation] if %i(collect_with_max_id collect_with_cursor).include?(method)
+        delim = '_'
 
         if opt.empty?
           nil
         else
-          str = opt.map {|k, v| "#{k}=#{v}"}.join('&')
+          str = opt.map {|k, v| "#{k}#{delim}#{v}"}.join(delim)
           "options#{DELIM}#{str}"
         end
       end
 
-      def extract_super_operation(options)
-        raise ArgumentError.new('You must specify :super_operation.') unless options[:super_operation]
-        if options[:super_operation].is_a?(Array)
-          options[:super_operation][0]
-        else
-          options[:super_operation]
-        end
-      end
-
       def hexdigest(ary)
         Digest::MD5.hexdigest(ary.join(','))
       end

data/lib/twitter_friendly/caching.rb

@@ -0,0 +1,80 @@
+module TwitterFriendly
+  module Caching
+    # 他のメソッドと違い再帰的に呼ばれるため、全体をキャッシュすると、すべてを再帰的にキャッシュしてしまう。
+    # それを防ぐために、特別にここでキャッシュの処理を登録している。
+
+    def caching_users
+      method_name = :users
+
+      define_method(method_name) do |*args|
+        if args[0].size <= TwitterFriendly::REST::Users::MAX_USERS_PER_REQUEST
+          options = args.dup.extract_options!
+          TwitterFriendly::CachingAndLogging::Instrumenter.start_processing(method_name, options)
+
+          TwitterFriendly::CachingAndLogging::Instrumenter.complete_processing(method_name, options) do
+
+            key = CacheKey.gen(method_name, args, hash: credentials_hash)
+            @cache.fetch(key, args: [method_name, options]) do
+              TwitterFriendly::CachingAndLogging::Instrumenter.perform_request(method_name, options) {super(*args)}
+            end
+          end
+        else
+          super(*args)
+        end
+      end
+    end
+
+    def caching_tweets_with_max_id(*method_names)
+      method_names.each do |method_name|
+        max_count =
+            case method_name
+            when :home_timeline     then TwitterFriendly::REST::Timelines::MAX_TWEETS_PER_REQUEST
+            when :user_timeline     then TwitterFriendly::REST::Timelines::MAX_TWEETS_PER_REQUEST
+            when :mentions_timeline then TwitterFriendly::REST::Timelines::MAX_TWEETS_PER_REQUEST
+            when :favorites         then TwitterFriendly::REST::Favorites::MAX_TWEETS_PER_REQUEST
+            when :search            then TwitterFriendly::REST::Search::MAX_TWEETS_PER_REQUEST
+            else raise "Unknown method #{method_name}"
+            end
+
+        define_method(method_name) do |*args|
+          options = {count: max_count}.merge(args.extract_options!)
+          args << options
+
+          if options[:count] <= max_count
+            TwitterFriendly::CachingAndLogging::Instrumenter.start_processing(method_name, options)
+
+            TwitterFriendly::CachingAndLogging::Instrumenter.complete_processing(method_name, options) do
+              key = CacheKey.gen(method_name, args, hash: credentials_hash)
+              @cache.fetch(key, args: [method_name, options]) do
+                TwitterFriendly::CachingAndLogging::Instrumenter.perform_request(method_name, options) {super(*args)}
+              end
+            end
+          else
+            super(*args)
+          end
+        end
+      end
+    end
+
+    def caching_resources_with_cursor(*method_names)
+      method_names.each do |method_name|
+        define_method(method_name) do |*args|
+          options = args.dup.extract_options!
+
+          if options.has_key?(:cursor)
+            TwitterFriendly::CachingAndLogging::Instrumenter.start_processing(method_name, options)
+
+            TwitterFriendly::CachingAndLogging::Instrumenter.complete_processing(method_name, options) do
+              key = CacheKey.gen(method_name, args, hash: credentials_hash)
+              @cache.fetch(key, args: [method_name, options]) do
+                TwitterFriendly::CachingAndLogging::Instrumenter.perform_request(method_name, options) {super(*args)}
+              end
+            end
+          else
+            super(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitter_friendly/caching_and_logging.rb

@@ -5,22 +5,18 @@ module TwitterFriendly
 
     # TODO 1つのメソッドに対して1回しか実行されないようにする
     # 全体をキャッシュさせ、さらにロギングを行う
-    def caching(*root_args)
-      root_args.each do |method_name|
+    def caching(*method_names)
+      method_names.each do |method_name|
+
         define_method(method_name) do |*args|
-          options = args.extract_options!
+          options = args.dup.extract_options!
           Instrumenter.start_processing(method_name, options)
 
           Instrumenter.complete_processing(method_name, options) do
-            do_request =
-                Proc.new {Instrumenter.perform_request(method_name, options) {options.empty? ? super(*args) : super(*args, options)}}
 
-            if Utils.cache_disabled?(options)
-              do_request.call
-            else
-              user = (method_name == :friendship?) ? args[0, 2] : args[0]
-              key = CacheKey.gen(method_name, user, options.merge(hash: credentials_hash))
-              @cache.fetch(key, args: [method_name, options], &do_request)
+            key = CacheKey.gen(method_name, args, hash: credentials_hash)
+            @cache.fetch(key, args: [method_name, options]) do
+              Instrumenter.perform_request(method_name, options) {super(*args)}
             end
           end
         end
@@ -31,12 +27,10 @@ module TwitterFriendly
     def logging(*root_args)
       root_args.each do |method_name|
         define_method(method_name) do |*args|
-          options = args.extract_options!
+          options = args.dup.extract_options!
           Instrumenter.start_processing(method_name, options)
 
-          Instrumenter.complete_processing(method_name, options) do
-            options.empty? ? super(*args) : super(*args, options)
-          end
+          Instrumenter.complete_processing(method_name, options) {super(*args)}
         end
       end
     end
@@ -60,14 +54,5 @@ module TwitterFriendly
         ::ActiveSupport::Notifications.instrument('request.twitter_friendly', payload) { yield(payload) }
       end
     end
-
-    module Utils
-
-      module_function
-
-      def cache_disabled?(options)
-        options.is_a?(Hash) && options.has_key?(:cache) && !options[:cache]
-      end
-    end
   end
 end

data/lib/twitter_friendly/client.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 
 require 'twitter_friendly/caching_and_logging'
+require 'twitter_friendly/caching'
 require 'twitter_friendly/rest/api'
 require 'twitter_friendly/utils'
 
@@ -15,8 +16,13 @@ module TwitterFriendly
 
     extend TwitterFriendly::CachingAndLogging
     caching :user, :friendship?, :verify_credentials, :user?, :blocked_ids
-    logging :favorites, :friend_ids, :follower_ids, :friends, :followers, :friend_ids_and_follower_ids, :friends_and_followers,
-            :home_timeline, :user_timeline, :mentions_timeline, :search, :memberships, :list_members, :retweeters_ids
+    logging :friends, :followers, :friend_ids_and_follower_ids, :friends_and_followers, :retweeters_ids
+
+
+    extend TwitterFriendly::Caching
+    caching_users
+    caching_tweets_with_max_id :home_timeline, :user_timeline, :mentions_timeline, :favorites, :search
+    caching_resources_with_cursor :friend_ids, :follower_ids, :memberships, :list_members
 
     def initialize(*args)
       options = args.extract_options!
@@ -49,6 +55,11 @@ module TwitterFriendly
       @twitter
     end
 
+    def twitter
+      logger.warn "DEPRECATION WARNING: Use #internal_client instead of #twitter"
+      internal_client
+    end
+
     def subscriber_attached?
       @@subscriber_attached ||= false
     end

data/lib/twitter_friendly/log_subscriber.rb

@@ -14,19 +14,13 @@ module TwitterFriendly
       {args: args}.merge(payload.except(:args)).inspect
     end
 
-    INDENT = '  '
-
-    def indentation(payload)
-      sp = payload[:super_operation]&.is_a?(Array) ? (INDENT * payload[:super_operation].size) : ''
-      sp + (payload[:name] == 'write' ? INDENT : '')
-    end
-
     module_function
 
     def logger
       @@logger
     end
 
+    # Because TwitterFriendly::Logging is not inherited, passing an instance of logger via module function.
     def logger=(logger)
       @@logger = logger
     end
@@ -38,7 +32,7 @@ module TwitterFriendly
     def start_processing(event)
       debug do
         payload = event.payload
-        name = "#{indentation(payload)}TF::Started #{payload[:operation]}"
+        name = "TF::Started #{payload[:operation]}"
 
         if payload[:super_operation]
           "#{name} in #{payload[:super_operation][0]} at #{Time.now}"
@@ -53,7 +47,7 @@ module TwitterFriendly
         payload = event.payload
         name = "TF::Completed #{payload[:operation]} in #{event.duration.round(1)}ms"
 
-        "#{indentation(payload)}#{name}#{" #{truncated_payload(payload)}" unless payload.empty?}"
+        "#{name}#{" #{truncated_payload(payload)}" unless payload.empty?}"
       end
     end
 
@@ -62,9 +56,9 @@ module TwitterFriendly
         payload = event.payload
         payload.delete(:name)
         operation = payload.delete(:operation)
-        name = "  TW::#{operation.capitalize} #{payload[:args].last[:super_operation][0]} in #{payload[:args][0]} (#{event.duration.round(1)}ms)"
+        name = "  TW::#{operation.capitalize} #{payload[:args].last[:super_operation]} in #{payload[:args][0]} (#{event.duration.round(1)}ms)"
         name = color(name, BLUE, true)
-        "  #{indentation(payload)}#{name}#{" #{payload[:args][1]}" unless payload.empty?}"
+        "  #{name}"
       end
     end
 
@@ -73,10 +67,10 @@ module TwitterFriendly
         payload = event.payload
         payload.delete(:name)
         operation = payload.delete(:operation)
-        name = "  TW::#{operation.capitalize} #{payload[:args][0]} (#{event.duration.round(1)}ms)"
+        name = "  TW::#{operation.capitalize} #{payload[:args][0] if payload[:args]&.is_a?(Array)} (#{event.duration.round(1)}ms)"
         c = (%i(encode decode).include?(operation.to_sym)) ? YELLOW : CYAN
         name = color(name, c, true)
-        "  #{indentation(payload)}#{name}#{" #{payload[:args][1]}" unless payload.empty?}"
+        "  #{name}#{" #{payload[:args][1] if payload[:args]&.is_a?(Array)}" unless payload.empty?}"
       end
     end
 
@@ -98,10 +92,10 @@ module TwitterFriendly
         payload = event.payload
         operation = payload[:super_operation] == :fetch ? :fetch : payload[:name]
         hit = %i(read fetch).include?(operation.to_sym) && payload[:hit] ? ' (Hit)' : ''
-        name = "  AS::#{operation.capitalize}#{hit} #{payload[:key].split(':')[1]} (#{event.duration.round(1)}ms)"
+        name = "  AS::#{operation.capitalize}#{hit} #{payload[:key].split('__')[1]} (#{event.duration.round(1)}ms)"
         name = color(name, MAGENTA, true)
         # :name, :expires_in, :super_operation, :hit, :race_condition_ttl, :tf_super_operation, :tf_super_super_operation
-        "#{indentation(payload)}#{name} #{(payload.slice(:key).inspect)}"
+        "#{name} #{(payload.slice(:key).inspect)}"
       end
     end
 

data/lib/twitter_friendly/logger.rb

@@ -5,7 +5,7 @@ require 'logger'
 module TwitterFriendly
   class Logger
     extend Forwardable
-    def_delegators :@logger, :debug, :info, :warn, :level
+    def_delegators :@logger, :debug, :info, :warn, :error, :fatal, :level
 
     def initialize(options = {})
       path = options[:log_dir] || File.join('.twitter_friendly')
@@ -15,4 +15,4 @@ module TwitterFriendly
       @logger.level = options[:log_level] || :debug
     end
   end
-end
+end

data/lib/twitter_friendly/rest/api.rb

@@ -1,7 +1,6 @@
 require 'twitter_friendly/rest/utils'
 require 'twitter_friendly/rest/collector'
 require "twitter_friendly/rest/parallel"
-require "twitter_friendly/rest/base"
 require 'twitter_friendly/rest/friends_and_followers'
 require 'twitter_friendly/rest/users'
 require 'twitter_friendly/rest/timelines'
@@ -20,7 +19,6 @@ module TwitterFriendly
       include TwitterFriendly::REST::Utils
       include TwitterFriendly::REST::Collector
       include TwitterFriendly::REST::Parallel
-      include TwitterFriendly::REST::Base
       include TwitterFriendly::REST::FriendsAndFollowers
       include TwitterFriendly::REST::Users
       include TwitterFriendly::REST::Timelines
@@ -31,9 +29,6 @@ module TwitterFriendly
 
       include TwitterFriendly::REST::Extension::Clusters
       include TwitterFriendly::REST::Extension::Timelines
-
-      include TwitterFriendly::REST::Collector::Caching
-      include TwitterFriendly::REST::Users::Caching
     end
   end
 end

data/lib/twitter_friendly/rest/collector.rb

@@ -1,22 +1,52 @@
 module TwitterFriendly
   module REST
     module Collector
-      def collect_with_max_id(user, collection, max_id, options, collect_options, &block)
-        key = CacheKey.gen(__method__, user, options.merge(max_id: max_id, hash: credentials_hash, super_operation: collect_options[:super_operation]))
+      def fetch_tweets_with_max_id(method_name, max_count, *args)
+        options = args.dup.extract_options!
 
-          # TODO Handle {cache: false} option
-        tweets =
-            @cache.fetch(key, args: [__method__, options]) do
-              Instrumenter.perform_request(__method__, options) {yield(max_id)}
+        total_count = options.delete(:count) || max_count
+        call_count = total_count / max_count + (total_count % max_count == 0 ? 0 : 1)
+        options[:count] = [max_count, total_count].min
+        collect_options = {call_count: call_count, total_count: total_count}
+
+        collect_with_max_id([], nil, collect_options) do |max_id|
+          options[:max_id] = max_id unless max_id.nil?
+          result = send(method_name, *args)
+
+          if method_name == :search
+            result.attrs[:statuses]
+          else
+            if result.is_a?(Array) && result[0].respond_to?(:attrs)
+              result.map(&:attrs)
+            else
+              result
             end
+          end
+        end
+      end
+
+      # @param method_name [Symbol]
+      # @param user [Integer, String, nil]
+      #
+      # @option options [Integer] :count
+      def fetch_resources_with_cursor(method_name, *args)
+        options = args.dup.extract_options!
+
+        collect_with_cursor([], -1) do |next_cursor|
+          options[:cursor] = next_cursor unless next_cursor.nil?
+          send(method_name, *args)
+        end
+      end
+
+      def collect_with_max_id(collection, max_id, collect_options, &block)
+        tweets = yield(max_id)
         return collection if tweets.nil?
 
         collection.concat tweets
         if tweets.empty? || (collect_options[:call_count] -= 1) < 1
           collection.flatten
         else
-          options[:recursive] = true
-          collect_with_max_id(user, collection, tweets.last[:id] - 1, options, collect_options, &block)
+          collect_with_max_id(collection, tweets.last[:id] - 1, collect_options, &block)
         end
       end
 
@@ -25,55 +55,13 @@ module TwitterFriendly
       # @param cursor [Integer]
       #
       # @option options [Integer] :count
-      # @option options [String] :super_operation
-      # @option options [String] :super_super_operation
-      def collect_with_cursor(user, collection, cursor, options, &block)
-        key = CacheKey.gen(__method__, user, options.merge(cursor: cursor, hash: credentials_hash))
-
-        # TODO Handle {cache: false} option
-        response =
-            @cache.fetch(key, args: [__method__, options]) do
-              Instrumenter.perform_request(__method__, options) {yield(cursor).attrs}
-            end
+      def collect_with_cursor(collection, cursor, &block)
+        response = yield(cursor)
         return collection if response.nil?
 
-        options[:recursive] = true
-
         # Notice: If you call response.to_a, it automatically fetch all results and the results are not cached.
         collection.concat (response[:ids] || response[:users] || response[:lists])
-        response[:next_cursor].zero? ? collection.flatten : collect_with_cursor(user, collection, response[:next_cursor], options, &block)
-      end
-
-      module Instrumenter
-
-        module_function
-
-        # 他のメソッドと違い再帰的に呼ばれるため、全体をキャッシュすると、すべてを再帰的にキャッシュしてしまう。
-        # それを防ぐために、特別にここでキャッシュの処理を登録している。
-
-        def perform_request(method_name, options, &block)
-          payload = {operation: 'collect', args: [method_name, options.slice(:max_id, :cursor, :super_operation)]}
-          ::ActiveSupport::Notifications.instrument('collect.twitter_friendly', payload) { yield(payload) }
-        end
-      end
-
-      module Caching
-        %i(
-          collect_with_max_id
-          collect_with_cursor
-        ).each do |name|
-          define_method(name) do |*args, &block|
-            options = args.extract_options!
-            do_request = Proc.new { options.empty? ? super(*args, &block) : super(*args, options, &block) }
-
-            if options[:recursive]
-              do_request.call
-            else
-              TwitterFriendly::CachingAndLogging::Instrumenter.start_processing(name, options)
-              TwitterFriendly::CachingAndLogging::Instrumenter.complete_processing(name, options, &do_request)
-            end
-          end
-        end
+        response[:next_cursor].zero? ? collection.flatten : collect_with_cursor(collection, response[:next_cursor], &block)
       end
     end
   end

data/lib/twitter_friendly/rest/favorites.rb

@@ -5,9 +5,14 @@ module TwitterFriendly
       MAX_TWEETS_PER_REQUEST = 100
 
       def favorites(*args)
-        options = {result_type: :recent}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, args[0], options)
+        options = {count: MAX_TWEETS_PER_REQUEST}.merge(args.extract_options!)
+        args << options
+
+        if options[:count] <= MAX_TWEETS_PER_REQUEST
+          @twitter.favorites(*args)&.map(&:attrs)
+        else
+          fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, *args)
+        end
       end
     end
   end

data/lib/twitter_friendly/rest/friends_and_followers.rb

@@ -1,3 +1,5 @@
+require 'parallel'
+
 module TwitterFriendly
   module REST
     module FriendsAndFollowers
@@ -17,14 +19,24 @@ module TwitterFriendly
       # @option options [Integer] :count The number of tweets to return per page, up to a maximum of 5000.
       def friend_ids(*args)
         options = {count: MAX_IDS_PER_REQUEST}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_resources_with_cursor(__method__, args[0], options)
+        args << options
+
+        if options.has_key?(:cursor)
+          @twitter.friend_ids(*args)&.attrs
+        else
+          fetch_resources_with_cursor(__method__, *args)
+        end
       end
 
       def follower_ids(*args)
         options = {count: MAX_IDS_PER_REQUEST}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_resources_with_cursor(__method__, args[0], options)
+        args << options
+
+        if options.has_key?(:cursor)
+          @twitter.follower_ids(*args)&.attrs
+        else
+          fetch_resources_with_cursor(__method__, *args)
+        end
       end
 
       # @return [Hash]
@@ -36,47 +48,26 @@ module TwitterFriendly
       #
       # @option options [Bool] :parallel
       def friends(*args)
-        options = {parallel: true}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        ids = friend_ids(*args, options.except(:parallel))
-        users(ids, options)
+        ids = friend_ids(*args)
+        users(ids)
       end
 
       def followers(*args)
-        options = {parallel: true}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        ids = follower_ids(*args, options.except(:parallel))
-        users(ids, options)
+        ids = follower_ids(*args)
+        users(ids)
       end
 
       def friend_ids_and_follower_ids(*args)
-        options = { parallel: true}.merge(args.extract_options!)
-        is_parallel = options.delete(:parallel)
-
-        if is_parallel
-          require 'parallel'
-
-          parallel(in_threads: 2) do |batch|
-            batch.friend_ids(*args, options.merge(super_operation: [__method__]))
-            batch.follower_ids(*args, options.merge(super_operation: [__method__]))
-          end
-        else
-          [friend_ids(*args, options), follower_ids(*args, options)]
+        parallel(in_threads: 2) do |batch|
+          batch.friend_ids(*args)
+          batch.follower_ids(*args)
         end
       end
 
       def friends_and_followers(*args)
-        options = args.extract_options!.merge(super_operation: :friends_and_followers)
-
-        following_ids, followed_ids = friend_ids_and_follower_ids(*args, options)
-        unique_ids = (following_ids + followed_ids).uniq
-        people = _users(unique_ids).index_by { |u| u[:id] }
+        following_ids, followed_ids = friend_ids_and_follower_ids(*args)
+        people = users((following_ids + followed_ids).uniq).index_by { |u| u[:id] }
         [people.slice(*following_ids).values, people.slice(*followed_ids).values]
-
-        # parallel(in_threads: 2) do |batch|
-        #   batch.friends(*args, options)
-        #   batch.followers(*args, options)
-        # end
       end
     end
   end

data/lib/twitter_friendly/rest/lists.rb

@@ -2,6 +2,10 @@ module TwitterFriendly
   module REST
     module Lists
 
+      def list(*args)
+        @twitter.list(*args)&.to_hash
+      end
+
       MAX_LISTS_PER_REQUEST = 1000
 
       # @return [Hash] The lists the specified user has been added to.
@@ -14,8 +18,13 @@ module TwitterFriendly
       # @option options [Integer] :count The number of tweets to return per page, up to a maximum of 5000.
       def memberships(*args)
         options = {count: MAX_LISTS_PER_REQUEST}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_resources_with_cursor(__method__, args[0], options)
+        args << options
+
+        if options.has_key?(:cursor)
+          @twitter.memberships(*args)&.attrs
+        else
+          fetch_resources_with_cursor(__method__, *args)
+        end
       end
 
       MAX_MEMBERS_PER_REQUEST = 5000
@@ -30,8 +39,13 @@ module TwitterFriendly
       # @option options [Integer] :count The number of tweets to return per page, up to a maximum of 5000.
       def list_members(*args)
         options = {count: MAX_MEMBERS_PER_REQUEST, skip_status: 1}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_resources_with_cursor(__method__, args[0], options)
+        args << options
+
+        if options.has_key?(:cursor)
+          @twitter.list_members(*args)&.attrs
+        else
+          fetch_resources_with_cursor(__method__, *args)
+        end
       end
     end
   end

data/lib/twitter_friendly/rest/search.rb

@@ -6,9 +6,13 @@ module TwitterFriendly
 
       def search(query, options = {})
         raise ArgumentError.new('You must specify a search query.') unless query.is_a?(String)
-        options = {result_type: :recent}.merge(options)
-        push_operations(options, __method__)
-        fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, query, options)
+        options = {result_type: 'recent'}.merge(options)
+
+        if options[:count] <= MAX_TWEETS_PER_REQUEST
+          @twitter.search(query, options)&.attrs&.fetch(:statuses)
+        else
+          fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, query, options)
+        end
       end
     end
   end

data/lib/twitter_friendly/rest/timelines.rb

@@ -5,21 +5,31 @@ module TwitterFriendly
       MAX_TWEETS_PER_REQUEST = 200
 
       def home_timeline(options = {})
-        options = {include_rts: true}.merge(options)
-        push_operations(options, __method__)
-        fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, nil, options)
+        options = {include_rts: true, count: MAX_TWEETS_PER_REQUEST}.merge(options)
+        if options[:count] <= MAX_TWEETS_PER_REQUEST
+          @twitter.home_timeline(options)&.map(&:attrs)
+        else
+          fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, options)
+        end
       end
 
       def user_timeline(*args)
-        options = {include_rts: true}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, args[0], options)
+        options = {include_rts: true, count: MAX_TWEETS_PER_REQUEST}.merge(args.extract_options!)
+        args << options
+        if options[:count] <= MAX_TWEETS_PER_REQUEST
+          @twitter.user_timeline(*args)&.map(&:attrs)
+        else
+          fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, *args)
+        end
       end
 
       def mentions_timeline(options = {})
-        options = {include_rts: true}.merge(options)
-        push_operations(options, __method__)
-        fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, nil, options)
+        options = {include_rts: true, count: MAX_TWEETS_PER_REQUEST}.merge(options)
+        if options[:count] <= MAX_TWEETS_PER_REQUEST
+          @twitter.mentions_timeline(options)&.map(&:attrs)
+        else
+          fetch_tweets_with_max_id(__method__, MAX_TWEETS_PER_REQUEST, options)
+        end
       end
     end
   end

data/lib/twitter_friendly/rest/tweets.rb

@@ -14,8 +14,8 @@ module TwitterFriendly
       def retweeters_ids(*args)
         # このメソッドではページングができない
         options = {count: MAX_IDS_PER_REQUEST}.merge(args.extract_options!)
-        push_operations(options, __method__)
-        fetch_resources_with_cursor(__method__, args[0], options)
+        args << options
+        @twitter.retweeters_ids(*args)
       end
     end
   end

data/lib/twitter_friendly/rest/users.rb

@@ -1,3 +1,5 @@
+require 'parallel'
+
 module TwitterFriendly
   module REST
     module Users
@@ -5,8 +7,8 @@ module TwitterFriendly
         @twitter.verify_credentials({skip_status: true}.merge(options))&.to_hash
       end
 
-      def user?(user, options = {})
-        @twitter.user?(user, options)
+      def user?(*args)
+        @twitter.user?(*args)
       end
 
       def user(*args)
@@ -17,71 +19,17 @@ module TwitterFriendly
 
       def users(values, options = {})
         if values.size <= MAX_USERS_PER_REQUEST
-          key = CacheKey.gen(__method__, values, options.merge(hash: credentials_hash))
-
-          @cache.fetch(key, args: [__method__, options]) do
-            Instrumenter.perform_request(args: [__method__, super_operation: options[:super_operation]]) do
-              @twitter.send(__method__, values, options.except(:parallel, :super_operation, :recursive))&.compact&.map(&:to_hash)
-            end
-          end
+          @twitter.users(values, options)
         else
-          options[:recursive] = true
-          _users(values, options)
+          parallel(in_threads: 10) do |batch|
+            values.each_slice(MAX_USERS_PER_REQUEST) { |targets| batch.users(targets, options) }
+          end.flatten
         end
       end
 
       def blocked_ids(*args)
         @twitter.blocked_ids(*args)&.attrs&.fetch(:ids)
       end
-
-      module Instrumenter
-
-        module_function
-
-        # 他のメソッドと違い再帰的に呼ばれるため、全体をキャッシュすると、すべてを再帰的にキャッシュしてしまう。
-        # それを防ぐために、特別にここでキャッシュの処理を登録している。
-
-        def perform_request(options, &block)
-          payload = {operation: 'request', args: options[:args]}
-          ::ActiveSupport::Notifications.instrument('request.twitter_friendly', payload) { yield(payload) }
-        end
-      end
-
-      module Caching
-        %i(
-          users
-        ).each do |name|
-          define_method(name) do |*args, &block|
-            options = args.extract_options!
-            do_request = Proc.new { options.empty? ? super(*args, &block) : super(*args, options, &block) }
-
-            if options[:recursive]
-              do_request.call
-            else
-              TwitterFriendly::CachingAndLogging::Instrumenter.start_processing(name, options)
-              TwitterFriendly::CachingAndLogging::Instrumenter.complete_processing(name, options, &do_request)
-            end
-          end
-        end
-      end
-
-      private
-
-      def _users(values, options = {})
-        options = {super_operation: :users, parallel: true}.merge(options)
-
-        if options[:parallel]
-          require 'parallel'
-
-          parallel(in_threads: 10) do |batch|
-            values.each_slice(MAX_USERS_PER_REQUEST) { |targets| batch.users(targets, options) }
-          end.flatten
-        else
-          values.each_slice(MAX_USERS_PER_REQUEST).map do |targets|
-            users(targets, options)
-          end
-        end&.flatten&.compact&.map(&:to_hash)
-      end
     end
   end
 end

data/lib/twitter_friendly/rest/utils.rb

@@ -6,12 +6,6 @@ module TwitterFriendly
       def credentials_hash
         Digest::MD5.hexdigest(access_token + access_token_secret + consumer_key + consumer_secret)
       end
-
-      def push_operations(options, operation)
-        options[:super_operation] = [] unless options[:super_operation]
-        options[:super_operation] = [options[:super_operation]] unless options[:super_operation].is_a?(Array)
-        options[:super_operation].prepend operation
-      end
     end
   end
 end

data/lib/twitter_friendly/version.rb

@@ -1,3 +1,3 @@
 module TwitterFriendly
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twitter_friendly
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - ts-3156
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-10 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -180,13 +180,13 @@ files:
 - lib/twitter_friendly.rb
 - lib/twitter_friendly/cache.rb
 - lib/twitter_friendly/cache_key.rb
+- lib/twitter_friendly/caching.rb
 - lib/twitter_friendly/caching_and_logging.rb
 - lib/twitter_friendly/client.rb
 - lib/twitter_friendly/log_subscriber.rb
 - lib/twitter_friendly/logger.rb
 - lib/twitter_friendly/rate_limit.rb
 - lib/twitter_friendly/rest/api.rb
-- lib/twitter_friendly/rest/base.rb
 - lib/twitter_friendly/rest/collector.rb
 - lib/twitter_friendly/rest/extension/clusters.rb
 - lib/twitter_friendly/rest/extension/timelines.rb

data/lib/twitter_friendly/rest/base.rb

@@ -1,32 +0,0 @@
-module TwitterFriendly
-  module REST
-    module Base
-      def fetch_tweets_with_max_id(method_name, max_count, user, options)
-        total_count = options.delete(:count) || max_count
-        call_count = total_count / max_count + (total_count % max_count == 0 ? 0 : 1)
-        options[:count] = [max_count, total_count].min
-        super_operation = options.delete(:super_operation)
-        collect_options = {call_count: call_count, total_count: total_count, super_operation: super_operation}
-
-        collect_with_max_id(user, [], nil, options, collect_options) do |max_id|
-          options[:max_id] = max_id unless max_id.nil?
-
-          result = @twitter.send(method_name, *[user, options].compact)
-          (method_name == :search) ? result.attrs[:statuses] : result.map(&:attrs)
-        end
-      end
-
-      # @param method_name [Symbol]
-      # @param user [Integer, String, nil]
-      #
-      # @option options [Integer] :count
-      # @option options [String] :super_super_operation
-      def fetch_resources_with_cursor(method_name, user, options)
-        collect_with_cursor(user, [], -1, options) do |next_cursor|
-          options[:cursor] = next_cursor unless next_cursor.nil?
-          @twitter.send(method_name, user, options.except(:super_operation))
-        end
-      end
-    end
-  end
-end