twitter_friendly 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e5481574a9af954eee677e12ab10be1cd29bd3e744c00f295792aa59b7dec18
-  data.tar.gz: '078c67dafe0a4c76418d178abb1c8da2b79323790353fc47adf254ed7866e795'
+  metadata.gz: bd3aedc3bbfeb41ae92a95b3ca8a4a654c03d1332540396d85ff883871456f8d
+  data.tar.gz: 2554445ef8a39dce0be467d006f9f1fea19aa6ce265a0612e71350f27aca3007
 SHA512:
-  metadata.gz: 142be53e34255b50211248e835bdec011fe68cd7ffede00929a762228ffb854de53616f4ad5875d23e77283d2d1ece8a890f3dc3f83c86e71e907bacd52163cc
-  data.tar.gz: 8734fe7505f898ce41ab563774e515baee99d7fc8fef2ff42803d575d8d74d03267a7f2468ffa7e691015040d38779b7e23254c814523caf5eb71b3c2c4312c0
+  metadata.gz: 69ce0e002321247a430df087a6efad1868c5fd7397c86940f8c4bf9043e089c8d7077acda3699926d29b8b69d9b24cc511313e072f515e2897c62cbdc6df3927
+  data.tar.gz: a2b958451a785d063b23becc9bde00c3fb52c89f25e646a95b4c98126c2969771ad3a8b7fed3ee80e64cc8618ba0f1f99dd3fdd9121f01c3f1075071e564789a

data/Gemfile.lock

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

data/lib/twitter_friendly/cache.rb

@@ -14,33 +14,30 @@ module TwitterFriendly
       @client = ::ActiveSupport::Cache::FileStore.new(path, options)
     end
 
-    def fetch(method, user, options = {}, &block)
-      key = CacheKey.gen(method, user, options.except(:args))
-      super_operation = options[:args].length >= 2 && options[:args][1][:super_operation]
-
+    # @param key [String]
+    #
+    # @option serialize_options [Array] :args
+    def fetch(key, serialize_options, &block)
       block_result = nil
-      blk =
+      yield_and_encode =
           Proc.new do
             block_result = yield
-            encode(block_result, args: options[:args])
+            encode(block_result, serialize_options)
           end
 
-      fetch_result =
-        if super_operation
-          @client.fetch(key, tf_super_operation: super_operation, &blk)
-        else
-          @client.fetch(key, &blk)
-        end
+      fetch_result = @client.fetch(key, &yield_and_encode)
 
-      block_result ? block_result : decode(fetch_result, args: options[:args])
+      block_result || decode(fetch_result, serialize_options)
     end
 
     private
 
+    # @option options [Array] :args
     def encode(obj, options)
       Serializer.encode(obj, options)
     end
 
+    # @option options [Array] :args
     def decode(str, options)
       Serializer.decode(str, options)
     end

data/lib/twitter_friendly/cache_key.rb

@@ -25,8 +25,8 @@ module TwitterFriendly
           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(options[:super_operation], user, options)
-          when method == :collect_with_cursor       then method_identifier(options[:super_operation], user, options)
+          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
@@ -46,7 +46,7 @@ module TwitterFriendly
       def options_identifier(method, options)
         # TODO 内部的な値はすべてprefix _tf_ をつける
         opt = options.except(:hash, :call_count, :call_limit, :super_operation, :super_super_operation, :recursive, :parallel)
-        opt[:in] = options[:super_operation] if %i(collect_with_max_id collect_with_cursor).include?(method)
+        opt[:in] = extract_super_operation(options) if %i(collect_with_max_id collect_with_cursor).include?(method)
 
         if opt.empty?
           nil
@@ -56,6 +56,15 @@ module TwitterFriendly
         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_and_logging.rb

@@ -0,0 +1,73 @@
+module TwitterFriendly
+  module CachingAndLogging
+
+    module_function
+
+    # TODO 1つのメソッドに対して1回しか実行されないようにする
+    # 全体をキャッシュさせ、さらにロギングを行う
+    def caching(*root_args)
+      root_args.each do |method_name|
+        define_method(method_name) do |*args|
+          options = args.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)
+            end
+          end
+        end
+      end
+    end
+
+    # 全体をキャッシュせずにロギングだけを行う
+    def logging(*root_args)
+      root_args.each do |method_name|
+        define_method(method_name) do |*args|
+          options = args.extract_options!
+          Instrumenter.start_processing(method_name, options)
+
+          Instrumenter.complete_processing(method_name, options) do
+            options.empty? ? super(*args) : super(*args, options)
+          end
+        end
+      end
+    end
+
+    module Instrumenter
+
+      module_function
+
+      def start_processing(operation, options)
+        payload = {operation: operation}.merge(options)
+        ::ActiveSupport::Notifications.instrument('start_processing.twitter_friendly', payload) {}
+      end
+
+      def complete_processing(operation, options)
+        payload = {operation: operation}.merge(options)
+        ::ActiveSupport::Notifications.instrument('complete_processing.twitter_friendly', payload) { yield(payload) }
+      end
+
+      def perform_request(caller, options, &block)
+        payload = {operation: 'request', args: [caller, options]}
+        ::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,17 +1,29 @@
 require 'forwardable'
 
