twterm 1.1.3 → 1.2.0

data/lib/twterm/rest_client.rb

@@ -0,0 +1,401 @@
+require 'twterm/direct_message'
+require 'twterm/direct_message_manager'
+require 'twterm/publisher'
+require 'twterm/event/notification'
+
+module Twterm
+  module RESTClient
+    include Publisher
+
+    CONSUMER_KEY = 'vLNSVFgXclBJQJRZ7VLMxL9lA'.freeze
+    CONSUMER_SECRET = 'OFLKzrepRG2p1hq0nUB9j2S9ndFQoNTPheTpmOY0GYw55jGgS5'.freeze
+
+    def block(*user_ids)
+      send_request do
+        rest_client.block(*user_ids)
+      end.then do |users|
+        users.each do |user|
+          Friendship.block(self.user_id, user.id)
+        end
+      end
+    end
+
+    def create_direct_message(recipient, text)
+      send_request do
+        rest_client.create_direct_message(recipient.id, text)
+      end.then do |message|
+        msg = DirectMessage.new(message)
+        direct_message_manager.add(msg.recipient, msg)
+        publish(Event::DirectMessage::Fetched.new)
+        publish(Event::Notification.new(:message, 'Your message to @%s has been sent' % msg.recipient.screen_name))
+      end
+    end
+
+    def direct_message_conversations
+      direct_message_manager.conversations
+    end
+
+    def direct_messages_received
+      send_request do
+        rest_client.direct_messages(count: 200).map(&DirectMessage.method(:new))
+      end
+    end
+
+    def direct_messages_sent
+      send_request do
+        rest_client.direct_messages_sent(count: 200).map(&DirectMessage.method(:new))
+      end
+    end
+
+    def destroy_status(status)
+      send_request_without_catch do
+        rest_client.destroy_status(status.id)
+        publish(Event::Status::Delete.new(status.id))
+        publish(Event::Notification.new(:message, 'Your tweet has been deleted'))
+      end.catch do |reason|
+        case reason
+        when Twitter::Error::NotFound, Twitter::Error::Forbidden
+          publish(Event::Notification.new(:error, 'You cannot destroy that status'))
+        else
+          raise reason
+        end
+      end.catch(&show_error)
+    end
+
+    def favorite(status)
+      return false unless status.is_a? Status
+
+      send_request do
+        rest_client.favorite(status.id)
+      end.then do
+        status.favorite!
+        publish(Event::Notification.new(:message, 'Successfully liked: @%s "%s"' % [
+          status.user.screen_name, status.text
+        ]))
+      end
+    end
+
+    def favorites(user_id = nil)
+      user_id ||= self.user_id
+
+      send_request do
+        rest_client.favorites(user_id, count: 200)
+      end.then do |tweets|
+        tweets.map(&Status.method(:new))
+      end
+    end
+
+    def fetch_muted_users
+      send_request do
+        @muted_user_ids = rest_client.muted_ids.to_a
+      end
+    end
+
+    def follow(*user_ids)
+      send_request do
+        rest_client.follow(*user_ids)
+      end.then do |users|
+        users.each do |user|
+          if user.protected?
+            Friendship.following_requested(self.user_id, user.id)
+          else
+            Friendship.follow(self.user_id, user.id)
+          end
+        end
+      end
+    end
+
+    def followers(user_id = nil)
+      user_id ||= self.user_id
+
+      m = Mutex.new
+
+      send_request do
+        rest_client.follower_ids(user_id).each_slice(100) do |user_ids|
+          m.synchronize do
+            users = rest_client.users(*user_ids).map(& -> u { User.new(u) })
+            users.each do |user|
+              Friendship.follow(user.id, self.user_id)
+            end if user_id == self.user_id
+            yield users
+          end
+        end
+      end
+    end
+
+    def friends(user_id = nil)
+      user_id ||= self.user_id
+
+      m = Mutex.new
+
+      send_request do
+        rest_client.friend_ids(user_id).each_slice(100) do |user_ids|
+          m.synchronize do
+            yield rest_client.users(*user_ids).map(& -> u { User.new(u) })
+          end
+        end
+      end
+    end
+
+    def home_timeline
+      send_request do
+        rest_client.home_timeline(count: 200)
+      end.then do |statuses|
+        statuses
+        .select(&@mute_filter)
+        .map(&Status.method(:new))
+      end
+    end
+
+    def list(list_id)
+      send_request do
+        rest_client.list(list_id)
+      end.then do |list|
+        List.new(list)
+      end
+    end
+
+    def list_timeline(list)
+      fail ArgumentError,
+        'argument must be an instance of List class' unless list.is_a? List
+      send_request do
+        rest_client.list_timeline(list.id, count: 200)
+      end.then do |statuses|
+        statuses
+        .select(&@mute_filter)
+        .map(&Status.method(:new))
+      end
+    end
+
+    def lists
+      send_request do
+        rest_client.lists
+      end.then do |lists|
+        lists.map { |list| List.new(list) }
+      end
+    end
+
+    def lookup_friendships
+      user_ids = User.ids.reject { |id| Friendship.already_looked_up?(id) }
+      send_request_without_catch do
+        user_ids.each_slice(100) do |chunked_user_ids|
+          friendships = rest_client.friendships(*chunked_user_ids)
+          friendships.each do |friendship|
+            id = friendship.id
+            client_id = user_id
+
+            conn = friendship.connections
+            conn.include?('blocking') ? Friendship.block(client_id, id) : Friendship.unblock(client_id, id)
+            conn.include?('following') ? Friendship.follow(client_id, id) : Friendship.unfollow(client_id, id)
+            conn.include?('following_requested') ? Friendship.following_requested(client_id, id) : Friendship.following_not_requested(client_id, id)
+            conn.include?('followed_by') ? Friendship.follow(id, client_id) : Friendship.unfollow(id, client_id)
+            conn.include?('muting') ? Friendship.mute(client_id, id) : Friendship.unmute(client_id, id)
+          end
+        end
+      end.catch do |e|
+        case e
+        when Twitter::Error::TooManyRequests
+          # do nothing
+        else
+          raise e
+        end
+      end.catch(&show_error)
+    end
+
+    def mentions
+      send_request do
+        rest_client.mentions(count: 200)
+      end.then do |statuses|
+        statuses
+        .select(&@mute_filter)
+        .map(&Status.method(:new))
+      end
+    end
+
+    def mute(user_ids)
+      send_request do
+        rest_client.mute(*user_ids)
+      end.then do |users|
+        users.each do |user|
+          Friendship.mute(self.user_id, user.id)
+        end
+      end
+    end
+
+    def post(text, in_reply_to = nil)
+      send_request do
+        if in_reply_to.is_a? Status
+          text = "@#{in_reply_to.user.screen_name} #{text}"
+          rest_client.update(text, in_reply_to_status_id: in_reply_to.id)
+        else
+          rest_client.update(text)
+        end
+        publish(Event::Notification.new(:message, 'Your tweet has been posted'))
+      end
+    end
+
+    def retweet(status)
+      fail ArgumentError,
+        'argument must be an instance of Status class' unless status.is_a? Status
+
+      send_request_without_catch do
+        rest_client.retweet!(status.id)
+      end.then do
+        status.retweet!
+        publish(Event::Notification.new(:message, 'Successfully retweeted: @%s "%s"' % [
+          status.user.screen_name, status.text
+        ]))
+      end.catch do |reason|
+        message =
+          case reason
+          when Twitter::Error::AlreadyRetweeted
+            'The status is already retweeted'
+          when Twitter::Error::NotFound
+            'The status is not found'
+          when Twitter::Error::Forbidden
+            if status.user.id == user_id  # when the status is mine
+              'You cannot retweet your own status'
+            else  # when the status is not mine
+              'The status is protected'
+            end
+          else
+            raise e
+          end
+        publish(Event::Notification.new(:error, "Retweet attempt failed: #{message}"))
+      end.catch(&show_error)
+    end
+
+    def saved_search
+      send_request do
+        rest_client.saved_searches
+      end
+    end
+
+    def search(query)
+      send_request do
+        rest_client.search(query, count: 100).attrs[:statuses]
+      end.then do |statuses|
+        statuses
+        .map(&Twitter::Tweet.method(:new))
+        .map(&Status.method(:new))
+      end
+    end
+
+    def show_status(status_id)
+      send_request do
+        rest_client.status(status_id)
+      end.then do |status|
+        Status.new(status)
+      end
+    end
+
+    def show_user(query)
+      send_request_without_catch do
+        rest_client.user(query)
+      end.catch do |reason|
+        case reason
+        when Twitter::Error::NotFound
+          nil
+        else
+          raise reason
+        end
+      end.catch(&show_error).then do |user|
+        user.nil? ? nil : User.new(user)
+      end
+    end
+
+    def unblock(*user_ids)
+      send_request do
+        rest_client.unblock(*user_ids)
+      end.then do |users|
+        users.each do |user|
+          Friendship.unblock(self.user_id, user.id)
+        end
+      end
+    end
+
+    def unfavorite(status)
+      fail ArgumentError,
+        'argument must be an instance of Status class' unless status.is_a? Status
+
+      send_request do
+        rest_client.unfavorite(status.id)
+      end.then do
+        status.unfavorite!
+        publish(Event::Notification.new(:message, 'Successfully unliked: @%s "%s"' % [
+          status.user.screen_name, status.text
+        ]))
+      end
+    end
+
+    def unfollow(*user_ids)
+      send_request do
+        rest_client.unfollow(*user_ids)
+      end.then do |users|
+        users.each do |user|
+          Friendship.unfollow(self.user_id, user.id)
+        end
+      end
+    end
+
+    def unmute(user_ids)
+      send_request do
+        rest_client.unmute(*user_ids)
+      end.then do |users|
+        users.each do |user|
+          Friendship.unmute(self.user_id, user.id)
+        end
+      end
+    end
+
+    def user_timeline(user_id)
+      send_request do
+        rest_client.user_timeline(user_id, count: 200)
+      end.then do |statuses|
+        statuses
+        .select(&@mute_filter)
+        .map(&Status.method(:new))
+      end
+    end
+
+    def rest_client
+      @rest_client ||= Twitter::REST::Client.new do |config|
+        config.consumer_key        = CONSUMER_KEY
+        config.consumer_secret     = CONSUMER_SECRET
+        config.access_token        = @access_token
+        config.access_token_secret = @access_token_secret
+      end
+    end
+
+    def send_request(&block)
+      send_request_without_catch(&block).catch(&show_error)
+    end
+
+    def send_request_without_catch(&block)
+      Promise.new do |resolve, reject|
+        begin
+          resolve.(block.call)
+        rescue Twitter::Error => reason
+          reject.(reason)
+        end
+      end
+    end
+
+    private
+
+    def direct_message_manager
+      @direct_message_manager ||= DirectMessageManager.new(self)
+    end
+
+    def show_error
+      proc do |e|
+        case e
+        when Twitter::Error
+          publish(Event::Notification.new(:error, "Failed to send request: #{e.message}"))
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/twterm/screen.rb

