twterm 1.0.12 → 1.1.0.beta1

data/lib/twterm/filterable_list.rb

@@ -12,7 +12,7 @@ module Twterm
         reset_filter
         Notifier.instance.show_error "No matches found: \"#{query}\""
       else
-        Notifier.instance.show_message "#{total_item_count} statuses found: \"#{filter_query}\""
+        Notifier.instance.show_message "#{total_item_count} items found: \"#{filter_query}\""
         scroller.move_to_top
       end
 
@@ -30,6 +30,7 @@ module Twterm
     def reset_filter
       FilterQueryWindow.instance.clear
       @filter_query = ''
+      refresh
     end
   end
 end

data/lib/twterm/friendship.rb

@@ -0,0 +1,124 @@
+module Twterm
+  class Friendship
+    STATUSES = %i(
+      blocking
+      following
+      following_requested
+      muting
+    ).freeze
+
+    attr_reader :status, :from, :to
+
+    @@instances = []
+    @@user_ids = Set.new
+
+    def initialize(status, from, to)
+      fail ArgumentError,
+        '' unless STATUSES.include? status
+
+      @status, @from, @to = status, from, to
+      @@instances << self
+    end
+
+    def blocking?
+      status?(:blocking)
+    end
+
+    def following?
+      status?(:following)
+    end
+
+    def following_requested?
+      status?(:following_requested)
+    end
+
+    def muting?
+      status?(:muting)
+    end
+
+    def self.already_looked_up?(user_id)
+      @@user_ids.include?(user_id)
+    end
+
+    def self.block(from, to)
+      new(:blocking, from, to)
+    end
+
+    def self.blocking?(from, to)
+      !find(:blocking, from, to).nil?
+    end
+
+    def self.cancel_follow_request(from, to)
+      new(:following_requested, from, to)
+    end
+
+    def self.delete(status, from, to)
+      cond = -> f { f.status == status && f.from == from && f.to == to }
+      @@instances.delete_if(&cond)
+    end
+    private_class_method :delete
+
+    def self.find(status, from, to)
+      cond = -> f { f.status == status && f.from == from && f.to == to }
+      @@instances.find(&cond)
+    end
+    private_class_method :find
+
+    def self.follow(from, to)
+      new(:following, from, to)
+    end
+
+    def self.following?(from, to)
+      !find(:following, from, to).nil?
+    end
+
+    def self.following_not_requested(from, to)
+      delete(:following_requested, from, to)
+    end
+
+    def self.following_requested(from, to)
+      new(:following_requested, from, to)
+    end
+
+    def self.following_requested?(from, to)
+      !find(:following_requested, from, to).nil?
+    end
+
+    def self.looked_up!(user_id)
+      @@user_ids << user_id
+      user_id
+    end
+
+    def self.mute(from, to)
+      new(:muting, from, to)
+    end
+
+    def self.muting?(from, to)
+      !find(:muting, from, to).nil?
+    end
+
+    def self.new(status, from, to)
+      instance = find(status, from, to)
+      instance.nil? ? super : instance
+    end
+    private_class_method :new
+
+    def self.unblock(from, to)
+      delete(:blocking, from, to)
+    end
+
+    def self.unfollow(from, to)
+      delete(:following, from, to)
+    end
+
+    def self.unmute(from, to)
+      delete(:muting, from, to)
+    end
+
+    private
+
+    def status?(status)
+      self.status == status
+    end
+  end
+end

data/lib/twterm/list.rb

@@ -41,10 +41,12 @@ module Twterm
     end
 
     def self.find_or_fetch(id)
-      instance = find(id)
-      (yield(instance) && return) if instance
+      Promise.new do |resolve, reject|
+        instance = find(id)
+        (resolve.(instance) && next) if instance
 
-      Client.current.list(id) { |list| yield list }
+        Client.current.list(id).then { |list| resolve.(list) }
+      end
     end
 
     def self.new(list)

data/lib/twterm/promise.rb

