twterm 1.3.0 → 2.0.0.beta1

data/lib/twterm/key_mapper/tab_key_mapper.rb

@@ -0,0 +1,31 @@
+require 'twterm/key_mapper/abstract_key_mapper'
+
+module Twterm
+  class KeyMapper
+    class TabKeyMapper < Twterm::KeyMapper::AbstractKeyMapper
+      DEFAULT_MAPPINGS = {
+        :'1st' => '1',
+        :'2nd' => '2',
+        :'3rd' => '3',
+        :'4th' => '4',
+        :'5th' => '5',
+        :'6th' => '6',
+        :'7th' => '7',
+        :'8th' => '8',
+        :'9th' => '9',
+        close: 'w',
+        find_next: 'n',
+        find_previous: 'N',
+        last: '0',
+        new: '^T',
+        reload: '^R',
+        search_down: '/',
+        search_up: '?',
+      }.freeze
+
+      def self.category
+        'tab'.freeze
+      end
+    end
+  end
+end

data/lib/twterm/key_mapper.rb

@@ -0,0 +1,127 @@
+require 'toml'
+require 'singleton'
+
+require 'twterm/app'
+require 'twterm/key_mapper/abstract_key_mapper'
+require 'twterm/key_mapper/app_key_mapper'
+require 'twterm/key_mapper/cursor_key_mapper'
+require 'twterm/key_mapper/general_key_mapper.rb'
+require 'twterm/key_mapper/no_such_command'
+require 'twterm/key_mapper/no_such_key'
+require 'twterm/key_mapper/status_key_mapper.rb'
+require 'twterm/key_mapper/tab_key_mapper'
+
+module Twterm
+  class KeyMapper
+    include Singleton
+
+    MAPPERS = {
+      app: AppKeyMapper,
+      cursor: CursorKeyMapper,
+      general: GeneralKeyMapper,
+      status: StatusKeyMapper,
+      tab: TabKeyMapper,
+    }.freeze
+
+    def initialize
+      create_default_dict_file! unless dict_file_exists?
+      load_dict_file!
+    end
+
+    def [](category, kind)
+      (@mappings[category] || {})[kind]
+    end
+
+    def as_string(category, kind)
+      key = self[category, kind]
+
+      case key
+      when '!'..'}' then key
+      when Curses::Key::F1 then 'F1'
+      when Curses::Key::F2 then 'F2'
+      when Curses::Key::F3 then 'F3'
+      when Curses::Key::F4 then 'F4'
+      when Curses::Key::F5 then 'F5'
+      when Curses::Key::F6 then 'F6'
+      when Curses::Key::F7 then 'F7'
+      when Curses::Key::F8 then 'F8'
+      when Curses::Key::F9 then 'F9'
+      when Curses::Key::F10 then 'F10'
+      when Curses::Key::F11 then 'F11'
+      when Curses::Key::F12 then 'F12'
+      when 1..26 then "^#{(key + 'A'.ord - 1).chr}"
+      else ''
+      end
+    end
+
+    private
+
+    def assign_mappings!(dict)
+      @mappings = MAPPERS
+        .map { |c, m| { c => m.new(dict[c]) } }
+        .reduce({}) { |acc, x| acc.merge(x) }
+    rescue NoSuchCommand => e
+      warn "Unrecognized command detected: #{e.full_command}"
+      warn 'Make sure you have specified the correct command'
+      warn "Your key assignments are defined in #{dict_file_path}"
+
+      exit
+    rescue NoSuchKey => e
+      warn "Unrecognized key detected: #{e.key}"
+      warn 'Make sure you have specified the correct key'
+      warn "Your key assignments are defined in #{dict_file_path}"
+
+      exit
+    end
+
+    def create_default_dict_file!
+      dict = TOML.dump(default_mappings).gsub("\n[", "\n\n[")
+      File.open(dict_file_path, 'w', 0644) { |f| f.write(dict) }
+    end
+
+    def default_mappings
+      MAPPERS.map { |key, klass| [key, klass::DEFAULT_MAPPINGS] }.to_h
+    end
+
+    def dict_file_exists?
+      File.exist?(dict_file_path)
+    end
+
+    def dict_file_path
+      "#{App::DATA_DIR}/keys.toml".freeze
+    end
+
+    def getc
+      system('stty raw -echo')
+      STDIN.getc
+    ensure
+      system('stty -raw echo')
+    end
+
+    def load_dict_file!
+      dict = TOML.load_file(dict_file_path, symbolize_keys: true)
+    rescue TOML::ParseError, TOML::ValueOverwriteError => e
+      first_line =
+        case e
+        when TOML::ParseError
+          "Your key assignments dictionary file (#{dict_file_path}) could not be parsed"
+        when TOML::ValueOverwriteError
+          "Command `#{e.key}` is declared more than once"
+        end
+
+      warn <<-EOS
+#{first_line}
+Falling back to the default key assignments
+
+Check the syntax and edit the file manually,
+or remove it and launch twterm again to restore
+
+Press any key to continue
+      EOS
+
+      getc
+    ensure
+      assign_mappings!(dict || default_mappings)
+    end
+  end
+end