@@ -1,6 +1,10 @@
+require 'twterm/event/screen/resize'
+require 'twterm/subscriber'
+
 module Twterm
   class Screen
     include Singleton
+    include Subscriber
     include Curses
 
     def initialize
@@ -11,6 +15,8 @@ module Twterm
       stdscr.keypad(true)
       start_color
       use_default_colors
+
+      subscribe(Event::Screen::Resize, :resize)
     end
 
     def refresh
@@ -19,19 +25,6 @@ module Twterm
       Notifier.instance.show
     end
 
-    def resize
-      return if closed?
-
-      resizeterm(`tput lines`.to_i, `tput cols`.to_i)
-      @screen.resize(`tput lines`.to_i, `tput cols`.to_i)
-
-      TabManager.instance.resize
-      TabManager.instance.each_tab(&:resize)
-      Notifier.instance.resize
-      FilterQueryWindow.instance.resize
-      refresh
-    end
-
     def respond_to_key(key)
       case key
       when ?n
@@ -58,6 +51,16 @@ module Twterm
 
     private
 
+    def resize(event)
+      return if closed?
+
+      lines, cols = event.lines, event.cols
+      resizeterm(lines, cols)
+      @screen.resize(lines, cols)
+
+      refresh
+    end
+
     def scan
       App.instance.reset_interruption_handler
 

