pry-send_tweet.rb 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1ea12e85df53a86fb132f2742e161b385c3d3fcecd8d2be8a5d46ed5c17e303
-  data.tar.gz: 551b008e811ba767defb60ec07ef8760e3b11e9f1e3b014ece1364ce1cbddf27
+  metadata.gz: ed084e3b9fae0289169d8f868beb43339998d9d30349eacb5261979148721e56
+  data.tar.gz: 31d443e012af14a5e9b7dcdb9ec9ccc49ab735cf710ab5f9f34a8f924cdbf46f
 SHA512:
-  metadata.gz: 1f049151c4f2ae0e2cc620f4ac00407a9cdeb640926173889a18d4bd0b49e3ba8b6b9462cf59ec13b5124fbfd02118fa6a6238260701cb04ead4bcf61fa0bcd4
-  data.tar.gz: 5a371218f0153b93afc3b16c95aa034ef801072658efa339cdf8bf12c1adaa09cd496ea20043fec155adc56342d36518a343795f9b3f11942b25e2b0659eee61
+  metadata.gz: b8e7dcf4fb5561197b1f428c6f0e3af4690d12f00d5ba30a0bb086e0e6b2ffd9a9fb5221e595262cce3049fd447c13ec7653332b21abbe527cf105ceb5b8f3d1
+  data.tar.gz: b2d006dc6fc9c62716b95ee382b5e6a9e2430e9a25bae531e90c1cd9f0e5b0a2ee77faa28d83577b9e05800e80661e7ec01e6f7ff9f7518f0b669871896ceeb8

data/CHANGELOG.md

@@ -1,13 +1,28 @@
 # CHANGELOG
 
+## master
+
+## v0.5.0
+
+* Automatically refresh the tweets on display every 4 minutes.
+
+* `Pry.config.twitter.refresh_interval` can be used for setting a custom refresh  
+   interval. The default is 240 seconds, or 4 minutes.
+
+* Add the command `read-tweets`.
+
+* Add the command `twitter-action`, aliased as `on-twitter`.
+
 ## v0.4.0
 
-* Add support for attaching an image to a tweet with the optional `-f` switch:
-  `send-tweet -f /path/to/image.jpg`
+* Add support for attaching an image to a tweet with
+  the optional `-f` / `--file` switch:
+
+  `send-tweet --file /path/to/image.jpg`
 
 ## v0.3.0
 
-* Compose a tweet using `pry.editor` instead of a command argument
+* Compose a tweet using `pry.editor`
 
 ## v0.2.1
 

data/README.md

@@ -1,53 +1,172 @@
 # pry-send_tweet.rb
 
-pry-send_tweet.rb adds a Pry command that can send tweets using your
-personal twitter account.
+## Introduction
 
-## API Access
+Extends the Pry REPL with the capabilities of a Twitter client.
 
-pry-send_tweet.rb sends tweets by talking to the twitter API over HTTPS.
-Twitter requires the following keys and tokens to do that:
+## API Access
 