data/lib/twterm/list.rb

@@ -2,8 +2,6 @@ module Twterm
   class List
     attr_reader :id, :name, :slug, :full_name, :mode, :description, :member_count, :subscriber_count
 
-    @@instances = {}
-
     def ==(other)
       other.is_a?(self.class) && id == other.id
     end
@@ -11,13 +9,6 @@ module Twterm
     def initialize(list)
       @id = list.id
       update!(list)
-
-      @@instances[@id] = self
-      self
-    end
-
-    def matches?(query)
-      [full_name, description].any? { |x| x.downcase.include?(query.downcase) }
     end
 
     def update!(list)
@@ -31,27 +22,5 @@ module Twterm
 
       self
     end
-
-    def self.all
-      @@instances.values
-    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.list(id).then { |list| resolve.(list) }
-      end
-    end
-
-    def self.new(list)
-      instance = find(list.id)
-      instance.nil? ? super : instance.update!(list)
-    end
   end
 end

data/lib/twterm/notifier.rb

@@ -1,6 +1,6 @@
 require 'twterm/subscriber'
 require 'twterm/event/favorite'
-require 'twterm/event/notification'
+require 'twterm/event/notification/abstract_notification'
 require 'twterm/event/screen/resize'
 
 module Twterm
@@ -14,15 +14,15 @@ module Twterm
       @queue = Queue.new
 
       subscribe(Event::Favorite) do |e|
-        break if e.source.id == e.authenticating_user.user_id
+        next if e.source.id == e.authenticating_user.user_id
 
         msg = '@%s has favorited your tweet: %s' % [
           e.source.screen_name, e.target.text
         ]
-        show_message(msg)
+        show_info(msg)
       end
 
-      subscribe(Event::Notification) do |e|
+      subscribe(Event::Notification::AbstractNotification) do |e|
         queue(e)
       end
 
@@ -37,8 +37,8 @@ module Twterm
       end
     end
 
-    def show_message(message)
-      notification = Event::Notification.new(:message, message)
+    def show_info(message)
+      notification = Event::Notification::Info.new(message)
       @queue.push(notification)
       self
     end
@@ -51,7 +51,7 @@ module Twterm
 
       @window.clear
 
-      if notification.is_a?(Event::Notification)
+      if notification.is_a?(Event::Notification::AbstractNotification)
         fg_color, bg_color = notification.color
 
         @window.with_color(fg_color, bg_color) do

data/lib/twterm/repository/abstract_entity_repository.rb

