twterm 2.5.0 → 2.9.0

data/lib/twterm/direct_message_composer.rb

@@ -1,80 +0,0 @@
-require 'twterm/event/screen/refresh'
-require 'twterm/publisher'
-require 'twterm/user'
-require 'twterm/utils'
-
-module Twterm
-  class DirectMessageComposer
-    include Readline
-    include Curses
-    include Publisher
-    include Utils
-
-    def initialize(app, client)
-      @app, @client = app, client
-    end
-
-    def compose(recipient)
-      check_type User, recipient
-
-      clear
-
-      resetter = proc do
-        reset_prog_mode
-        sleep 0.1
-        publish(Event::Screen::Refresh.new)
-      end
-
-      thread = Thread.new do
-        close_screen
-
-        puts "\nCompose new message to @%s:" % recipient.screen_name
-
-        app.completion_manager.set_default_mode!
-
-        loop do
-          line = (readline('> ', true) || '').strip
-          break if line.empty?
-
-          if line.end_with?('\\')
-            @text << line.chop.rstrip + "\n"
-          else
-            @text << line
-            break
-          end
-        end
-
-        puts "\n"
-
-        resetter.call
-        send(recipient) unless text.empty?
-      end
-
-      app.register_interruption_handler do
-        thread.kill
-        clear
-        puts "\nCanceled"
-        resetter.call
-      end
-
-      thread.join
-    end
-
-    private
-
-    attr_reader :app, :client
-
-    def clear
-      @text = ''
-    end
-
-    def send(recipient)
-      client.create_direct_message(recipient, text)
-      clear
-    end
-
-    def text
-      @text || ''
-    end
-  end
-end

data/lib/twterm/direct_message_manager.rb

@@ -1,51 +0,0 @@
-require 'twterm/client'
-require 'twterm/direct_message'
-require 'twterm/event/direct_message/fetched'
-require 'twterm/publisher'
-require 'twterm/scheduler'
-require 'twterm/user'
-require 'twterm/utils'
-
-module Twterm
-  class DirectMessageManager
-    include Publisher, Utils
-
-    def initialize(client)
-      check_type Client, client
-
-      @client = client
-      @conversations = {}
-
-      fetch
-
-      Scheduler.new(300) { fetch }
-    end
-
-    def add(collocutor_id, message)
-      check_type DirectMessage, message
-
-      @conversations[collocutor_id] ||= DirectMessage::Conversation.new(collocutor_id)
-      @conversations[collocutor_id] << message
-    end
-
-    def fetch
-      client.direct_messages_received.then do |messages|
-        messages.each { |m| add(m.sender_id, m) }
-        publish(Event::DirectMessage::Fetched.new)
-      end
-
-      client.direct_messages_sent.then do |messages|
-        messages.each { |m| add(m.recipient_id, m) }
-        publish(Event::DirectMessage::Fetched.new)
-      end
-    end
-
-    def conversations
-      @conversations.values
-    end
-
-    private
-
-    attr_reader :client
-  end
-end

data/lib/twterm/event/direct_message/fetched.rb

@@ -1,10 +0,0 @@
-require 'twterm/event/abstract_event'
-
-module Twterm
-  module Event
-    module DirectMessage
-      class Fetched < AbstractEvent
-      end
-    end
-  end
-end

data/lib/twterm/event/notification/direct_message.rb

@@ -1,30 +0,0 @@
-require 'twterm/event/notification/abstract_notification'
-
-module Twterm
-  module Event
-    module Notification
-      class DirectMessage < AbstractNotification
-        # @param [Twterm::DirectMessage] message
-        # @param [Twterm::User] user
-        def initialize(message, user)
-          @message = message
-          @user = user
-        end
-
-        # @return [String] notification body
-        def body
-          message.text
-        end
-
-        # @return [String] notification title
-        def title
-          "@#{user.screen_name} has sent you a message"
-        end
-
-        private
-
-        attr_reader :message, :user
-      end
-    end
-  end
-end

data/lib/twterm/event/status/timeline.rb

@@ -1,10 +0,0 @@
-require 'twterm/event/status/abstract_status_event'
-
-module Twterm
-  module Event
-    module Status
-      class Timeline < AbstractStatusEvent
-      end
-    end
-  end
-end

data/lib/twterm/repository/direct_message_repository.rb

@@ -1,14 +0,0 @@
-require 'twterm/direct_message'
-require 'twterm/repository/abstract_entity_repository'
-
-module Twterm
-  module Repository
-    class DirectMessageRepository < AbstractEntityRepository
-      private
-
-      def type
-        DirectMessage
-      end
-    end
-  end
-end

data/lib/twterm/streaming_client.rb