@@ -0,0 +1,143 @@
+module Twterm
+  class Promise
+    def initialize
+      @state = :pending
+      @callbacks = []
+
+      Thread.new do
+        yield method(:resolve), method(:reject)
+      end if block_given?
+    end
+
+    def catch(on_rejected = nil, &block)
+      if on_rejected.is_a?(Proc) && block_given?
+        fail ArgumentError, 'both proc and block cannot be passed at the same time'
+      end
+
+      on_rejected ||= block
+      self.then(nil, on_rejected)
+    end
+
+    def reject(reason)
+      return if settled?
+
+      @state = :rejected
+      @reason = reason
+
+      callbacks.each do |cb|
+        cb.invoke_on_rejected(reason)
+      end
+      self
+    end
+
+    def rejected?
+      state.eql? :rejected
+    end
+
+    def resolve(value)
+      return if settled?
+
+      @state = :fulfilled
+      @value = value
+
+      callbacks.each do |cb|
+        cb.invoke_on_fulfilled(value)
+      end
+      self
+    end
+
+    def then(on_fulfilled = nil, on_rejected = nil, &block)
+      if (on_fulfilled.is_a?(Proc) || on_rejected.is_a?(Proc)) && block_given?
+        fail ArgumentError, 'both procs and block cannot be passed at the same time'
+      end
+
+      on_fulfilled ||= block
+      next_promise = Promise.new
+      callback = Callback.new(
+        self,
+        on_fulfilled.is_a?(Proc) ? on_fulfilled : nil,
+        on_rejected.is_a?(Proc) ? on_rejected : nil,
+        next_promise
+      )
+      @callbacks << callback
+
+      callback.invoke_on_fulfilled(@value) if fulfilled?
+      callback.invoke_on_rejected(@reason) if rejected?
+
+      next_promise
+    end
+
+    def self.resolve(value)
+      Promise.new { |resolve, _| resolve.(value) }
+    end
+
+    private
+
+    attr_reader :callbacks, :errorbacks, :next_promises, :state
+
+    def fulfilled?
+      state.eql? :fulfilled
+    end
+
+    def pending?
+      state.eql? :pending
+    end
+
+    def rejected?
+      state.eql? :rejected
+    end
+
+    def settled?
+      !pending?
+    end
+
+    class Callback
+      def initialize(promise, on_fulfilled, on_rejected, next_promise)
+        @promise = promise
+        @on_fulfilled, @on_rejected = on_fulfilled, on_rejected
+        @next_promise = next_promise
+      end
+
+      def has_on_fulfilled?
+        !on_fulfilled.nil?
+      end
+
+      def has_on_rejected?
+        !on_rejected.nil?
+      end
+
+      def invoke_on_fulfilled(value)
+        if has_on_fulfilled?
+          new_value = on_fulfilled.(value)
+          next_promise.resolve(new_value)
+        else
+          next_promise.resolve(value)
+        end
+      rescue => reason
+        next_promise.reject(reason)
+      end
+
+      def invoke_on_rejected(reason)
+        unless has_on_rejected?
+          if has_on_fulfilled?
+            next_promise.reject(reason)
+          else
+            raise reason unless has_on_fulfilled?
+          end
+          return
+        end
+
+        begin
+          new_value = on_rejected.(reason)
+          next_promise.resolve(new_value)
+        rescue => reason
+          next_promise.reject(reason)
+        end
+      end
+
+      private
+
+      attr_reader :promise, :on_fulfilled, :on_rejected, :next_promise
+    end
+  end
+end

data/lib/twterm/screen.rb

@@ -16,7 +16,6 @@ module Twterm
     def refresh
       TabManager.instance.refresh_window
       TabManager.instance.current_tab.refresh
-      UserWindow.instance.refresh_window
       Notifier.instance.show
     end
 

data/lib/twterm/status.rb

@@ -35,18 +35,17 @@ module Twterm
     end
 
     def in_reply_to_status(&block)