data/lib/twterm/status.rb

@@ -113,10 +113,15 @@ module Twterm
     end
 
     def update!(tweet)
+      return self if recently_updated?
+
       @retweet_count = tweet.retweet_count
       @favorite_count = tweet.favorite_count
       @retweeted = tweet.retweeted?
       @favorited = tweet.favorited?
+
+      @updated_at = Time.now
+
       self
     end
 
@@ -135,7 +140,7 @@ module Twterm
       cond = -> (status) { status.touched_at > Time.now - MAX_CACHED_TIME }
       statuses = all.select(&cond)
       status_ids = statuses.map(&:id)
-      @@instances = status_ids.zip(statuses).to_h
+      @@instances = Hash[status_ids.zip(statuses)]
     end
 
     def self.delete(id)
@@ -159,5 +164,11 @@ module Twterm
       instance = find(tweet.id)
       instance.nil? ? super : instance.update!(tweet)
     end
+
+    private
+
+    def recently_updated?
+      !@updated_at.nil? && @updated_at + 60 > Time.now
+    end
   end
 end

data/lib/twterm/streaming_client.rb

@@ -0,0 +1,103 @@
+require 'twterm/event/favorite'
+require 'twterm/event/notification'
+require 'twterm/event/status/mention'
+require 'twterm/event/status/timeline'
+require 'twterm/publisher'
+
+module Twterm
+  module StreamingClient
+    include Publisher
+
+    CONSUMER_KEY = 'vLNSVFgXclBJQJRZ7VLMxL9lA'.freeze
+    CONSUMER_SECRET = 'OFLKzrepRG2p1hq0nUB9j2S9ndFQoNTPheTpmOY0GYw55jGgS5'.freeze
+
+    def connect_user_stream
+      streaming_client.stop_stream
+
+      @streaming_thread = Thread.new do
+        begin
+          publish(Event::Notification.new(:message, 'Trying to connect to Twitter...'))
+          streaming_client.userstream
+        rescue EventMachine::ConnectionError
+          publish(Event::Notification.new(:error, 'Connection failed'))
+          sleep 30
+          retry
+        end
+      end
+    end
+
+    def initialize_user_stream
+      return if user_stream_initialized?
+
+      streaming_client.on_friends do
+        user_stream_connected!
+      end
+
+      streaming_client.on_timeline_status do |tweet|
+        status = Status.new(tweet)
+        publish(Event::Status::Timeline.new(status))
+        publish(Event::Status::Mention.new(status)) if status.text.include?('@%s' % screen_name)
+      end
+
+      streaming_client.on_delete do |status_id|
+        publish(Event::StatusDeleted.new(status_id))
+      end
+
+      streaming_client.on_event(:favorite) do |event|
+        user = User.new(Twitter::User.new(event[:source]))
+        status = Status.new(Twitter::Status.new(event[:target]))
+
+        event = Event::Favorite.new(user, status, self)
+        publish(event)
+      end
+
+      streaming_client.on_event(:follow) do |event|
+        source = User.new(Twitter::User.new(event[:source]))
+        target = User.new(Twitter::User.new(event[:target]))
+
+        event = Event::Follow.new(source, target, self)
+        publish(:followed, event)
+      end
+
+      streaming_client.on_no_data_received do
+        user_stream_disconnected!
+        connect_user_stream
+      end
+
+      user_stream_initialized!
+    end
+
+    private
+
+    def streaming_client
+      @streaming_client ||= TweetStream::Client.new(
+        consumer_key:       CONSUMER_KEY,
+        consumer_secret:    CONSUMER_SECRET,
+        oauth_token:        @access_token,
+        oauth_token_secret: @access_token_secret,
+        auth_method:        :oauth
+      )
+    end
+
+    def user_stream_connected?
+      @user_stream_connected || false
+    end
+
+    def user_stream_connected!
+      publish(Event::Notification.new(:message, 'Connection established')) unless user_stream_connected?
+      @user_stream_connected = true
+    end
+
+    def user_stream_disconnected!
+      @user_stream_connected = false
+    end
+
+    def user_stream_initialized?
+      @user_stream_initialized || false
+    end
+
+    def user_stream_initialized!
+      @user_stream_initialized = true
+    end
+  end
+end

