twterm 1.3.0 → 2.0.0.beta1

data/lib/twterm/status.rb

@@ -1,15 +1,13 @@
+require 'concurrent'
+
 module Twterm
   class Status
-    MAX_CACHED_TIME = 3600
-
-    attr_reader :appeared_at, :created_at, :favorite_count, :favorited, :id,
+    attr_reader :created_at, :favorite_count, :favorited, :id,
       :in_reply_to_status_id, :media, :retweet_count, :retweeted,
-      :retweeted_by_user_id, :text, :touched_at, :urls, :user_id
+      :retweeted_status_id, :text, :urls, :user_id
     alias_method :favorited?, :favorited
     alias_method :retweeted?, :retweeted
 
-    @@instances = {}
-
     def ==(other)
       other.is_a?(self.class) && id == other.id
     end
@@ -25,150 +23,58 @@ module Twterm
     end
 
     def favorite!
-      @favorite_count += 1
       @favorited = true
     end
 
-    def matches?(query)
-      [text, user.screen_name, user.name]
-        .any? { |x| x.downcase.include?(query.downcase) }
-    end
-
-    def in_reply_to_status(&block)
-      Promise.new do |resolve, reject|
-        (resolve.(nil) && next) if in_reply_to_status_id.nil?
-
-        instance = Status.find(in_reply_to_status_id)
-        (resolve.(instance) && next) if instance
-
-        Client.current.show_status(in_reply_to_status_id)
-        .then do |status|
-          resolve.(status)
-        end
-      end
-    end
-
-    def initialize(tweet)
+    def initialize(tweet, is_retweeted_status = false)
       unless tweet.retweeted_status.is_a? Twitter::NullObject
-        @retweeted_by_user_id = tweet.user.id
-        User.new(tweet.user)
-        retweeted_at = tweet.created_at.dup.localtime
-        tweet = tweet.retweeted_status
+        @retweeted_status_id = tweet.retweeted_status.id
       end
 
       @id = tweet.id
       @text = CGI.unescapeHTML(tweet.full_text.dup)
       @created_at = tweet.created_at.dup.localtime
-      @appeared_at = retweeted_at || @created_at
-      @retweet_count = tweet.retweet_count
-      @favorite_count = tweet.favorite_count
       @in_reply_to_status_id = tweet.in_reply_to_status_id
 
-      @retweeted = tweet.retweeted?
-      @favorited = tweet.favorited?
+      update!(tweet, is_retweeted_status)
 
       @media = tweet.media
       @urls = tweet.urls
 
       @user_id = tweet.user.id
-      User.new(tweet.user)
 
       @splitted_text = {}
 
       expand_url!
-
-      @touched_at = Time.now
-
-      tweet.hashtags.each do |hashtag|
-        History::Hashtag.instance.add(hashtag.text)
-      end
-
-      @@instances[id] = self
     end
 
-    def replies
-      Status.all.select { |s| s.in_reply_to_status_id == id }
+    def retweet?
+      !retweeted_status_id.nil?
     end
 
     def retweet!
-      @retweet_count += 1
       @retweeted = true
     end
 
-    def retweeted_by
-      User.find(@retweeted_by_user_id)
-    end
-
     def split(width)
       @splitted_text[width] ||= @text.split_by_width(width)
     end
 
-    def touch!
-      @touched_at = Time.now
-    end
-
     def unfavorite!
-      @favorite_count -= 1
       @favorited = false
     end
 
-    def update!(tweet)
-      return self if recently_updated?
+    def unretweet!
+      @retweeted = false
+    end
 
+    def update!(tweet, is_retweeted_status = false)
       @retweet_count = tweet.retweet_count
       @favorite_count = tweet.favorite_count
-      @retweeted = tweet.retweeted?
+      @retweeted = tweet.retweeted? unless is_retweeted_status
       @favorited = tweet.favorited?
 
-      @updated_at = Time.now
-
       self
     end
