twterm 1.3.0 → 2.0.0.beta1

data/lib/twterm/tab/rate_limit_status.rb

@@ -0,0 +1,84 @@
+require 'twterm/tab/loadable'
+
+module Twterm
+  module Tab
+    class RateLimitStatus < Tab::Base
+      include Loadable
+      include Scrollable
+
+      @@mutex = Mutex.new
+      @@status = nil
+
+      def initialize(app, client)
+        super(app, client)
+
+        scroller.set_no_cursor_mode!
+
+        @ticker = Scheduler.new(1) { render }
+
+        @scheduler = Scheduler.new(10) { fetch }
+
+        fetch.then { initially_loaded! }
+      end
+
+      def close
+        @scheduler.kill
+        @ticker.kill
+        super
+      end
+
+      def drawable_item_count
+        window.maxy - 2
+      end
+
+      def image
+        return Image.string('Loading...') unless initially_loaded?
+
+        items
+          .drop(scroller.offset)
+          .take(drawable_item_count)
+          .reduce(Image.empty, :|)
+      end
+
+      def items
+        return [] unless initially_loaded?
+
+        @@status[:resources].flat_map do |category, limits|
+          [
+            !Image.string(category.to_s.gsub('_', ' ')).color(:green),
+            Image.blank_line,
+            *limits.flat_map do |endpoint, data|
+              limit, remaining = data[:limit], data[:remaining]
+              t = Time.at(data[:reset])
+              diff = (t - Time.now).round
+
+              [
+                Image.string("  #{endpoint}").color(:cyan) - (
+                  limit == remaining \
+                    ? Image.empty
+                    : Image.string(" (Resets #{diff.positive? ? "in #{diff} seconds" : 'soon...'})")),
+                Image.string('  ') - Image.remaining_resource(remaining, limit, 50) - Image.string(" #{remaining}/#{limit}"),
+                Image.blank_line,
+              ]
+            end,
+            Image.blank_line,
+          ]
+        end
+      end
+
+      def respond_to_key(key)
+        scroller.respond_to_key(key)
+      end
+
+      def title
+        'Rate Limit Status'.freeze
+      end
+
+      private
+
+      def fetch
+        client.rate_limit_status.then { |status| @@mutex.synchronize { @@status = status } }
+      end
+    end
+  end
+end

data/lib/twterm/tab/scrollable.rb

@@ -9,9 +9,9 @@ module Twterm
       def scroller
         return @scroller unless @scroller.nil?
 
-        @scroller = Scroller.new
+        @scroller = self.class::Scroller.new(self)
         @scroller.delegate = self
-        @scroller.after_move { refresh }
+        @scroller.after_move { render }
         @scroller
       end
 
@@ -21,10 +21,9 @@ module Twterm
         items.count
       end
 
-      private
-
       class Scroller
         extend Forwardable
+        include Publisher
 
         attr_reader :index, :offset
 
@@ -35,19 +34,21 @@ module Twterm
           add_hook(:after_move, &block)
         end
 
-        def current_item
-          items[index]
+        def current_index?(i)
+          index == offset + i
         end
 
-        def current_item?(i)
-          index == offset + i
+        def current_item
+          items[index]
         end
 
         def no_cursor_mode?
           !!@no_cursor_mode
         end
 
-        def initialize
+        def initialize(tab)
+          @tab = tab
+
           @index = 0
           @offset = 0
           @no_cursor_mode = false
@@ -58,7 +59,6 @@ module Twterm
         end
 
         def item_appended!
-          @index -= 1
           @offset -= 1 if @offset > 0
         end
 
@@ -69,7 +69,7 @@ module Twterm
         end
 
         def move_down
-          return if count == 0 || index == count - 1
+          return if count == 0 || index == count - 1 || (no_cursor_mode? && offset + drawable_item_count >= count)
           # return when there are no items or cursor is at the bottom
 
           @index += 1
@@ -81,7 +81,7 @@ module Twterm
         def move_to_bottom
           return if count == 0 || index == count - 1
 
-          @index = count - 1
+          @index = no_cursor_mode? ? count - drawable_item_count : count - 1
           @offset = [count - drawable_item_count + 1, 0].max
 
           @offset += 1 until last_item_shown?
@@ -89,6 +89,16 @@ module Twterm
           hook :after_move
         end
 
+        def move_to(n)
+          if nth_item_drawable?(n)
+            @index = n
+          else
+            @index = @offset = n
+          end
+
+          hook :after_move
+        end
+
         def move_to_top
           return if count.zero? || index.zero?
 
@@ -108,23 +118,31 @@ module Twterm
         end
 
         def nth_item_drawable?(n)
-          n.between?(offset, offset + drawable_item_count)
+          n.between?(offset, offset + drawable_item_count - 1)
         end
 
         def respond_to_key(key)
+          k = KeyMapper.instance
+
           case key
-          when ?d, 4
+          when k[:general, :page_down]
             10.times { move_down }
-          when ?g
+          when k[:general, :top]
             move_to_top
-          when ?G
+          when k[:general, :bottom]
             move_to_bottom
-          when ?j, 14, Curses::Key::DOWN
+          when k[:general, :down], Curses::Key::DOWN
             move_down
-          when ?k, 16, Curses::Key::UP
+          when k[:general, :up], Curses::Key::UP
             move_up
-          when ?u, 21
+          when k[:general, :page_up]
             10.times { move_up }
+          when k[:cursor, :top_of_window]
+            move_to(offset)
+          when k[:cursor, :middle_of_window]
+            move_to((2 * offset + [drawable_item_count, total_item_count - offset].min - 1) / 2)
+          when k[:cursor, :bottom_of_window]
+            move_to(offset + [drawable_item_count, total_item_count - offset].min - 1)
           else
             return false
           end
@@ -138,6 +156,8 @@ module Twterm
 
         private
 
+        attr_reader :tab
+
         def add_hook(name, &block)
           @hooks ||= {}
           @hooks[name] = block

data/lib/twterm/tab/searchable.rb

@@ -0,0 +1,133 @@
+require 'twterm/event/notification/info'
+require 'twterm/event/notification/warning'
+require 'twterm/search_query_window'
+
+module Twterm
+  module Tab
+    module Searchable
+      include Scrollable
+      extend Forwardable
+
+      def_delegators :scroller, :search_query
+
+      def matches?(item, query)
+        raise NotImplementedError, '`matches?` method must be implemented'
+      end
+
+      class Scroller < Scrollable::Scroller
+        extend Forwardable
+        include Publisher
+
+        attr_reader :search_query
+
+        def_delegators :search_query_window,
+                       :searching_backward!, :searching_backward?,
+                       :searching_down!, :searching_down?,
+                       :searching_forward!, :searching_forward?,
+                       :searching_up!, :searching_up?
+
+        def initialize(*)
+          super
+          @search_query = ''
+        end
+
+        def find_next
+          searching_forward!
+
+          search_query_window.render_last_query
+          search
+        end
+
+        def find_previous
+          searching_backward!
+
+          search_query_window.render_last_query
+          search
+        end
+
+        def respond_to_key(key)
+          k = KeyMapper.instance
+
+          return if super
+
+          case key
+          when k[:tab, :find_next]
+            find_next
+          when k[:tab, :find_previous]
+            find_previous
+          when k[:tab, :search_down]
+            search_down
+          when k[:tab, :search_up]
+            search_up
+          else
+            return false
+          end
+
+          true
+        end
+
+        def search_up
+          searching_up!
+          searching_forward!
+          ask
+
+          return if search_query.empty?
+
+          find_next
+        end
+
+        def search_down
+          searching_down!
+          searching_forward!
+          ask
+
+          return if search_query.empty?
+
+          find_next
+        end
+
+        private
+
+        def ask
+          @search_query = search_query_window.input || ''
+        end
+
+        def search
+          @search_query = search_query_window.last_query if search_query.empty?
+
+          if @search_query.empty?
+            event = Event::Notification::Info.new("search query is empty. Press '/' or '?' to start searching.")
+            publish(event)
+            return
+          end
+
+          f = searching_down? ^ searching_forward? ? -> xs { xs.reverse } : -> xs { xs }
+          previous_index = index
+
+          xs = [
+            *f.(items.each_with_index.drop(index.succ) + items.each_with_index.take(index)),
+            [current_item, index]
+          ]
+          _, index = xs.find { |x, _| tab.matches?(x, search_query) }
+
+          if index.nil?
+            publish(Event::Notification::Warning.new("No matches found: \"#{search_query}\""))
+          else
+            hit_bottom = Event::Notification::Info.new('search hit BOTTOM, continuing at TOP')
+            hit_top = Event::Notification::Info.new('search hit TOP, continuing at BOTTOM')
+
+            publish(hit_bottom) if (searching_down? ^ searching_backward?) && index <= previous_index
+            publish(hit_top) if (searching_up? ^ searching_backward?) && index >= previous_index
+            move_to(index)
+          end
+        end
+
+        def search_query_window
+          SearchQueryWindow.instance
+        end
+
+        alias_method :count, :total_item_count
+      end
+    end
+  end
+end