twterm 1.0.9 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b7f3f957fa6bb231072502fd2794d212db4547e
-  data.tar.gz: 83aecc6b84ed61620f52b69f6b65c91b6d1af67b
+  metadata.gz: 8d067153f4c632aeba6108ea07201aff1db4790c
+  data.tar.gz: d6ddac0119221c40646bae8bd53bf19081ddab1b
 SHA512:
-  metadata.gz: e3b1748a40af7f4a32b93568422e0cd65dbe6a9e7a12818567e8aff5142639af6396df93febdffd0f93a19afd9020bf4ac5f86ad468f60b00c5e8cdb597ee5ee
-  data.tar.gz: 6df0822a5f0d59a9f1e2e260e2e43a2b5997a7a36426f5dc786f85283514c9d44ddd9ca74dc41fd7ff1fbc83085bf2eb84a6b4af8b12f33b3438a91ec7d3438c
+  metadata.gz: dcd02ff35df547ca1383dfe70ac5a097c4ca0d91448ec0a79a4557084a84a14b24961c190697d30f428b1053db710fcd4030fcb9350a0a12111dd1c6eeec0dba
+  data.tar.gz: d37de57e07ad39327df4864b961a141e146a00d6956f43391c2e9cf4843e5d4d80a78d4666204edfeb32c4fbc7dd0ab73692a6e847a3d060bb4a57271629848c

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--color

data/README.md

@@ -8,7 +8,7 @@ A full-featured CLI Twitter client
 
 ## Requirements
 
-- Ruby (compiled with C Curses and Readline)
+- Ruby (>= 2.1, compiled with C Curses and Readline)
 - C curses
 - Readline
 