-
-    def user
-      User.find(user_id)
-    end
-
-    def self.all
-      @@instances.values
-    end
-
-    def self.cleanup
-      TabManager.instance.each_tab do |tab|
-        tab.touch_statuses if tab.is_a?(Tab::Statuses::Base)
-      end
-      cond = -> (status) { status.touched_at > Time.now - MAX_CACHED_TIME }
-      statuses = all.select(&cond)
-      status_ids = statuses.map(&:id)
-      @@instances = Hash[status_ids.zip(statuses)]
-    end
-
-    def self.delete(id)
-      @@instances.delete(id)
-    end
-
-    def self.find(id)
-      @@instances[id]
-    end
-
-    def self.find_or_fetch(id)
-      Promise.new do |resolve, reject|
-        instance = find(id)
-        (resolve.(instance) && next) if instance
-
-        Client.current.show_status(id) { |status| resolve.(status) }
-      end
-    end
-
-    def self.new(tweet)
-      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

@@ -1,6 +1,7 @@
 require 'twterm/event/favorite'
 require 'twterm/event/follow'
-require 'twterm/event/notification'
+require 'twterm/event/notification/error'
+require 'twterm/event/notification/info'
 require 'twterm/event/status/mention'
 require 'twterm/event/status/timeline'
 require 'twterm/publisher'
@@ -17,26 +18,26 @@ module Twterm
 
       @streaming_thread = Thread.new do
         begin
-          publish(Event::Notification.new(:message, 'Trying to connect to Twitter...'))
+          publish(Event::Notification::Info.new('Trying to connect to Twitter...'))
           streaming_client.user do |event|
             keep_alive!
 
             case event
             when Twitter::Tweet
-              status = Status.new(event)
+              status = status_repository.create(event)
               publish(Event::Status::Timeline.new(status))
               publish(Event::Status::Mention.new(status)) if status.text.include?('@%s' % screen_name)
             when Twitter::Streaming::Event
               case event.name
               when :favorite
-                user = User.new(event.source)
-                status = Status.new(event.target_object)
+                user = user_repository.create(event.source)
+                status = status_repository.create(event.target_object)
 
                 event = Event::Favorite.new(user, status, self)
                 publish(event)
               when :follow
-                source = User.new(event.source)
-                target = User.new(event.target)
+                source = user_repository.create(event.source)
+                target = user_repository.create(event.target)
 
                 event = Event::Follow.new(source, target, self)
 
@@ -50,15 +51,15 @@ module Twterm
             end
           end
         rescue Twitter::Error::TooManyRequests
-          publish(Event::Notification.new(:error, 'Rate limit exceeded'))
+          publish(Event::Notification::Error.new('Rate limit exceeded'))
           sleep 120
           retry
-        rescue Errno::ENETUNREACH, Resolv::ResolvError
-          publish(Event::Notification.new(:error, 'Network is unavailable'))
+        rescue Errno::ENETUNREACH, Errno::ETIMEDOUT, Resolv::ResolvError
+          publish(Event::Notification::Error.new('Network is unavailable'))
           sleep 30
           retry
         rescue Twitter::Error => e
-          publish(Event::Notification.new(:error, e.message))
+          publish(Event::Notification::Error.new(e.message))
         end
       end
     end
@@ -89,7 +90,7 @@ module Twterm
     end
 
     def user_stream_connected!
-      publish(Event::Notification.new(:message, 'Connection established')) unless user_stream_connected?
+      publish(Event::Notification::Info.new('Connection established')) unless user_stream_connected?
       @user_stream_connected = true
     end
 

data/lib/twterm/tab/base.rb

@@ -1,4 +1,7 @@
+require 'concurrent'
+
 require 'twterm/event/screen/resize'
+require 'twterm/image'
 require 'twterm/subscriber'
 
 module Twterm
@@ -19,13 +22,45 @@ module Twterm
         window.close
       end
 
-      def initialize
+      def find_or_fetch_status(id)
+        status = app.status_repository.find(id)
+
+        if status
+          Concurrent::Promise.fulfill(status)
+        else
+          client.show_status(id)
+        end
+      end
+
+      def find_or_fetch_list(id)
+        list = app.list_repository.find(id)
+
+        if list
+          Concurrent::Promise.fulfill(list)
+        else
+          client.list(id)
+        end
+      end
+
+      def find_or_fetch_user(id)
+        user = app.user_repository.find(id)
+
+        if user
+          Concurrent::Promise.fulfill(user)
+        else
+          client.show_user(id)
+        end
+      end
+
+      def initialize(app, client)
+        @app, @client = app, client
+
         @window = stdscr.subwin(stdscr.maxy - 5, stdscr.maxx, 3, 0)
 
         subscribe(Event::Screen::Resize, :resize)
       end
 