data/lib/twterm/subscriber.rb

@@ -0,0 +1,33 @@
+require 'twterm/event_dispatcher'
+
+module Twterm
+  module Subscriber
+    def subscribe(event, callback = nil, &block)
+      cb = if callback.is_a?(Proc)
+             callback
+           elsif callback.is_a?(Symbol)
+             if self.respond_to?(callback, true)
+               self.method(callback)
+             else
+               callback.to_proc
+             end
+           elsif callback.nil?
+             block
+           end
+
+      EventDispatcher.instance.register_subscription(object_id, event, cb)
+    end
+
+    def unsubscribe(event = nil)
+      EventDispatcher.instance.unregister_subscription(object_id, event)
+
+      self
+    end
+
+    def self.included(base)
+      base.instance_eval do
+        private :subscribe, :unsubscribe
+      end
+    end
+  end
+end

data/lib/twterm/tab/base.rb

@@ -1,7 +1,11 @@
+require 'twterm/event/screen/resize'
+require 'twterm/subscriber'
+
 module Twterm
   module Tab
-    module Base
+    class Base
       include Curses
+      include Subscriber
 
       attr_reader :window
       attr_accessor :title
@@ -11,11 +15,14 @@ module Twterm
       end
 
       def close
+        unsubscribe
         window.close
       end
 
       def initialize
         @window = stdscr.subwin(stdscr.maxy - 5, stdscr.maxx, 3, 0)
+
+        subscribe(Event::Screen::Resize, :resize)
       end
 
       def refresh
@@ -37,11 +44,6 @@ module Twterm
         end
       end
 
-      def resize
-        window.resize(stdscr.maxy - 5, stdscr.maxx)
-        window.move(3, 0)
-      end
-
       def respond_to_key(_)
         fail NotImplementedError, 'respond_to_key method must be implemented'
       end
@@ -65,6 +67,11 @@ module Twterm
         )
       end
 
+      def resize(event)
+        window.resize(stdscr.maxy - 5, stdscr.maxx)
+        window.move(3, 0)
+      end
+
       def update
         fail NotImplementedError, 'update method must be implemented'
       end