@@ -1,146 +0,0 @@
-require 'twterm/event/message/error'
-require 'twterm/event/message/info'
-require 'twterm/event/notification/direct_message'
-require 'twterm/event/notification/favorite'
-require 'twterm/event/notification/follow'
-require 'twterm/event/notification/list_member_added'
-require 'twterm/event/notification/mention'
-require 'twterm/event/notification/quote'
-require 'twterm/event/notification/retweet'
-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
-      return if user_stream_connected?
-
-      @streaming_thread = Thread.new do
-        begin
-          publish(Event::Message::Info.new('Trying to connect to Twitter...'))
-          streaming_client.user do |event|
-            keep_alive!
-
-            case event
-            when Twitter::Tweet
-              status = status_repository.create(event)
-              user = user_repository.create(event.user)
-
-              publish(Event::Status::Timeline.new(status))
-
-              if !status.retweet? && status.text.include?('@%s' % screen_name)
-                publish(Event::Status::Mention.new(status))
-
-                notification = Event::Notification::Mention.new(status, user)
-                publish(notification)
-              end
-
-              if status.retweet? && event.retweeted_status.user.id == user_id
-                retweeted_status = status_repository.create(event.retweeted_status)
-                notification = Event::Notification::Retweet.new(retweeted_status, user)
-                publish(notification)
-              end
-            when Twitter::Streaming::Event
-              case event.name
-              when :favorite
-                next if event.source.id == user_id
-                user = user_repository.create(event.source)
-                status = status_repository.create(event.target_object)
-                notification = Event::Notification::Like.new(status, user)
-                publish(notification)
-              when :follow
-                next if event.source.id == user_id
-
-                user = user_repository.create(event.source)
-                notification = Event::Notification::Follow.new(user)
-                publish(notification)
-              when :list_member_added
-                next if event.source.id == user_id
-
-                list = list_repository.create(event.target_object)
-                notification = Event::Notification::ListMemberAdded.new(list)
-                publish(notification)
-              when :quoted_tweet
-                next if event.source.id == user_id
-
-                status = status_repository.create(event.target_object)
-                user = user_repository.create(event.source)
-                notification = Event::Notification::Quote.new(status, user)
-                publish(notification)
-              end
-            when Twitter::DirectMessage
-              next if event.sender.id == user_id
-
-              user = user_repository.create(event.sender)
-              message = DirectMessage.new(event)
-              notification = Event::Notification::DirectMessage.new(message, user)
-              publish(notification)
-            when Twitter::Streaming::FriendList
-              user_stream_connected!
-            when Twitter::Streaming::DeletedTweet
-              publish(Event::StatusDeleted.new(event.id))
-            end
-          end
-        rescue Twitter::Error::TooManyRequests
-          publish(Event::Message::Error.new('Rate limit exceeded'))
-          sleep 120
-          retry
-        rescue Errno::ENETUNREACH, Errno::ETIMEDOUT, Resolv::ResolvError
-          publish(Event::Message::Error.new('Network is unavailable'))
-          sleep 30
-          retry
-        rescue Twitter::Error => e
-          publish(Event::Message::Error.new(e.message))
-        end
-      end
-    end
-
-    private
-
-    def keep_alive!
-      @keep_alive_timer.kill if @keep_alive_timer.is_a?(Thread)
-      @keep_alive_timer = Thread.new do
-        sleep(120)
-        @user_stream_connected = false
-        @streaming_thread.kill
-        connect_user_stream
-      end
-    end
-
-    def streaming_client
-      @streaming_client ||= Twitter::Streaming::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 user_stream_connected?
-      @user_stream_connected || false
-    end
-
-    def user_stream_connected!
-      publish(Event::Message::Info.new('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/tab/direct_message/conversation.rb

@@ -1,104 +0,0 @@
-require 'twterm/direct_message_composer'
-require 'twterm/event/direct_message/fetched'
-require 'twterm/image_builder/user_name_image_builder'
-require 'twterm/subscriber'
-require 'twterm/tab/abstract_tab'
-require 'twterm/tab/loadable'
-require 'twterm/tab/searchable'
-
-module Twterm
-  module Tab
-    module DirectMessage
-      class Conversation < AbstractTab
-        include Searchable
-        include Subscriber
-        include Loadable
-
-        def drawable_item_count
-          messages.drop(scroller.offset).lazy
-            .map { |m| m.text.split_by_width(window.maxx - 4).count + 2 }
-            .scan(0, :+)
-            .each_cons(2)
-            .select { |_, l| l < window.maxy }
-            .count
-        end
-
-        def image
-          return Image.string(initially_loaded? ? 'No results found' : 'Loading...') if items.empty?
-
-          scroller.drawable_items.map.with_index(0) do |message, i|
-            sender = app.user_repository.find(message.sender_id)
-
-            header = [
-              ImageBuilder::UserNameImageBuilder.new(sender).build,
-              Image.string(message.date.to_s).brackets,
-            ].intersperse(Image.whitespace).reduce(Image.empty, :-)
-
-            body = message.text.split_by_width(window.maxx - 4)
-              .map { |x| Image.string(x) }
-              .reduce(Image.empty, :|)
-
-            m = header | body
-
-            cursor = Image.cursor(m.height, scroller.current_index?(i))
-
-            cursor - Image.whitespace - m
-          end
-            .intersperse(Image.blank_line)
-            .reduce(Image.empty, :|)
-        end
-
-        def initialize(app, client, conversation)
-          super(app, client)
-
-          @conversation = conversation
-
-          subscribe(Event::DirectMessage::Fetched) { initially_loaded! }
-        end
-
-        def items
-          messages
-        end
-
-        def matches?(message, query)
-          sender = app.user_repository.find(message.sender_id)
-
-          [
-            message.text,
-            sender.screen_name,
-            sender.name
-          ].any? { |x| x.downcase.include?(query.downcase) }
-        end
-
-        def respond_to_key(key)
-          return true if scroller.respond_to_key(key)
-
-          k = KeyMapper.instance
-
-          case key
-          when k[:status, :compose], k[:status, :reply]
-            collocutor = app.user_repository.find(conversation.collocutor_id)
-            app.direct_message_composer.compose(collocutor)
-          else
-            return false
-          end
-
-          true
-        end
-
-        def title
-          collocutor = app.user_repository.find(conversation.collocutor_id)
-          '@%s messages' % collocutor.screen_name
-        end
-
-        private
-
-        attr_reader :conversation
-
-        def messages
-          @conversation.messages
-        end
-      end
-    end
-  end
-end