twitter_friendly 0.1.0 → 0.2.0

data/gemfiles/ar_4.2.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 4.2.10"
+
+gemspec path: "../"

data/gemfiles/ar_5.1.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 5.1.5"
+
+gemspec path: "../"

data/gemfiles/ar_5.2.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 5.2.1"
+
+gemspec path: "../"

data/lib/twitter_friendly.rb

@@ -1,4 +1,16 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'twitter'
+
 require "twitter_friendly/version"
+require "twitter_friendly/utils"
+require "twitter_friendly/logger"
+require "twitter_friendly/log_subscriber"
+require "twitter_friendly/serializer"
+require "twitter_friendly/cache_key"
+require "twitter_friendly/cache"
+require "twitter_friendly/rate_limit"
+require "twitter_friendly/client"
 
 module TwitterFriendly
   class Error < StandardError; end

data/lib/twitter_friendly/cache.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+require 'fileutils'
+
+module TwitterFriendly
+  class Cache
+    extend Forwardable
+    def_delegators :@client, :clear, :cleanup
+
+    def initialize(*args)
+      options = args.extract_options!
+
+      path = options[:cache_dir] || File.join('.twitter_friendly', 'cache')
+      FileUtils.mkdir_p(path) unless File.exists?(path)
+      @client = ::ActiveSupport::Cache::FileStore.new(path, expires_in: 1.hour, race_condition_ttl: 5.minutes)
+    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]
+
+      block_result = nil
+      blk =
+          Proc.new do
+            block_result = yield
+            encode(block_result, args: options[:args])
+          end
+
+      fetch_result =
+        if super_operation
+          @client.fetch(key, tf_super_operation: super_operation, &blk)
+        else
+          @client.fetch(key, &blk)
+        end
+
+      block_result ? block_result : decode(fetch_result, args: options[:args])
+    end
+
+    private
+
+    def encode(obj, options)
+      Serializer.encode(obj, options)
+    end
+
+    def decode(str, options)
+      Serializer.decode(str, options)
+    end
+  end
+end

data/lib/twitter_friendly/cache_key.rb

@@ -0,0 +1,64 @@
+require 'digest/md5'
+
+module TwitterFriendly
+  class CacheKey
+    DELIM = ':'
+    VERSION = '1'
+
+    class << self
+      def gen(method, user, options = {})
+        [version,
+         method,
+         method_identifier(method, user, options),
+         options_identifier(method, options)
+        ].compact.join(DELIM)
+      end
+
+      private
+
+      def version
+        '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(options[:super_operation], user, options)
+          when method == :collect_with_cursor       then method_identifier(options[:super_operation], user, options)
+          when user.nil? && options[:hash].present? then "token-hash#{DELIM}#{options[:hash]}"
+          else user_identifier(user)
+          end
+      end
+
+      def user_identifier(user)
+        case
+        when user.kind_of?(Integer)                            then "id#{DELIM}#{user}"
+        when user.kind_of?(String)                             then "screen_name#{DELIM}#{user}"
+        when user.kind_of?(Array) && user.empty?               then 'The_#users_is_called_with_an_empty_array'
+        when user.kind_of?(Array) && user[0].kind_of?(Integer) then "ids#{DELIM}#{user.size}-#{hexdigest(user)}"
+        when user.kind_of?(Array) && user[0].kind_of?(String)  then "screen_names#{DELIM}#{user.size}-#{hexdigest(user)}"
+        else raise "#{__method__}: No matches #{user.inspect}"
+        end
+      end
+
+      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)
+
+        if opt.empty?
+          nil
+        else
+          str = opt.map {|k, v| "#{k}=#{v}"}.join('&')
+          "options#{DELIM}#{str}"
+        end
+      end
+
+      def hexdigest(ary)
+        Digest::MD5.hexdigest(ary.join(','))
+      end
+    end
+  end
+end

data/lib/twitter_friendly/caching.rb