@@ -0,0 +1,41 @@
+require 'concurrent'
+
+require 'twterm/repository/abstract_repository'
+
+module Twterm
+  module Repository
+    class AbstractEntityRepository < AbstractRepository
+      def create(*args)
+        invoke_callbacks(:before_create, *args)
+
+        existing_instance = find(extract_key(args))
+
+        instance = existing_instance.nil? ? type.new(*args) : existing_instance.update!(*args)
+
+        store(instance)
+
+        invoke_callbacks(:after_create, instance)
+
+        instance
+      end
+
+      def find(key)
+        repository[key]
+      end
+
+      private
+
+      def empty_repository
+        Concurrent::Hash.new
+      end
+
+      def extract_key(args)
+        args[0].id
+      end
+
+      def store(instance)
+        repository[instance.id] = instance
+      end
+    end
+  end
+end

data/lib/twterm/repository/abstract_expirable_entity_repository.rb

@@ -0,0 +1,35 @@
+require 'concurrent'
+
+require 'twterm/repository/abstract_entity_repository'
+
+module Twterm
+  module Repository
+    class AbstractExpirableEntityRepository < AbstractEntityRepository
+      def initialize
+        super
+        @touched_at = Concurrent::Hash.new
+      end
+
+      def create(args, *)
+        touch(args.id)
+        super
+      end
+
+      def find(id)
+        touch(id)
+        super
+      end
+
+      def expire(threshold)
+        now = Time.now
+        repository.delete_if { |id, _| !@touched_at[id] || @touched_at[id] + threshold < now }
+      end
+
+      private
+
+      def touch(id)
+        @touched_at[id] = Time.now
+      end
+    end
+  end
+end

data/lib/twterm/repository/abstract_repository.rb

@@ -0,0 +1,64 @@
+module Twterm
+  module Repository
+    class AbstractRepository
+      def initialize
+        @repository = empty_repository
+
+        @callbacks = {
+          after_create: [],
+          before_create: [],
+        }
+      end
+
+      def after_create(&block)
+        @callbacks[:after_create] << block
+      end
+
+      def before_create(&block)
+        @callbacks[:before_create] << block
+      end
+
+      def create(*args)
+        invoke_callbacks(:before_create, *args)
+
+        existing_instance = find(extract_key(args))
+
+        instance = existing_instance.nil? ? type.new(*args) : existing_instance
+
+        store(instance) if existing_instance.nil?
+
+        invoke_callbacks(:after_create, instance)
+
+        instance
+      end
+
+      def find(_key)
+        raise NotImplementedError, '`find` must be implemented'
+      end
+
+      def type
+        raise NotImplementedError, '`type` must be implemented'
+      end
+
+      private
+
+      attr_reader :repository
+
+      def empty_repository
+        raise NotImplementedError, '`empty_repository` must be implemented'
+      end
+
+      def extract_key(_args)
+        raise NotImplementedError, '`extract_key` must be implemented'
+      end
+
+      def invoke_callbacks(type, *args)
+        @callbacks[type].each { |cb| cb.call(*args) }
+      end
+
+      def store(_instance)
+        raise NotImplementedError, '`store` must be implemented'
+      end
+    end
+  end
+end

data/lib/twterm/repository/direct_message_repository.rb

@@ -0,0 +1,14 @@
+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/repository/friendship_repository.rb