@@ -18,12 +18,34 @@ A full-featured CLI Twitter client
 $ gem install twterm
 ```
 
-## Execution
+## Usage
+
+To launch twterm, just type in your console:
 
 ```
 $ twterm
 ```
 
+### Basic key assignments
+
+key | operation
+--- | ---
+`F` | add to favorite
+`d` `C-d` | scroll down
+`h` `C-b` `←` | show previous tab
+`j` `C-n` `↓` | move down
+`k` `C-p` `↑` | move up
+`l` `C-f` `→` | show next tab
+`n` | compose new tweet
+`N` | open new tab
+`r` | reply
+`R` | retweet
+`w` | close current tab
+`Q` | quit
+`?` | open key assignments cheatsheet
+
+Type `?` key to see the full list of key assignments.
+
 ## License
 
 See the LICENSE file for license rights and limitations (MIT).

data/lib/twterm/app.rb

@@ -7,13 +7,10 @@ module Twterm
     def initialize
       Dir.mkdir(DATA_DIR, 0700) unless File.directory?(DATA_DIR)
 
-      Config.load
-      Auth.authenticate_user if Config[:screen_name].nil?
+      Auth.authenticate_user(config) if config[:screen_name].nil?
 
       Screen.instance
 
-      client = Client.new(Config[:user_id], Config[:screen_name], Config[:access_token], Config[:access_token_secret])
-
       timeline = Tab::TimelineTab.new(client)
       TabManager.instance.add_and_show(timeline)
 
@@ -53,6 +50,19 @@ module Twterm
 
     private
 
+    def client
+      @client ||= Client.new(
+        config[:user_id].to_i,
+        config[:screen_name],
+        config[:access_token],
+        config[:access_token_secret]
+      )
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
     def run_periodic_cleanup
       Scheduler.new(300) do
         Status.cleanup

data/lib/twterm/auth.rb

@@ -1,6 +1,6 @@
 module Twterm
   module Auth
-    def authenticate_user
+    def authenticate_user(config)
       consumer = OAuth::Consumer.new(
         'vLNSVFgXclBJQJRZ7VLMxL9lA',
         'OFLKzrepRG2p1hq0nUB9j2S9ndFQoNTPheTpmOY0GYw55jGgS5',
@@ -17,10 +17,10 @@ module Twterm
       pin = (STDIN.gets || '').strip
       access_token = request_token.get_access_token(oauth_verifier: pin)
 
-      Config[:access_token] = access_token.token
-      Config[:access_token_secret] = access_token.secret
-      Config[:screen_name] = access_token.params[:screen_name]
-      Config[:user_id] = access_token.params[:user_id]
+      config[:access_token] = access_token.token
+      config[:access_token_secret] = access_token.secret
+      config[:screen_name] = access_token.params[:screen_name]
+      config[:user_id] = access_token.params[:user_id]
     end
 
     module_function :authenticate_user

data/lib/twterm/client.rb

@@ -3,146 +3,191 @@ module Twterm
     attr_reader :user_id, :screen_name
 
     CREATE_STATUS_PROC = -> (s) { Status.new(s) }
+    CONSUMER_KEY = 'vLNSVFgXclBJQJRZ7VLMxL9lA'.freeze
+    CONSUMER_SECRET = 'OFLKzrepRG2p1hq0nUB9j2S9ndFQoNTPheTpmOY0GYw55jGgS5'.freeze
 
     @@instances = []
 
-    def initialize(user_id, screen_name, token, secret)
-      @user_id = user_id
-      @screen_name = screen_name
+    def connect_stream
+      stream_client.stop_stream
 
-      @rest_client = Twitter::REST::Client.new do |config|
-        config.consumer_key        = 'vLNSVFgXclBJQJRZ7VLMxL9lA'
-        config.consumer_secret     = 'OFLKzrepRG2p1hq0nUB9j2S9ndFQoNTPheTpmOY0GYw55jGgS5'
-        config.access_token        = token
-        config.access_token_secret = secret
+      @streaming_thread = Thread.new do
+        begin
+          Notifier.instance.show_message 'Trying to connect to Twitter...'
+          stream_client.userstream
+        rescue EventMachine::ConnectionError
+          Notifier.instance.show_error 'Connection failed'
+          sleep 30
+          retry
+        end
       end
+    end
 
-      TweetStream.configure do |config|
-        config.consumer_key       = 'vLNSVFgXclBJQJRZ7VLMxL9lA'
-        config.consumer_secret    = 'OFLKzrepRG2p1hq0nUB9j2S9ndFQoNTPheTpmOY0GYw55jGgS5'
-        config.oauth_token        = token
-        config.oauth_token_secret = secret
-        config.auth_method        = :oauth
+    def destroy_status(status)
+      send_request do
+        begin
+          rest_client.destroy_status(status.id)
+          yield if block_given?
+        rescue Twitter::Error::NotFound, Twitter::Error::Forbidden
+          Notifier.instance.show_error 'You cannot destroy that status'
+        end
       end
+    end
 
-      @stream_client = TweetStream::Client.new
-
-      @callbacks = {}
+    def favorite(status)
+      return false unless status.is_a? Status
 
-      @mute_filter = -> _ { true }
-      fetch_muted_users do |muted_user_ids|
-        @mute_filter = lambda do |status|
-          !muted_user_ids.include?(status.user.id) &&
-            !(status.retweeted_status.is_a?(Twitter::NullObject) &&
-            muted_user_ids.include?(status.retweeted_status.user.id))
-        end
+      send_request do
+        rest_client.favorite(status.id)
+        status.favorite!
+        yield status if block_given?
       end
 
-      @@instances << self
+      self
     end
 
-    def stream
-      @stream_client.on_friends do
-        Notifier.instance.show_message 'Connection established' unless @stream_connected
-        @stream_connected = true
+    def fetch_muted_users
+      send_request do
+        @muted_user_ids = rest_client.muted_ids.to_a
+        yield @muted_user_ids if block_given?
       end
+    end
 
-      @stream_client.on_timeline_status do |tweet|
-        status = Status.new(tweet)
-        invoke_callbacks(:timeline_status, status)
-        invoke_callbacks(:mention, status) if status.text.include? "@#{@screen_name}"
+    def home_timeline
+      send_request do
+        statuses = rest_client
+          .home_timeline(count: 100)
+          .select(&@mute_filter)
+          .map(&CREATE_STATUS_PROC)
+        yield statuses
       end
+    end
 
-      @stream_client.on_delete do |status_id|
-        timeline.delete_status(status_id)
-      end
+    def initialize(user_id, screen_name, access_token, access_token_secret)
+      @user_id, @screen_name = user_id, screen_name
+      @access_token, @access_token_secret = access_token, access_token_secret
 
-      @stream_client.on_event(:favorite) do |event|
-        break if event[:source][:screen_name] == @screen_name
-        message = "@#{event[:source][:screen_name]} has favorited your tweet: #{event[:target_object][:text]}"
-        Notifier.instance.show_message(message)
-      end
+      @callbacks = {}
 
-      @stream_client.on_no_data_received do
-        @stream_connected = false
-        connect_stream
+      @mute_filter = -> _ { true }
+      fetch_muted_users do |muted_user_ids|
+        @mute_filter = lambda do |status|
+          !muted_user_ids.include?(status.user.id) &&
+            !(status.retweeted_status.is_a?(Twitter::NullObject) &&
+            muted_user_ids.include?(status.retweeted_status.user.id))
+        end
       end
 
-      connect_stream
+      @@instances << self
     end
 
-    def connect_stream
-      @stream_client.stop_stream
-
-      @streaming_thread = Thread.new do
-        begin
-          Notifier.instance.show_message 'Trying to connect to Twitter...'
-          @stream_client.userstream
-        rescue EventMachine::ConnectionError
-          Notifier.instance.show_error 'Connection failed'
-          sleep 30
-          retry
-        end
+    def list(list_id)
+      send_request do
+        yield List.new(rest_client.list(list_id))
       end
     end
 
-    def post(text, in_reply_to = nil)
+    def list_timeline(list)
+      fail ArgumentError,
+        'argument must be an instance of List class' unless list.is_a? List
       send_request do
-        if in_reply_to.is_a? Status
-          text = "@#{in_reply_to.user.screen_name} #{text}"
-          @rest_client.update(text, in_reply_to_status_id: in_reply_to.id)
-        else
-          @rest_client.update(text)
-        end
+        statuses = rest_client
+          .list_timeline(list.id, count: 100)
+          .select(&@mute_filter)
+          .map(&CREATE_STATUS_PROC)
+        yield statuses
       end
     end
 
-    def home_timeline
+    def lists
       send_request do
-        yield @rest_client.home_timeline(count: 100).select(&@mute_filter).map(&CREATE_STATUS_PROC)
+        yield rest_client.lists.map { |list| List.new(list) }
       end
     end
 
     def mentions
       send_request do
-        yield @rest_client.mentions(count: 100).select(&@mute_filter).map(&CREATE_STATUS_PROC)
+        statuses = rest_client
+          .mentions(count: 100)
+          .select(&@mute_filter)
+          .map(&CREATE_STATUS_PROC)
+        yield statuses
       end
     end
 
-    def user_timeline(user_id)
-      send_request do
-        yield @rest_client.user_timeline(user_id, count: 100).select(&@mute_filter).map(&CREATE_STATUS_PROC)
-      end
+    def on_mention(&block)
+      fail ArgumentError, 'no block given' unless block_given?
+      on(:mention, &block)
     end
 
-    def list(list_id)
+    def on_timeline_status(&block)
+      fail ArgumentError, 'no block given' unless block_given?
+      on(:timeline_status, &block)
+    end
+
+    def post(text, in_reply_to = nil)
       send_request do
-        yield List.new(@rest_client.list(list_id))
+        if in_reply_to.is_a? Status
+          text = "@#{in_reply_to.user.screen_name} #{text}"
+          rest_client.update(text, in_reply_to_status_id: in_reply_to.id)
+        else
+          rest_client.update(text)
+        end
       end
     end
 
-    def lists
-      send_request do
-        yield @rest_client.lists.map { |list| List.new(list) }
+    def rest_client
+      @rest_client ||= Twitter::REST::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 list_timeline(list)
-      fail ArgumentError, 'argument must be an instance of List class' unless list.is_a? List
+    def retweet(status)
+      fail ArgumentError,
+        'argument must be an instance of Status class' unless status.is_a? Status
+
       send_request do
-        yield @rest_client.list_timeline(list.id, count: 100).select(&@mute_filter).map(&CREATE_STATUS_PROC)
+        begin
+          rest_client.retweet!(status.id)
+          status.retweet!
+          yield status if block_given?
+        rescue => e
+          message =
+            case e
+            when Twitter::Error::AlreadyRetweeted
+              'The status is already retweeted'
+            when Twitter::Error::NotFound
+              'The status is not found'
+            when Twitter::Error::Forbidden
+              if status.user.id == user_id  # when the status is mine
+                'You cannot retweet your own status'
+              else  # when the status is not mine
+                'The status is protected'
+              end
+            else
+              raise e
+            end
+          Notifier.instance.show_error "Retweet attempt failed: #{message}"
+        end
       end
     end
 
     def search(query)
       send_request do
-        yield @rest_client.search(query, count: 100).select(&@mute_filter).map(&CREATE_STATUS_PROC)
+        statuses = rest_client
+          .search(query, count: 100)
+          .select(&@mute_filter)
+          .map(&CREATE_STATUS_PROC)
+        yield statuses
       end
     end
 
     def show_status(status_id)
       send_request do
-        yield Status.new(@rest_client.status(status_id))
+        yield Status.new(rest_client.status(status_id))
       end
     end
 
@@ -150,7 +195,7 @@ module Twterm
       send_request do
         user =
           begin
-            User.new(@rest_client.user(query))
+            User.new(rest_client.user(query))
           rescue Twitter::Error::NotFound
             nil
           end
@@ -158,90 +203,82 @@ module Twterm
       end
     end
 
-    def favorite(status)
-      return false unless status.is_a? Status
+    def stream
+      stream_client.on_friends do
+        Notifier.instance.show_message 'Connection established' unless @stream_connected
+        @stream_connected = true
+      end
 
-      send_request do
-        @rest_client.favorite(status.id)
-        status.favorite!
-        yield status if block_given?
+      stream_client.on_timeline_status do |tweet|
+        status = Status.new(tweet)
+        invoke_callbacks(:timeline_status, status)
+        invoke_callbacks(:mention, status) if status.text.include? "@#{@screen_name}"
       end
 
-      self
-    end
+      stream_client.on_delete do |status_id|
+        timeline.delete_status(status_id)
+      end
 
-    def unfavorite(status)
-      fail ArgumentError, 'argument must be an instance of Status class' unless status.is_a? Status
+      stream_client.on_event(:favorite) do |event|
+        break if event[:source][:screen_name] == @screen_name
 
-      send_request do
-        @rest_client.unfavorite(status.id)
-        status.unfavorite!
-        yield status if block_given?
+        user = event[:source][:screen_name]
+        text = event[:target_object][:text]
+        message = "@#{user} has favorited your tweet: #{text}"
+        Notifier.instance.show_message(message)
       end
-    end
 
-    def retweet(status)
-      return false unless status.is_a? Status
-
-      send_request do
-        begin
-          @rest_client.retweet!(status.id)
-          status.retweet!
-          yield status if block_given?
-        rescue Twitter::Error::AlreadyRetweeted, Twitter::Error::NotFound, Twitter::Error::Forbidden
-          Notifier.instance.show_error 'Retweet attempt failed'
-        end
+      stream_client.on_no_data_received do
+        @stream_connected = false
+        connect_stream
       end
+
+      connect_stream
     end
 
-    def destroy_status(status)
-      send_request do
-        begin
-          @rest_client.destroy_status(status.id)
-          yield if block_given?
-        rescue Twitter::Error::NotFound, Twitter::Error::Forbidden
-          Notifier.instance.show_error 'You cannot destroy that status'
-        end
-      end
+    def stream_client
+      @stream_client ||= TweetStream::Client.new(
+        consumer_key:       CONSUMER_KEY,
+        consumer_secret:    CONSUMER_SECRET,
+        oauth_token:        @access_token,
+        oauth_token_secret: @access_token_secret,
+        auth_method:        :oauth
+      )
     end
 
-    def fetch_muted_users
+    def unfavorite(status)
+      fail ArgumentError,
+        'argument must be an instance of Status class' unless status.is_a? Status
+
       send_request do
-        @muted_user_ids = @rest_client.muted_ids.to_a
-        yield @muted_user_ids if block_given?
+        rest_client.unfavorite(status.id)
+        status.unfavorite!
+        yield status if block_given?
       end
     end
 
-    def on_timeline_status(&block)
-      fail ArgumentError, 'no block given' unless block_given?
-      on(:timeline_status, &block)
+    def user_timeline(user_id)
+      send_request do
+        statuses = rest_client
+          .user_timeline(user_id, count: 100)
+          .select(&@mute_filter)
+          .map(&CREATE_STATUS_PROC)
+        yield statuses
+      end
     end
 
-    def on_mention(&block)
-      fail ArgumentError, 'no block given' unless block_given?
-      on(:mention, &block)
+    def self.new(user_id, screen_name, token, secret)
+      detector = -> (instance) { instance.user_id == user_id }
+      instance = @@instances.find(&detector)
+      instance.nil? ? super : instance
     end
 
-    class << self
-      def new(user_id, screen_name, token, secret)
-        detector = -> (instance) { instance.user_id == user_id }
-        instance = @@instances.find(&detector)
-        instance.nil? ? super : instance
-      end
-
-      def current
-        @@instances[0]
-      end
+    def self.current
+      @@instances[0]
     end
 
     private
 
-    def on(event, &block)
-      @callbacks[event] ||= []
-      @callbacks[event] << block
-      self
-    end
-
     def invoke_callbacks(event, data = nil)
       return if @callbacks[event].nil?
 
@@ -249,6 +286,12 @@ module Twterm
       self
     end
 
+    def on(event, &block)
+      @callbacks[event] ||= []
+      @callbacks[event] << block
+      self
+    end
+
     def send_request(&block)
       Thread.new do
         begin

data/lib/twterm/color_manager.rb

@@ -16,6 +16,17 @@ module Twterm
       transparent: -1
     }
 
+    def get_color_pair_index(fg, bg)
+      fail ArgumentError,
+        'invalid color name for foreground' unless COLORS.include? fg
+      fail ArgumentError,
+        'invalid color name for background' unless COLORS.include? bg
+
+      return @colors[bg][fg] unless @colors[bg][fg].nil?
+
+      add_color(fg, bg)
+    end
+
     def initialize
       @colors = {
         black: {}, white: {}, red: {}, green: {},
@@ -25,20 +36,13 @@ module Twterm
       @count = 0
     end
 
-    def get_color_pair_index(fg, bg)
-      fail ArgumentError, 'invalid color name' unless COLORS.include? fg
-      fail ArgumentError, 'invalid color name' unless COLORS.include? bg
-
-      return @colors[bg][fg] unless @colors[bg][fg].nil?
-
-      add_color(fg, bg)
-    end
-
     private
 
     def add_color(fg, bg)
-      fail ArgumentError, 'invalid color name' unless COLORS.include? fg
-      fail ArgumentError, 'invalid color name' unless COLORS.include? bg
+      fail ArgumentError,
+        'invalid color name for foreground' unless COLORS.include? fg
+      fail ArgumentError,
+        'invalid color name for background' unless COLORS.include? bg
 
       @count += 1
       index = @count

data/lib/twterm/config.rb

@@ -1,32 +1,37 @@
 module Twterm
-  module Config
-    CONFIG_FILE = "#{App::DATA_DIR}/config"
-
+  class Config
     def [](key)
-      @config[key]
+      config[key]
     end
 
     def []=(key, value)
-      @config[key] = value
-      save
+      return if config[key] == value
+      save_config_to_file
+      config[key] = value
+    end
+
+    private
+
+    def config
+      @config ||= exist_config_file? ? load_config_file : {}
     end
 
-    def load
-      unless File.exist? CONFIG_FILE
-        @config = {}
-        return
+    def save_config_to_file
+      File.open(config_file_path, 'w', 0600) do |f|
+        f.write config.to_yaml
       end
-      @config = YAML.load(File.read(CONFIG_FILE)) || {}
     end
 
-    private
+    def load_config_file
+      YAML.load_file(config_file_path)
+    end
 
-    def save
-      File.open(CONFIG_FILE, 'w', 0600) do |f|
-        f.write @config.to_yaml
-      end
+    def exist_config_file?
+      File.exist?(config_file_path)
     end
 
-    module_function :[], :[]=, :load, :save
+    def config_file_path
+      "#{App::DATA_DIR}/config".freeze
+    end
   end
 end