@@ -0,0 +1,86 @@
+module TwitterFriendly
+  module Caching
+    %i(
+      verify_credentials
+      user?
+      user
+      users
+      blocked_ids
+      friendship?
+    ).each do |name|
+      define_method(name) do |*args|
+        options = args.extract_options!
+        Instrumenter.start_processing(name, options)
+
+        Instrumenter.complete_processing(name, options) do
+          do_request =
+              Proc.new {Instrumenter.perform_request(name, options) {options.empty? ? super(*args) : super(*args, options)}}
+
+          if Utils.cache_disabled?(options)
+            do_request.call
+          else
+            user = (name == :friendship?) ? args[0, 2] : args[0]
+            @cache.fetch(name, user, options.merge(args: [name, options], hash: credentials_hash), &do_request)
+          end
+        end
+      end
+    end
+
+    # これらのメソッドは、内部で呼ぶメソッドをキャッシュするため、
+    # 全体をキャッシュすることはない。
+    %i(
+      friend_ids
+      follower_ids
+      friends
+      followers
+      friend_ids_and_follower_ids
+      friends_and_followers
+      search
+      favorites
+      home_timeline
+      user_timeline
+      mentions_timeline
+      memberships
+      list_members
+      retweeters_ids
+    ).each do |name|
+      define_method(name) do |*args|
+        options = args.extract_options!
+        Instrumenter.start_processing(name, options)
+
+        Instrumenter.complete_processing(name, options) do
+          options.empty? ? super(*args) : super(*args, options)
+        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

@@ -0,0 +1,52 @@
+require 'forwardable'
+
+require 'twitter_friendly/rest/api'
+
+module TwitterFriendly
+  class Client
+    extend Forwardable
+    def_delegators :@twitter, :access_token, :access_token_secret, :consumer_key, :consumer_secret
+
+    include TwitterFriendly::REST::API
+    include TwitterFriendly::RateLimit
+
+    def initialize(*args)
+      options = args.extract_options!
+
+      @logger = TwitterFriendly::Logger.new(options)
+
+      unless subscriber_attached?
+        if @logger.level == ::Logger::DEBUG
+          @@subscriber_attached = true
+          TwitterFriendly::Logging.logger = @logger
+          TwitterFriendly::TFLogSubscriber.attach_to :twitter_friendly
+          TwitterFriendly::ASLogSubscriber.attach_to :active_support
+        end
+      end
+
+      @cache = TwitterFriendly::Cache.new(options)
+      @twitter = Twitter::REST::Client.new(options)
+    end
+
+    def cache
+      @cache
+    end
+
+    def logger
+      @logger
+    end
+
+    def internal_client
+      @twitter
+    end
+
+    def subscriber_attached?
+      @@subscriber_attached ||= false
+    end
+  end
+
+  def cache(cache_dir = nil)
+    TwitterFriendly::Cache.new(cache_dir: cache_dir)
+  end
+  module_function :cache
+end

data/lib/twitter_friendly/log_subscriber.rb