-* `consumer_key`, `consumer_secret`, `access_token`, `access_token_secret`
+Using the Twitter API requires a developer account.
+Follow the instructions at [https://developer.twitter.com](https://developer.twitter.com)  
+if you haven't already setup access to the Twitter API.
 
-The required keys & tokens can be created on Twitter by signing up for a
-developer account and then creating an "app" for your account. This can be done
-at [https://developer.twitter.com](https://developer.twitter.com).
+## Configuration (required)
 
-## Configuration
+The placeholder keys and tokens in the below example can be replaced
+by those from your developer account.
 
 ```ruby
+# .pryrc
 Pry.configure do |config|
   config.twitter = Pry::Config.from_hash({
     consumer_key: '<consumer key>',
     consumer_secret: '<consumer secret>',
     access_token: '<access token>',
     access_token_secret: '<access token secret>'
-  }, nil)
+  })
 end
 ```
 
 ## Usage
 
-__1.__
+There are three commands added to Pry by this plugin, those commands are:
+
+  * `send-tweet`  
+    For sending tweets.
+
+  * `read-tweets`  
+    For reading tweets.
+
+  * `twitter-action` (aliased as: `on-twitter`)  
+    For performing misc actions on Twitter, such as following, unfollowing, etc.
+
+### Sending tweets
+
+
+* Send a tweet:
+
+      # Your editor opens (`_pry_.editor`), compose a tweet then hit save & close.
+      # You'll then get the url for your tweet:
+      [1] pry(main)> send-tweet
+      https://twitter.com/xxx/status/xxx
+
+
+* Send a tweet with an image attached:
+
+      [1] pry(main)> send-tweet --file #{File.join ENV['HOME'], 'photos', 'image.jpg'}
+
+* Reply to a tweet:
+
+      [1] pry(main)> send-tweet --reply-to https://twitter.com/username/status/1
+
+* There is built-in support for the `cowsay` program, which is a program that  
+  draws humorous ascii art. The following example will send a tweet using the  
+  Linux 'tux' mascot.  
+  <br>
+  **Tip:** `--cowsay-char` is optional and can be left blank. A cow will be used  
+  as the default. For a full list of available `cowsay` characters that can be  
+  used with the `--cowsay-char` option, run `cowsay -l` from a shell.   
+
+  **Extra Tip:** The `Dockerfile` in this repository installs `cowsay`.
+
+      [1] pry(main)> send-tweet --cowsay-text 'Hello, world' --cowsay-char tux
+
+### Reading tweets
+
+By default the tweets displayed by the `read-tweets` command  are automatically  
+refreshed every 4 minutes.
+
+That can be changed to a custom interval by setting `Pry.config.twitter.refresh_interval`  
+to a number of seconds, or to `nil` if you want to disable this feature.  
+
+* Read recent tweets from your timeline:
+
+      [1] pry(main)> read-tweets
+
+* Read recent tweets from the timeline of another user:
+
+      [1] pry(main)> read-tweets -t rubygems
+
+* Read recent tweets that `@mention` you:
+
+      [1] pry(main)> read-tweets --that-mention-me
+
+* Read recent tweets that you've liked:
 
-Send a tweet:
+      [1] pry(main) read-tweets --my-likes
 
-    [1] pry(main)> send-tweet
-    # Your editor opens (`_pry_.editor`), compose a tweet then hit save & close.
-    # You'll then get the url for your tweet:
-    https://twitter.com/xxx/status/xxx
+* Read recent tweets liked by another user:
 
-__2.__
+      [1] pry(main)> read-tweets --liked-by ladygaga
 
-Send a tweet with an image attached:
+* By default retweets are not displayed.  
+  To display retweets, pass the `--with-retweets` option.  
 
-    [1] pry(main)> send-tweet -f #{File.join ENV['HOME'], 'photos', 'WinnieThePooh.jpg'}
+      [1] pry(main)> read-tweets --with-retweets
+
+* Read 100 recent tweets instead of the default 35 recent tweets.    
+  **Tip:** `--count` can be combined with all of the options described above.
+
+      [1] pry(main)> read-tweets --count 100
+
+### Deleting tweets
+
+* Delete a tweet:
+
+      [1] pry(main)> twitter-action --delete-tweet https://twitter.com/username/status/1
+
+* Delete a retweet:
+
+      [1] pry(main)> twitter-action --delete-retweet https://twitter.com/username/status/1
+
+### Liking tweets
+
+* Like a tweet:
+
+      [1] pry(main)> twitter-action --like https://twitter.com/user/status/1
+
+* Unlike a tweet:
+
+      [1] pry(main)> twitter-action --unlike https://twitter.com/user/status/1
+
+### Retweets
+
+* Retweet a tweet:
+
+      [1] pry(main)> twitter-action --retweet https://twitter.com/user/status/1
+
+### Update your Twitter profile
+
+* Update your profiles image:
+
+      [1] pry(main)> twitter-action --set-profile-image /path/to/image.jpg
+
+* Update your profiles banner image:
+
+      [1] pry(main)> twitter-action --set-profile-banner-image /path/to/image.jpg
+
+* Update your profiles bio:
+
+      # Your editor opens (`_pry_.editor`), write your bio then hit save & close.
+      # Your bio will be updated after closing your editor.
+      [1] pry(main)> twitter-action --set-profile-bio
 
 ## Install
 
-    gem install pry-send_tweet.rb
+Install the gem:
+
+    $ gem install pry-send_tweet.rb
+
+There's also the option to clone this repository and then use the provided
+`Dockerfile` to run pry-send_tweet.rb inside a Docker container.
+The container is configured to use `emacs` when sending tweets and when using
+other commands that open an editor.
+
+    $ git clone https://github.com/r-obert/pry-send_tweet.rb
+    $ cd pry-send_tweet.rb
+    $ ./dockerize.sh
+
 
 ## License
 
-[MIT](./LICENSE.txt)
+This project uses the MIT license, see [LICENSE.txt](./LICENSE.txt) for details.

data/lib/pry-send_tweet.rb

@@ -1,57 +1,12 @@
 require 'pry' if not defined?(Pry::ClassCommand)
-Pry.commands.add_command Class.new(Pry::ClassCommand) {
-  require 'twitter'
-  match 'send-tweet'
-  command_options argument_required: false
-  banner <<-BANNER
-  send-tweet [options]
-
-  Send a tweet.
-  BANNER
-
-  def options(opts)
-    opts.on :f,
-            :file,
-            'A path to an image or other media to attach to a tweet',
-            argument: true
-  end
-
-  def process(*args)
-    if nil == _pry_.config.twitter
-      raise Pry::CommandError, "_pry_.config.twitter is nil!\n" \
-                               "Please set the required keys and tokens to send " \
-                               "tweets using Twitters API. \n" \
-                               "Visit https://github.com/r-obert/pry-send_tweet.rb#readme to learn how."
-    end
-    send_tweet_using_editor
-  end
-
-  private
-  def send_tweet_using_editor
-    tmp_file = Tempfile.new('pry-send_tweet')
-    Pry::Editor.new(_pry_).invoke_editor(tmp_file.path, 0)
-    tmp_file.rewind
-    if opts.f?
-      file = File.new opts[:f], 'r'
-      _pry_.output.puts client.update_with_media(tmp_file.read, file).url
-      file.close
-    else
-      _pry_.output.puts client.update(tmp_file.read).url
-    end
-  ensure
-    tmp_file.close
-    tmp_file.unlink
-  end
-
-
-  def client
-    @client ||= begin
-      Twitter::REST::Client.new { |config|
-        config.consumer_key = _pry_.config.twitter.consumer_key
-        config.consumer_secret = _pry_.config.twitter.consumer_secret
-        config.access_token = _pry_.config.twitter.access_token
-        config.access_token_secret = _pry_.config.twitter.access_token_secret
-      }
-    end
-  end
-}
+require 'twitter'
+require 'cgi'
+require 'shellwords'
+require 'timeout'
+module Pry::SendTweet
+  require_relative 'pry/send_tweet/mixins/tweet_renderer'
+  require_relative 'pry/send_tweet/base_command'
+  require_relative 'pry/send_tweet/send_tweet_command'
+  require_relative 'pry/send_tweet/read_tweets_command'
+  require_relative 'pry/send_tweet/twitter_action_command'
+end

data/lib/pry/send_tweet/base_command.rb

@@ -0,0 +1,57 @@
+class Pry::SendTweet::BaseCommand < Pry::ClassCommand
+  include Pry::SendTweet::TweetRenderer
+
+  def self.inherited(kls)
+    kls.group 'Twitter'
+  end
+
+  def process(*args)
+    if nil == _pry_.config.twitter
+      raise Pry::CommandError, "_pry_.config.twitter is nil!\n" \
+                               "Please set the required keys and tokens to send " \
+                               "tweets using Twitters API. \n" \
+                               "Visit https://github.com/r-obert/pry-send_tweet.rb#readme to learn how."
+    end
+  end
+
+  private
+
+  def page(txt)
+    _pry_.pager.page txt
+  end
+
+  def find_usernames_in(*ary)
+    ary.map do |str|
+      if str.start_with?('https://twitter.com')
+        File.basename URI.parse(URI.escape(str)).path
+      elsif str.start_with?('@')
+        str[1..-1]
+      else
+        str
+      end
+    end
+  end
+
+  # With thanks to ActionView for this method
+  def word_wrap(text, options = {})
+   line_width = options.fetch(:line_width, 80)
+   text.split("\n").collect! do |line|
+     line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip : line
+   end * "\n"
+  end
+
+  def numbered_list(title, ary)
+    underline = "-" * title.size
+    title = "#{bold(underline)}\n#{title.chomp}\n#{bold(underline)}\n\n"
+    title + ary.map.with_index { |item, index| yield(item, index+1) }.join("\n")
+  end
+
+  def client
+    @client ||= Twitter::REST::Client.new { |config|
+      config.consumer_key = _pry_.config.twitter.consumer_key
+      config.consumer_secret = _pry_.config.twitter.consumer_secret
+      config.access_token = _pry_.config.twitter.access_token
+      config.access_token_secret = _pry_.config.twitter.access_token_secret
+    }
+  end
+end

data/lib/pry/send_tweet/mixins/tweet_renderer.rb

@@ -0,0 +1,55 @@
+module Pry::SendTweet::TweetRenderer
+  include Timeout
+
+  def render_tweets(fetch_tweets_proc, title:)
+    pid = nil
+    refresh_interval = _pry_.config.twitter.refresh_interval || 240
+    timeout(refresh_interval) do
+      _pry_.pager.open do |pager|
+        pid = pager.send(:pager).pid
+        pager.write draw_tweets(title, fetch_tweets_proc.call)
+      end
+    end
+  rescue Timeout::Error
+    Process.kill 'SIGKILL', pid
+    _pry_.output.puts bold(bright_yellow("\n\n** Refreshing Tweets **\n"))
+    sleep 0.3
+    system 'reset'
+    retry
+  end
+
+  def render_tweet(tweet)
+    text = tweet.attrs[:full_text] ? tweet.attrs[:full_text] : tweet.full_text
+    <<-TWEET.each_line.map{|s| s.chomp.strip}.join("\n")
+      #{tweet_title(tweet)}
+      #{tweet.url}
+      #{"-" * 80}
+      #{word_wrap(CGI.unescapeHTML(text))}
+      #{"-" * 80}
+    TWEET
+  end
+
+  def tweet_title(tweet)
+    if tweet.user
+      u = tweet.user
+      <<-TWEET_TITLE.each_line.map{|s| s.chomp.strip}.join
+        @#{u.screen_name}
+        #{bright_blue(" | ")}
+        #{tweet_timestamp(tweet)}
+      TWEET_TITLE
+    end
+  end
+
+  def tweet_timestamp(tweet)
+    tweet
+      .created_at
+      .getlocal
+      .strftime("%-d %b %Y, %-I:%M%p")
+  end
+
+  def draw_tweets(heading, tweets)
+    "#{heading}\n\n" + tweets.map.with_index {|tweet, i|
+      "#{red bold('#')}#{red bold(i+1)}\n#{render_tweet(tweet)}"
+    }.join("\n\n")
+  end
+end

data/lib/pry/send_tweet/read_tweets_command.rb

@@ -0,0 +1,78 @@
+class Pry::SendTweet::ReadTweets < Pry::SendTweet::BaseCommand
+  DEFAULT_COUNT = 35
+  match 'read-tweets'
+  description "Read tweets from your timeline or the timeline of another user"
+  banner <<-B
+  read-tweets [options]
+
+  Read tweets from your timeline or the timeline of another user.
+  B
+
+  def options(o)
+    o.on :t=,
+         'The username whose timeline you want to read.'
+    o.on :c=,
+         'count=',
+         'The number of tweets to read. The maximum is 200.'
+    o.on 'with-retweets',
+         'Include retweets.'
+    o.on 'that-mention-me',
+         'Read tweets that @mention you.'
+    o.on 'my-likes',
+         'Read tweets you have liked.'
+    o.on 'liked-by=',
+         'The username whose likes you want to read.'
+  end
+
+  def process
+    super
+    case
+    when opts.present?('liked-by') then render_user_likes(opts['liked-by'])
+    when opts.present?('my-likes') then render_my_likes
+    when opts.present?('that-mention-me') then render_tweets_that_mention_me
+    else render_tweets_from_timeline(opts['t'])
+    end
+  end
+
+  private
+
+  def render_user_likes(str)
+    sn = find_usernames_in(str).first
+    asn = "@#{sn}"
+    render_tweets ->() { client.favorites(sn, count: opts['count'] || DEFAULT_COUNT)},
+                  title: bright_white(bold("Tweets liked by #{bright_blue(asn)}"))
+  end
+
+  def render_my_likes
+    render_tweets ->() { client.favorites(count: opts['count'] || DEFAULT_COUNT) },
+                  title: bright_blue(bold("Tweets liked by you"))
+  end
+
+  def render_tweets_that_mention_me
+    render_tweets ->() { client.mentions(timeline_options) },
+                  title: bright_white(bold("Tweets that #{bright_blue('@mention')} #{bright_white(bold('you'))}"))
+  end
+
+  def render_tweets_from_timeline(target)
+    render_tweets ->() {
+      if target
+       client.user_timeline(target, timeline_options)
+      else
+       client.home_timeline(timeline_options)
+      end
+    },
+    title: target ?
+           bright_white(bold("Tweets from #{bright_blue("@#{target}")}")) :
+           bright_blue(bold('Twitter'))
+  end
+
+  def timeline_options
+    {
+      tweet_mode: 'extended',
+      include_rts: opts.present?('with-retweets'),
+      count: opts.present?('count') ? opts['count'] : DEFAULT_COUNT
+    }
+  end
+
+  Pry.commands.add_command self
+end

data/lib/pry/send_tweet/send_tweet_command.rb

@@ -0,0 +1,95 @@
+class Pry::SendTweet::SendTweetCommand < Pry::SendTweet::BaseCommand
+  match 'send-tweet'
+  command_options argument_required: false
+  banner <<-BANNER
+  send-tweet [options]
+
+  Send a tweet.
+  BANNER
+
+  def options(opts)
+    opts.on :f=,
+            'file=',
+            'A path to an image or other media to attach to a tweet'
+    opts.on :r=,
+            'reply-to=',
+            'An absolute url to a tweet you want to reply to.'
+    opts.on 'cowsay-text=',
+            'A string of text that "cowsay" will use.'
+    opts.on 'cowsay-char=',
+            'Decides which character "cowsay" will use. Default is "cow".'
+  end
+
+  def process(args)
+    super
+    tweet = create_content_of_tweet
+    if opts.present?(:file)
+      media = File.new opts[:file], 'r'
+      _pry_.output.puts client.update_with_media(tweet, media, tweet_options).url
+      media.close
+    else
+      _pry_.output.puts client.update(tweet, tweet_options).url
+    end
+  end
+
+  private
+
+  def prepend_username_to_reply!(tweet_url, file)
+    username = tweet_username_from(tweet_url)
+    file.write "@#{username} "
+  end
+
+  def tweet_username_from(tweet_url)
+    File.basename File.dirname(File.dirname(tweet_url))
+  end
+
+  def replying_to_other_tweet?
+    opts.present?('reply-to')
+  end
+
+  def tweet_options
+    options = {}
+    options.merge!({
+      in_reply_to_status_id: Integer(File.basename(opts['reply-to']))
+    }) if replying_to_other_tweet?
+    options
+  end
+
+  def create_content_of_tweet
+    if opts.present?('cowsay-text')
+      compose_tweet_with_cowsay
+    else
+      compose_tweet_with_editor
+    end
+  end
+
+  def compose_tweet_with_editor
+    Tempfile.open('pry-send_tweet--compose-tweet') do |file|
+      if replying_to_other_tweet?
+        # During experimentation I noticed that without prefixing who we are
+        # replying to, the tweet we send will not be considered a reply even
+        # with reply_to_status_id being set.
+        prepend_username_to_reply!(opts['reply-to'], file)
+      end
+      file.rewind
+      Pry::Editor.new(_pry_).invoke_editor(file.path, 0)
+      file.read
+    end
+  end
+
+  def compose_tweet_with_cowsay
+    username = if replying_to_other_tweet?
+                 "@#{tweet_username_from(opts['reply-to'])} "
+               end
+    char = opts['cowsay-char'] || 'cow'
+    txt = "#{username}#{opts['cowsay-text']}"
+    `cowsay -f #{char.shellescape} #{txt.shellescape}`.tap do
+      if !$?.success?
+        raise Pry::CommandError,
+        "Something went wrong. Is 'cowsay' installed?"
+      end
+    end
+  end
+
+  Pry.commands.add_command self
+end

data/lib/pry/send_tweet/twitter_action_command.rb

@@ -0,0 +1,166 @@
+class Pry::SendTweet::TwitterAction < Pry::SendTweet::BaseCommand
+  match 'twitter-action'
+  description 'Like, unlike, follow, unfollow and more'
+  banner <<-B
+  twitter-action OPTIONS
+
+  Like, unlike, follow, unfollow and more.
+  B
+
+  def options(o)
+    #
+    # Like / unlike tweets
+    #
+    o.on 'like-tweet=', 'Like a tweet'
+    o.on 'unlike-tweet=', 'Unlike a tweet'
+    #
+    # Follow / unfollow a user
+    #
+    o.on 'follow=', 'Follow a user'
+    o.on 'unfollow=', 'Unfollow a user'
+    #
+    # Delete tweets and reweets
+    #
+    o.on 'delete-retweet=', 'Delete a retweet'
+    o.on 'delete-tweet=', 'Delete a tweet'
+    #
+    # Retweet a tweet
+    #
+    o.on 'retweet=', 'Retweet a tweet'
+    #
+    # Profile management
+    #
+    o.on 'set-profile-bio', 'Set your profiles bio'
+    o.on 'set-profile-banner-image=', 'Set your profiles banner image'
+    o.on 'set-profile-name=', 'Set the name associated with your profile'
+    o.on 'set-profile-image=', 'Set your profile image'
+  end
+
+  def process
+    super
+    case
+    when opts.present?('like-tweet') then like_tweet
+    when opts.present?('unlike-tweet') then unlike_tweet
+    when opts.present?('follow') then follow_user
+    when opts.present?('unfollow') then unfollow_user
+    when opts.present?('delete-tweet') then delete_tweet
+    when opts.present?('delete-retweet') then delete_retweet
+    when opts.present?('retweet') then retweet_tweet
+    when opts.present?('set-profile-banner-image') then set_profile_banner_image
+    when opts.present?('set-profile-bio') then set_profile_bio
+    when opts.present?('set-profile-name') then set_profile_name
+    when opts.present?('set-profile-image') then set_profile_image
+    end
+  end
+
+  private
+
+  def set_profile_image
+    path = opts['set-profile-image']
+    if client.update_profile_image path
+      page "Profile image updated"
+    else
+      raise Pry::CommandError, "Something went wrong"
+    end
+  end
+
+  def set_profile_banner_image
+    path = opts['set-profile-banner-image']
+    if client.update_profile_banner Base64.strict_encode64(File.binread(path))
+      page "Profile banner updated"
+    else
+      raise Pry::CommandError, "Something went wrong"
+    end
+  end
+
+  def set_profile_name
+    client.update_profile name: opts['set-profile-name']
+    page "Profile name updated"
+  end
+
+  def set_profile_bio
+    Tempfile.open('pry-send_tweet-set-bio') do |file|
+      Pry::Editor.new(_pry_).invoke_editor(file.path, 0)
+      file.rewind
+      client.update_profile description: file.read
+      page "Profile bio updated"
+    end
+  end
+
+  def retweet_tweet
+    tweet_url = opts['retweet']
+    if !client.retweet(tweet_url).empty?
+      page "Tweet retweeted"
+    else
+      raise Pry::CommandError, "Something went wrong"
+    end
+  end
+
+  def like_tweet
+    tweets = client.favorite(opts['like-tweet'])
+    page numbered_list(bold("Tweets you liked"), tweets) {|tweet, index|
+      "#{index}. #{tweet.url}"
+    }
+  end
+
+  def unlike_tweet
+    tweets = client.unfavorite(opts['unlike-tweet'])
+    page numbered_list(bold("Tweets you unliked"), tweets) {|tweet, index|
+      "#{index}. #{tweet.url}"
+    }
+  end
+
+  def follow_user
+    usernames = find_usernames_in(opts['follow'])
+    follows = client.follow(usernames)
+    if follows.empty?
+      page "Didn't follow #{list_usernames(usernames)}, " \
+           "you could be following them already."
+    else
+      page numbered_list(bold("Users you started following"), follows) {|user, index|
+        display_followed_or_unfollowed(user, index)
+      }
+    end
+  end
+
+  def unfollow_user
+    usernames = find_usernames_in(opts['unfollow'])
+    unfollows = client.unfollow(usernames)
+    if unfollows.empty?
+      page "Didn't unfollow #{list_usernames(usernames)} " \
+           "you might not be following them already."
+    else
+      page numbered_list(bold("Users you stopped following"), unfollows) {|user, index|
+        display_followed_or_unfollowed(user, index)
+      }
+    end
+  end
+
+  def delete_retweet
+    tweets = client.unretweet(opts['delete-retweet'])
+    page numbered_list(bold("Retweets you deleted"), tweets) {|tweet, index|
+      "#{index}. #{tweet.url}"
+    }
+  end
+
+  def delete_tweet
+    tweets = client.destroy_status(opts['delete-tweet'])
+    page numbered_list(bold("Tweets you deleted"), tweets) {|tweet, index|
+      "#{index}. #{tweet.url}"
+    }
+  end
+
+  def display_followed_or_unfollowed(user, index)
+    sn = "@#{user.screen_name}"
+    "#{sn} #{bold(bright_blue('|'))} #{user.url}"
+  end
+
+  def list_usernames(ary)
+    find_usernames(ary).map do |username|
+      bold("@#{username}")
+    end.join(', ')
+  end
+
+  Pry.commands.add_command(self)
+  Pry.commands.alias_command "on-twitter", "twitter-action"
+end

data/pry-send_tweet.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |spec|
   spec.name = "pry-send_tweet.rb"
-  spec.version = "0.4.0"
+  spec.version = "0.5.0"
   spec.authors = ["Robert Gleeson"]
   spec.email = "trebor.g@protonmail.com"
-  spec.summary = "pry-send_tweet.rb adds a Pry command that can send tweets using your personal twitter account."
+  spec.summary = "Extends the Pry REPL with the capabilities of a Twitter client."
   spec.description = spec.summary
   spec.homepage = "https://github.com/r-obert/pry-send_tweet.rb"
   spec.licenses = ["MIT"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pry-send_tweet.rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Robert Gleeson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-10 00:00:00.000000000 Z
+date: 2018-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -38,8 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
-description: pry-send_tweet.rb adds a Pry command that can send tweets using your
-  personal twitter account.
+description: Extends the Pry REPL with the capabilities of a Twitter client.
 email: trebor.g@protonmail.com
 executables: []
 extensions: []
@@ -49,6 +48,11 @@ files:
 - LICENSE.txt
 - README.md
 - lib/pry-send_tweet.rb
+- lib/pry/send_tweet/base_command.rb
+- lib/pry/send_tweet/mixins/tweet_renderer.rb
+- lib/pry/send_tweet/read_tweets_command.rb
+- lib/pry/send_tweet/send_tweet_command.rb
+- lib/pry/send_tweet/twitter_action_command.rb
 - pry-send_tweet.gemspec
 homepage: https://github.com/r-obert/pry-send_tweet.rb
 licenses:
@@ -73,6 +77,5 @@ rubyforge_project:
 rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
-summary: pry-send_tweet.rb adds a Pry command that can send tweets using your personal
-  twitter account.
+summary: Extends the Pry REPL with the capabilities of a Twitter client.
 test_files: []