@@ -0,0 +1,108 @@
+require 'concurrent'
+
+require 'twterm/friendship'
+require 'twterm/repository//abstract_repository'
+
+module Twterm
+  module Repository
+    class FriendshipRepository < AbstractRepository
+      private :create
+
+      def initialize
+        super
+
+        @user_ids = Set.new
+        @m = Mutex.new
+      end
+
+      def already_looked_up?(user_id)
+        @m.synchronize { @user_ids.include?(user_id) }
+      end
+
+      def block(from, to)
+        create(:blocking, from, to)
+      end
+
+      def blocking?(from, to)
+        !find([:blocking, from, to]).nil?
+      end
+
+      def cancel_follow_request(from, to)
+        create(:following_requested, from, to)
+      end
+
+      def delete(status, from, to)
+        repository[status].delete_if { |f| f.status == status && f.from == from && f.to == to }
+      end
+
+      def follow(from, to)
+        create(:following, from, to)
+      end
+
+      def following?(from, to)
+        !find([:following, from, to]).nil?
+      end
+
+      def following_not_requested(from, to)
+        delete(:following_requested, from, to)
+      end
+
+      def following_requested(from, to)
+        create(:following_requested, from, to)
+      end
+
+      def following_requested?(from, to)
+        !find([:following_requested, from, to]).nil?
+      end
+
+      def looked_up!(user_id)
+        @m.synchronize { @user_ids << user_id }
+        user_id
+      end
+
+      def mute(from, to)
+        create(:muting, from, to)
+      end
+
+      def muting?(from, to)
+        !find([:muting, from, to]).nil?
+      end
+
+      def unblock(from, to)
+        delete(:blocking, from, to)
+      end
+
+      def unfollow(from, to)
+        delete(:following, from, to)
+      end
+
+      def unmute(from, to)
+        delete(:muting, from, to)
+      end
+
+      private
+
+      def find(key)
+        status, from, to = key
+
+        repository[status].find { |f| f.from == from && f.to == to }
+      end
+
+      def extract_key(args)
+        args
+      end
+
+      def empty_repository
+        Friendship::STATUSES.map { |s| [s, Concurrent::Array.new] }.to_h
+      end
+
+      def store(instance)
+        repository[instance.status] << instance
+      end
+
+      def type
+        Friendship
+      end
+    end
+  end
+end

data/lib/twterm/repository/hashtag_repository.rb

@@ -0,0 +1,39 @@
+require 'twterm/repository/abstract_repository'
+
+module Twterm
+  module Repository
+    class HashtagRepository < AbstractRepository
+      def initialize
+        @m = Mutex.new
+
+        super
+      end
+
+      def all
+        repository.to_a
+      end
+
+      private
+
+      def empty_repository
+        Set.new
+      end
+
+      def extract_key(args)
+        args[0]
+      end
+
+      def find(key)
+        repository.include?(key) ? key : nil
+      end
+
+      def store(hashtag)
+        @m.synchronize { repository << hashtag }
+      end
+
+      def type
+        String
+      end
+    end
+  end
+end

data/lib/twterm/repository/list_repository.rb

@@ -0,0 +1,14 @@
+require 'twterm/repository/abstract_entity_repository'
+require 'twterm/list'
+
+module Twterm
+  module Repository
+    class ListRepository < AbstractEntityRepository
+      private
+
+      def type
+        List
+      end
+    end
+  end
+end

data/lib/twterm/repository/status_repository.rb

@@ -0,0 +1,36 @@
+require 'twterm/repository/abstract_expirable_entity_repository'
+require 'twterm/status'
+
+module Twterm
+  module Repository
+    class StatusRepository < AbstractExpirableEntityRepository
+      def all
+        repository.values
+      end
+
+      def create(tweet, is_retweeted_status = false)
+        create(tweet.retweeted_status, true) unless tweet.retweeted_status.is_a?(Twitter::NullObject)
+        super
+      end
+
+      def delete(id)
+        @touched_at.delete(id)
+        repository.delete(id)
+      end
+
+      def find_replies_for(id)
+        repository.values.select { |s| s.in_reply_to_status_id == id }
+      end
+
+      def ids
+        repository.keys
+      end
+
+      private
+
+      def type
+        Status
+      end
+    end
+  end
+end

data/lib/twterm/repository/user_repository.rb

@@ -0,0 +1,22 @@
+require 'twterm/repository/abstract_expirable_entity_repository'
+require 'twterm/user'
+
+module Twterm
+  module Repository
+    class UserRepository < AbstractExpirableEntityRepository
+      def all
+        repository.values
+      end
+
+      def ids
+        repository.keys
+      end
+
+      private
+
+      def type
+        User
+      end
+    end
+  end
+end