@@ -0,0 +1,109 @@
+module TwitterFriendly
+  module Logging
+    def truncated_payload(payload)
+      return payload.inspect if !payload.has_key?(:args) || !payload[:args].is_a?(Array) || payload[:args].empty? || !payload[:args][0].is_a?(Array)
+
+      args = payload[:args].dup
+      args[0] =
+        if args[0].size > 3
+          "[#{args[0].take(3).join(', ')} ... #{args[0].size}]"
+        else
+          args[0].inspect
+        end
+
+      {args: args}.merge(payload.except(:args)).inspect
+    end
+
+    def nested_indent(payload)
+      (payload[:super_operation] ? '  ' : '') + (payload[:super_super_operation] ? '  ' : '') + (payload[:tf_super_operation] ? '  ' : '')
+    end
+
+    module_function
+
+    def logger
+      @@logger
+    end
+
+    def logger=(logger)
+      @@logger = logger
+    end
+  end
+
+  class TFLogSubscriber < ::ActiveSupport::LogSubscriber
+    include Logging
+
+    def start_processing(event)
+      payload = event.payload
+      name = "#{nested_indent(payload)}TF::Started #{payload.delete(:operation)}"
+      debug do
+        if payload[:super_operation]
+          "#{name} in #{payload[:super_operation]} at #{Time.now}"
+        else
+          "#{name} at #{Time.now}"
+        end
+      end
+    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?}"
+      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?}" }
+    end
+
+    %w(request encode decode collect).each do |operation|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{operation}(event)
+          event.payload[:name] = '#{operation}'
+          twitter_friendly_any(event)
+        end
+      METHOD
+    end
+  end
+
+  class ASLogSubscriber < ::ActiveSupport::LogSubscriber
+    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)}" }
+    end
+
+    # Ignore generate and fetch_hit
+    %w(read write delete exist?).each do |operation|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def cache_#{operation}(event)
+          event.payload[:name] = '#{operation}'
+          cache_any(event)
+        end
+      METHOD
+    end
+  end
+end

data/lib/twitter_friendly/logger.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+require 'fileutils'
+require 'logger'
+
+module TwitterFriendly
+  class Logger
+    extend Forwardable
+    def_delegators :@logger, :debug, :info, :warn, :level
+
+    def initialize(options = {})
+      path = options[:log_dir] || File.join('.twitter_friendly')
+      FileUtils.mkdir_p(path) unless File.exists?(path)
+
+      @logger = ::Logger.new(File.join(path, 'twitter_friendly.log'))
+      @logger.level = options[:log_level] || :debug
+    end
+  end
+end

data/lib/twitter_friendly/rate_limit.rb

@@ -0,0 +1,81 @@
+module TwitterFriendly
+  module RateLimit
+    def rate_limit
+      RateLimit.new(perform_get('/1.1/application/rate_limit_status.json'))
+    rescue => e
+      logger.warn e.inspect
+      nil
+    end
+
+    private
+
+    def perform_get(*args)
+      internal_client.send(:perform_get, *args)
+    end
+
+    class RateLimit
+      def initialize(status)
+        @status = status
+      end
+
+      def resources
+        @status[:resources]
+      end
+
+      def verify_credentials
+        extract_remaining_and_reset_in(resources[:account][:'/account/verify_credentials'])
+      end
+
+      def friend_ids
+        extract_remaining_and_reset_in(resources[:friends][:'/friends/ids'])
+      end
+
+      def follower_ids
+        extract_remaining_and_reset_in(resources[:followers][:'/followers/ids'])
+      end
+
+      def users
+        extract_remaining_and_reset_in(resources[:users][:'/users/lookup'])
+      end
+
+      def friends(parallel: true)
+        if parallel
+          {friend_ids: friend_ids, users: users}
+        else
+          extract_remaining_and_reset_in(resources[:friends][:'/friends/list'])
+        end
+      end
+
+      def followers(parallel: true)
+        if parallel
+          {follower_ids: follower_ids, users: users}
+        else
+          extract_remaining_and_reset_in(resources[:followers][:'/followers/list'])
+        end
+      end
+
+      def to_h
+        {
+          verify_credentials: verify_credentials,
+          friend_ids: friend_ids,
+          follower_ids: follower_ids,
+          users: users
+        }
+      end
+
+      def inspect
+        'verify_credentials ' + verify_credentials.inspect +
+          ' friend_ids ' + friend_ids.inspect +
+          ' follower_ids ' + follower_ids.inspect +
+          ' users ' + users.inspect
+      end
+
+      private
+
+      def extract_remaining_and_reset_in(limit)
+        {remaining: limit[:remaining], reset_in: (Time.at(limit[:reset]) - Time.now).round}
+      end
+    end
+  end
+end
+