-      if @in_reply_to_status_id.nil?
-        block.call(nil)
-        return
-      end
+      Promise.new do |resolve, reject|
+        (resolve.(nil) && next) if in_reply_to_status_id.nil?
 
-      status = Status.find(@in_reply_to_status_id)
-      unless status.nil?
-        block.call(status)
-        return
-      end
+        instance = Status.find(in_reply_to_status_id)
+        (resolve.(instance) && next) if instance
 
-      Client.current.show_status(@in_reply_to_status_id, &block)
+        Client.current.show_status(in_reply_to_status_id)
+        .then do |status|
+          resolve.(status)
+        end
+      end
     end
 
     def initialize(tweet)
@@ -131,7 +130,7 @@ module Twterm
 
     def self.cleanup
       TabManager.instance.each_tab do |tab|
-        tab.touch_statuses if tab.is_a?(Tab::StatusesTab)
+        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)
@@ -144,10 +143,12 @@ module Twterm
     end
 
     def self.find_or_fetch(id)
-      instance = find(id)
-      (yield(instance) && return) if instance
+      Promise.new do |resolve, reject|
+        instance = find(id)
+        (resolve.(instance) && next) if instance
 
-      Client.current.show_status(id) { |status| yield status }
+        Client.current.show_status(id) { |status| resolve.(status) }
+      end
     end
 
     def self.new(tweet)

data/lib/twterm/tab/base.rb

@@ -15,13 +15,22 @@ module Twterm
       end
 
       def initialize
-        @window = stdscr.subwin(stdscr.maxy - 5, stdscr.maxx - 30, 3, 0)
+        @window = stdscr.subwin(stdscr.maxy - 5, stdscr.maxx, 3, 0)
       end
 
       def refresh
         Thread.new do
           refresh_mutex.synchronize do
             window.clear
+
+            # avoid misalignment caused by some multibyte-characters
+            window.with_color(:black, :transparent) do
+              (0...window.maxy).each do |i|
+                window.setpos(i, 0)
+                window.addch(' ')
+              end
+            end
+
             update
             window.refresh
           end if refreshable?
@@ -32,6 +41,11 @@ module Twterm
         fail NotImplementedError, 'respond_to_key method must be implemented'
       end
 
+      def title=(title)
+        @title = title
+        TabManager.instance.refresh_window
+      end
+
       private
 
       def refresh_mutex

data/lib/twterm/tab/key_assignments_cheatsheet.rb

@@ -16,8 +16,7 @@ module Twterm
           '[j] [C-p] [DOWN]'  => 'Move down',
           '[k] [C-n] [UP]'    => 'Move up',
           '[u] [C-u]'         => 'Scroll up',
-          '[Q]'               => 'Quit twterm',
-          '[?]'               => 'Open key assignments cheatsheet'
+          '[Q]'               => 'Quit twterm'
         },
         'Tabs' => {
           '[h] [C-b] [LEFT]'  => 'Show previous tab',
@@ -36,6 +35,10 @@ module Twterm
           '[r]'               => 'Reply',
           '[R]'               => 'Retweet',
           '[U]'               => 'Show user'
+        },
+        'Others' => {
+          '[P]'               => 'View my profile',
+          '[?]'               => 'Open key assignments cheatsheet'
         }
       }
 
@@ -49,24 +52,9 @@ module Twterm
       end
 
       def respond_to_key(key)
-        case key
-        when ?d, 4
-          10.times { scroller.move_down }
-        when ?g
-          scroller.move_to_top
-        when ?G
-          scroller.move_to_bottom
-        when ?j, 14, Curses::Key::DOWN
-          scroller.move_down
-        when ?k, 16, Curses::Key::UP
-          scroller.move_up
-        when ?u, 21
-          10.times { scroller.move_up }
-        else
-          return false
-        end
+        return true if scroller.respond_to_key(key)
 
-        true
+        false
       end
 
       def title