-      def refresh
+      def render
         Thread.new do
           refresh_mutex.synchronize do
             window.clear
@@ -38,8 +73,7 @@ module Twterm
               end
             end
 
-            update
-            window.refresh
+            view.at(1, 2).render
           end if refreshable?
         end
       end
@@ -50,11 +84,17 @@ module Twterm
 
       def title=(title)
         @title = title
-        TabManager.instance.refresh_window
+        app.tab_manager.refresh_window
       end
 
       private
 
+      attr_reader :app, :client
+
+      def image
+        Image.string('view method is not implemented')
+      end
+
       def refresh_mutex
         @refresh_mutex ||= Mutex.new
       end
@@ -63,7 +103,7 @@ module Twterm
         !(
           refresh_mutex.locked? ||
             closed? ||
-            TabManager.instance.current_tab.object_id != object_id
+            app.tab_manager.current_tab.object_id != object_id
         )
       end
 
@@ -72,8 +112,8 @@ module Twterm
         window.move(3, 0)
       end
 
-      def update
-        fail NotImplementedError, 'update method must be implemented'
+      def view
+        View.new(window, image)
       end
     end
   end

data/lib/twterm/tab/direct_message/conversation.rb

@@ -2,49 +2,83 @@ require 'twterm/direct_message_composer'
 require 'twterm/event/direct_message/fetched'
 require 'twterm/subscriber'
 require 'twterm/tab/base'
+require 'twterm/tab/loadable'
+require 'twterm/tab/searchable'
 
 module Twterm
   module Tab
     module DirectMessage
       class Conversation < Base
-        include FilterableList
-        include Scrollable
+        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, :+)
-            .select { |l| l < window.maxy }
+            .each_cons(2)
+            .select { |_, l| l < window.maxy }
             .count
         end
 
-        def initialize(conversation)
-          super()
+        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 = [
+              !Image.string(sender.name).color(sender.color),
+              Image.string("@#{sender.screen_name}").parens,
+              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) { refresh }
+          subscribe(Event::DirectMessage::Fetched) { initially_loaded! }
         end
 
         def items
-          if filter_query.empty?
-            messages
-          else
-            messages.select { |m| m.matches?(filter_query) }
-          end
+          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 ?/
-            filter
-          when ?n, ?r
-            DirectMessageComposer.instance.compose(conversation.collocutor)
-          when ?q
-            reset_filter
+          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
@@ -52,42 +86,9 @@ module Twterm
           true
         end
 
-        def update
-          line = 0
-
-          scroller.drawable_items.each.with_index(0) do |message, i|
-            formatted_lines = message.text.split_by_width(window.maxx - 4).count
-
-            window.with_color(:black, :magenta) do
-              formatted_lines.+(1).times do |j|
-                window.setpos(line + j, 0)
-                window.addch(' ')
-              end
-            end if scroller.current_item?(i)
-
-            window.setpos(line, 2)
-
-            window.bold do
-              window.with_color(message.sender.color) do
-                window.addstr(message.sender.name)
-              end
-            end
-
-            window.addstr(' (@%s)' % message.sender.screen_name)
-            window.addstr(' [%s]' % message.date)
-
-            message.text.split_by_width(window.maxx - 4).each do |str|
-              line += 1
-              window.setpos(line, 2)
-              window.addstr(str)
-            end
-
-            line += 2
-          end
-        end
-
         def title
-          '@%s messages' % conversation.collocutor.screen_name
+          collocutor = app.user_repository.find(conversation.collocutor_id)
+          '@%s messages' % collocutor.screen_name
         end
 
         private

data/lib/twterm/tab/direct_message/conversation_list.rb

@@ -2,24 +2,47 @@ require 'twterm/direct_message_composer'
 require 'twterm/event/direct_message/fetched'
 require 'twterm/subscriber'
 require 'twterm/tab/base'
+require 'twterm/tab/loadable'
 require 'twterm/tab/direct_message/conversation'
 
 module Twterm
   module Tab
     module DirectMessage
       class ConversationList < Base