+require 'twitter_friendly/caching_and_logging'
 require 'twitter_friendly/rest/api'
+require 'twitter_friendly/utils'
 
 module TwitterFriendly
   class Client
     extend Forwardable
     def_delegators :@twitter, :access_token, :access_token_secret, :consumer_key, :consumer_secret
 
+    include TwitterFriendly::Utils
     include TwitterFriendly::REST::API
     include TwitterFriendly::RateLimit
 
+    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
+
     def initialize(*args)
       options = args.extract_options!
+      @twitter = Twitter::REST::Client.new(options.slice(:access_token, :access_token_secret, :consumer_key, :consumer_secret))
+
+      options.except!(:access_token, :access_token_secret, :consumer_key, :consumer_secret)
+      @cache = TwitterFriendly::Cache.new(options)
 
       @logger = TwitterFriendly::Logger.new(options)
 
@@ -23,9 +35,6 @@ module TwitterFriendly
           TwitterFriendly::ASLogSubscriber.attach_to :active_support
         end
       end
-
-      @cache = TwitterFriendly::Cache.new(options)
-      @twitter = Twitter::REST::Client.new(options)
     end
 
     def cache

data/lib/twitter_friendly/log_subscriber.rb

@@ -14,8 +14,11 @@ module TwitterFriendly
       {args: args}.merge(payload.except(:args)).inspect
     end
 
-    def nested_indent(payload)
-      (payload[:super_operation] ? '  ' : '') + (payload[:super_super_operation] ? '  ' : '') + (payload[:tf_super_operation] ? '  ' : '')
+    INDENT = '  '
+
+    def indentation(payload)
+      sp = payload[:super_operation]&.is_a?(Array) ? (INDENT * payload[:super_operation].size) : ''
+      sp + (payload[:name] == 'write' ? INDENT : '')
     end
 
     module_function
@@ -33,11 +36,12 @@ module TwitterFriendly
     include Logging
 
     def start_processing(event)
-      payload = event.payload
-      name = "#{nested_indent(payload)}TF::Started #{payload.delete(:operation)}"
       debug do
+        payload = event.payload
+        name = "#{indentation(payload)}TF::Started #{payload[:operation]}"
+
         if payload[:super_operation]
-          "#{name} in #{payload[:super_operation]} at #{Time.now}"
+          "#{name} in #{payload[:super_operation][0]} at #{Time.now}"
         else
           "#{name} at #{Time.now}"
         end
@@ -45,36 +49,38 @@ module TwitterFriendly
     end
 
     def complete_processing(event)
-      payload = event.payload
-      name = "TF::Completed #{payload.delete(:operation)} in #{event.duration.round(1)}ms"
       debug do
-        "#{nested_indent(payload)}#{name}#{" #{truncated_payload(payload)}" unless payload.empty?}"
+        payload = event.payload
+        name = "TF::Completed #{payload[:operation]} in #{event.duration.round(1)}ms"
+
+        "#{indentation(payload)}#{name}#{" #{truncated_payload(payload)}" unless payload.empty?}"
+      end
+    end
+
+    def collect(event)
+      debug do
+        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 = color(name, BLUE, true)
+        "  #{indentation(payload)}#{name}#{" #{payload[:args][1]}" unless payload.empty?}"
       end
     end
 
     def twitter_friendly_any(event)
-      payload = event.payload
-      payload.delete(:name)
-      operation = payload.delete(:operation)
-      name =
-          if operation.to_sym == :collect
-            "  TW::#{operation.capitalize} #{payload[:args].last[:super_operation]} in #{payload[:args][0]} (#{event.duration.round(1)}ms)"
-          else
-            "  TW::#{operation.capitalize} #{payload[:args][0]} (#{event.duration.round(1)}ms)"
-          end
-      c =
-          if %i(encode decode).include?(operation.to_sym)
-            YELLOW
-          elsif %i(collect).include?(operation.to_sym)
-            BLUE
-          else
-            CYAN
-          end
-      name = color(name, c, true)
-      debug { "  #{nested_indent(payload)}#{name}#{" #{truncated_payload(payload)}" unless payload.empty?}" }
+      debug do
+        payload = event.payload
+        payload.delete(:name)
+        operation = payload.delete(:operation)
+        name = "  TW::#{operation.capitalize} #{payload[:args][0]} (#{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?}"
+      end
     end
 
-    %w(request encode decode collect).each do |operation|
+    %w(request encode decode).each do |operation|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{operation}(event)
           event.payload[:name] = '#{operation}'
@@ -88,12 +94,15 @@ module TwitterFriendly
     include Logging
 
     def cache_any(event)
-      payload = event.payload
-      operation = payload[:super_operation] == :fetch ? :fetch : payload[:name]
-      hit = %i(read fetch).include?(operation.to_sym) && payload[:hit]
-      name = "  AS::#{operation.capitalize}#{' (Hit)' if hit} #{payload[:key].split(':')[1]} (#{event.duration.round(1)}ms)"
-      name = color(name, MAGENTA, true)
-      debug { "#{nested_indent(payload)}#{name} #{(payload.except(:name, :expires_in, :super_operation, :hit, :race_condition_ttl, :tf_super_operation).inspect)}" }
+      debug do
+        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 = 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)}"
+      end
     end
 
     # Ignore generate and fetch_hit