-        include FilterableList
-        include Scrollable
+        include Loadable
+        include Searchable
         include Subscriber
 
         def drawable_item_count
           window.maxy.-(2).div(3)
         end
 
-        def initialize
-          super
+        def image
+          return Image.string(initially_loaded? ? 'No results found' : 'Loading...') if items.empty?
 
-          subscribe(Event::DirectMessage::Fetched) { refresh }
+          scroller.drawable_items.map.with_index(0) do |conversation, i|
+            cursor = Image.cursor(2, scroller.current_index?(i))
+
+            collocutor = app.user_repository.find(conversation.collocutor_id)
+
+            header = [
+              !Image.string(collocutor.name).color(collocutor.color),
+              Image.string("@#{collocutor.screen_name}").parens,
+              Image.string(conversation.updated_at.to_s).brackets,
+            ].intersperse(Image.whitespace).reduce(Image.empty, :-)
+
+            body = Image.string(conversation.preview.split_by_width(window.maxx - 4).first)
+
+            cursor - Image.whitespace - (header | body)
+          end
+            .intersperse(Image.blank_line)
+            .reduce(Image.empty, :|)
+        end
+
+        def initialize(app, client)
+          super(app, client)
+
+          subscribe(Event::DirectMessage::Fetched) { initially_loaded! }
         end
 
         def ==(other)
@@ -27,26 +50,31 @@ module Twterm
         end
 
         def items
-          if filter_query.empty?
-            Client.current.direct_message_conversations
-          else
-            Client.current.direct_message_conversations.select { |c| c.matches?(filter_query) }
-          end
+          client.direct_message_conversations
+        end
+
+        def matches?(conversation, query)
+          collocutor = app.user_repository.find(conversation.collocutor_id)
+
+          [
+            collocutor.name,
+            collocutor.screen_name,
+            conversation.preview
+          ].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 10
             open_conversation
-          when ?n, ?r
+          when k[:status, :compose], k[:status, :reply]
             conversation = current_item
-            DirectMessageComposer.instance.compose(conversation.collocutor)
-          when ?/
-            filter
-          when ?q
-            reset_filter
+            collocutor = app.user_repository.find(conversation.collocutor_id)
+            app.direct_message_composer.compose(collocutor)
           else
             return false
           end
@@ -54,33 +82,6 @@ module Twterm
           true
         end
 
-        def update
-          scroller.drawable_items.each.with_index(0) do |conversation, i|
-            line = 3 * i
-
-            window.with_color(:black, :magenta) do
-              2.times do |j|
-                window.setpos(line + j, 0)
-                window.addch(' ')
-              end
-            end if scroller.current_item?(i)
-
-            window.setpos(line, 2)
-
-            window.bold do
-              window.with_color(conversation.collocutor.color) do
-                window.addstr(conversation.collocutor.name)
-              end
-            end
-
-            window.addstr(' (@%s)' % conversation.collocutor.screen_name)
-            window.addstr(' [%s]' % conversation.updated_at)
-
-            window.setpos(line + 1, 2)
-            window.addstr(conversation.preview.split_by_width(window.maxx - 4).first)
-          end
-        end
-
         def title
           'Direct Messages'
         end
@@ -90,8 +91,8 @@ module Twterm
         def open_conversation
           conversation = scroller.current_item
 
-          tab = Tab::DirectMessage::Conversation.new(conversation)
-          TabManager.instance.add_and_show(tab)
+          tab = Tab::DirectMessage::Conversation.new(app, client, conversation)
+          app.tab_manager.add_and_show(tab)
         end
       end
     end

data/lib/twterm/tab/dumpable.rb

@@ -2,7 +2,7 @@ module Twterm
   module Tab
     module Dumpable
       def dump
-        fail NotImplementedError 'dump method must be implemented'
+        fail NotImplementedError, 'dump method must be implemented'
       end
 
       def self.included(klass)
@@ -10,8 +10,8 @@ module Twterm
       end
 
       module ClassMethods
-        def recover(title, arg)
-          tab = new(arg)
+        def recover(app, client, title, arg)
+          tab = new(app, client, arg)
           tab.title = title
           tab
         end