data/lib/twitter_friendly/rest/api.rb

@@ -10,7 +10,9 @@ require 'twitter_friendly/rest/favorites'
 require 'twitter_friendly/rest/lists'
 require 'twitter_friendly/rest/tweets'
 
-require 'twitter_friendly/caching'
+# 後方互換性のために残した
+require 'twitter_friendly/rest/extension/clusters'
+require 'twitter_friendly/rest/extension/timelines'
 
 module TwitterFriendly
   module REST
@@ -27,8 +29,11 @@ module TwitterFriendly
       include TwitterFriendly::REST::Lists
       include TwitterFriendly::REST::Tweets
 
-      include TwitterFriendly::Caching
+      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/base.rb

@@ -1,30 +1,30 @@
 module TwitterFriendly
   module REST
     module Base
-      def fetch_tweets_with_max_id(name, args, max_count)
-        options = args.extract_options!
+      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
+        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(args[0], [], nil, {super_operation: name}.merge(options)) do |max_id|
+        collect_with_max_id(user, [], nil, options, collect_options) do |max_id|
           options[:max_id] = max_id unless max_id.nil?
-          if (call_count -= 1) >= 0
-            if name == :search
-              @twitter.send(name, *args, options).attrs[:statuses]
-            else
-              @twitter.send(name, *args, options).map(&:attrs)
-            end
-          end
+
+          result = @twitter.send(method_name, *[user, options].compact)
+          (method_name == :search) ? result.attrs[:statuses] : result.map(&:attrs)
         end
       end
 
-      def fetch_resources_with_cursor(name, args)
-        options = args.extract_options!
-
-        collect_with_cursor(args[0], [], -1, {super_operation: name}.merge(options)) do |next_cursor|
+      # @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(name, *args, options)
+          @twitter.send(method_name, user, options.except(:super_operation))
         end
       end
     end

data/lib/twitter_friendly/rest/collector.rb

@@ -1,37 +1,39 @@
 module TwitterFriendly
   module REST
     module Collector
-      def collect_with_max_id(user, collection, max_id, options, &block)
-        fetch_options = options.dup
-        fetch_options[:max_id] = max_id
-        fetch_options.merge!(args: [__method__, fetch_options], hash: credentials_hash)
+      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]))
 
-        # TODO Handle {cache: false} option
+          # TODO Handle {cache: false} option
         tweets =
-            @cache.fetch(__method__, user, fetch_options) do
-              Instrumenter.perform_request(args: [__method__, max_id: max_id, super_operation: options[:super_operation]]) do
-                yield(max_id)
-              end
+            @cache.fetch(key, args: [__method__, options]) do
+              Instrumenter.perform_request(__method__, options) {yield(max_id)}
             end
         return collection if tweets.nil?
 
-        options[:recursive] = true
-
         collection.concat tweets
-        tweets.empty? ? collection.flatten : collect_with_max_id(user, collection, tweets.last[:id] - 1, options, &block)
+        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)
+        end
       end
 
+      # @param user [Integer, String, nil]
+      # @param collection [Array]
+      # @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)
-        fetch_options = options.dup
-        fetch_options[:cursor] = cursor
-        fetch_options.merge!(args: [__method__, fetch_options], hash: credentials_hash)
+        key = CacheKey.gen(__method__, user, options.merge(cursor: cursor, hash: credentials_hash))
 
         # TODO Handle {cache: false} option
         response =
-            @cache.fetch(__method__, user, fetch_options) do
-              Instrumenter.perform_request(args: [__method__, cursor: cursor, super_operation: options[:super_operation]]) do
-                yield(cursor).attrs
-              end
+            @cache.fetch(key, args: [__method__, options]) do
+              Instrumenter.perform_request(__method__, options) {yield(cursor).attrs}
             end
         return collection if response.nil?
 
@@ -49,8 +51,8 @@ module TwitterFriendly
         # 他のメソッドと違い再帰的に呼ばれるため、全体をキャッシュすると、すべてを再帰的にキャッシュしてしまう。
         # それを防ぐために、特別にここでキャッシュの処理を登録している。
 
-        def perform_request(options, &block)
-          payload = {operation: 'collect', args: options[:args]}
+        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
@@ -67,8 +69,8 @@ module TwitterFriendly
             if options[:recursive]
               do_request.call
             else
-              TwitterFriendly::Caching::Instrumenter.start_processing(name, options)
-              TwitterFriendly::Caching::Instrumenter.complete_processing(name, options, &do_request)
+              TwitterFriendly::CachingAndLogging::Instrumenter.start_processing(name, options)
+              TwitterFriendly::CachingAndLogging::Instrumenter.complete_processing(name, options, &do_request)
             end
           end
         end