pry-send_tweet.rb 0.6.0 → 0.7.0

data/lib/pry/send_tweet/commands/read_tweets.rb

@@ -0,0 +1,83 @@
+class Pry::SendTweet::ReadTweets < Pry::SendTweet::BaseCommand
+  match 'read-tweets'
+  description 'A command for reading tweets.'
+  banner <<-BANNER
+  read-tweets [OPTIONS]
+
+  #{description}
+  BANNER
+
+  def options(o)
+    o.on 't=', 'tweeter=',
+         'A username whose timeline you want to read.'
+    o.on 'c=', 'count=',
+         "The number of tweets to read. The maximum is 200, and the default is " \
+         "#{Pry::SendTweet::DEFAULT_READ_SIZE}."
+    o.on 'l=', 'likes=',
+         'Read tweets you or another user have liked.',
+         argument: :optional
+    o.on 'r=', 'replies=', 'A username whose replies you want to read'
+    o.on 'm', 'mentions', 'Read tweets that @mention you.'
+    o.on 'w', 'with-retweets', 'Include retweets.'
+  end
+
+  def process
+    super
+    case
+    when opts.present?('replies') then show_replies(user: opts['replies'])
+    when opts.present?('likes') then show_likes(user: opts['likes'])
+    when opts.present?('mentions') then show_mentions
+    else show_tweets_from_timeline(user: opts['tweeter'])
+    end
+  end
+
+  private
+
+  def show_replies(user:)
+    render_tweets lambda {
+      username = find_usernames_in(user).first
+      twitter.user_timeline(username, timeline_options).select {|tweet|
+        tweet.reply? &&
+        tweet.in_reply_to_screen_name? &&
+        tweet.in_reply_to_screen_name.downcase != username.downcase
+      }
+    },
+    title: format("Replies sent by %{user}", user: bold("@#{user}"))
+  end
+
+  def show_likes(user:)
+    if user
+      user = find_usernames_in(user).first
+      render_tweets lambda { twitter.favorites(user, count: opts['count'] || Pry::SendTweet::DEFAULT_READ_SIZE)},
+                    title: "Tweets liked by #{bright_white('@'+user)}"
+    else
+      render_tweets lambda { twitter.favorites(count: opts['count'] || Pry::SendTweet::DEFAULT_READ_SIZE) },
+                    title: "Liked tweets"
+    end
+  end
+
+  def show_tweets_from_timeline(user:)
+    if user
+      render_tweets lambda { twitter.user_timeline(user, timeline_options) },
+                    title: '@'+user
+    else
+      render_tweets lambda { twitter.home_timeline(timeline_options) },
+                    title: "Twitter.com"
+    end
+  end
+
+  def show_mentions
+    render_tweets lambda { twitter.mentions(timeline_options) },
+                  title: "Tweets that #{bright_white('@mention')} #{bright_blue('you')}"
+  end
+
+  def timeline_options
+    {
+      tweet_mode: 'extended',
+      include_rts: opts.present?('with-retweets'),
+      count: opts.present?('count') ? opts['count'] : Pry::SendTweet::DEFAULT_READ_SIZE
+    }
+  end
+
+  Pry.commands.add_command self
+end

data/lib/pry/send_tweet/commands/send_tweet.rb

@@ -0,0 +1,141 @@
+class Pry::SendTweet::SendTweet < Pry::SendTweet::BaseCommand
+  MAX_TWEET_SIZE = 280
+
+  match 'send-tweet'
+  description 'Send a tweet'
+  command_options argument_required: false
+  banner <<-BANNER
+  send-tweet [options]
+
+  Send a tweet.
+  BANNER
+
+  def options(o)
+    o.on 'f=', 'file=',
+         'One or more paths to image(s) to attach to a tweet',
+          as: Array
+    o.on 'r=', 'reply-to=',
+         'An absolute url to a tweet you want to reply to.'
+    o.on 's=', 'self-destruct=',
+         'The number of seconds (represented as a number or a timestamp in the ' \
+         'format of HH:MM:SS) to wait before automatically deleting the tweet ' \
+         'asynchronously'
+    o.on 'd=', 'delay=',
+         'The number of seconds (represented as a number or a timestamp in the ' \
+         'format of HH:MM:SS) to wait before creating the tweet asynchronously'
+    o.on 'n', 'no-newline',
+         "Remove newlines (\\n) from a tweet before sending it"
+  end
+
+  def process(args)
+    super
+    tweet_contents = compose_tweet_with_editor
+    create_tweet = opts.present?(:file) ? lambda { send_tweet_with_media(tweet_contents) } :
+                                          lambda { send_textual_tweet(tweet_contents) }
+    if opts.present?('delay')
+      time_obj, sleep_seconds = parse_duration_str(opts['delay'])
+      Thread.new {
+        sleep sleep_seconds
+        create_tweet.call
+      }
+      publish_time = (time_obj ? time_obj : Time.now + sleep_seconds)
+                      .getlocal
+                      .strftime(time_format)
+      page bold("Tweet will be published at approximately #{publish_time}.")
+    else
+      tweet = create_tweet.call
+      page tweet.url
+    end
+  end
+
+  private
+
+  def no_newline?
+    opts.present?('no-newline')
+  end
+
+  def send_tweet_with_media(tweet_contents)
+    medias = opts['file'].map{|p| File.new p, 'r'}
+    tweet = twitter.update_with_media(tweet_contents, medias, tweet_options)
+    tweet.tap {|t| self_destruct! t.id, opts['self-destruct'] }
+  ensure
+    medias.each(&:close)
+  end
+
+  def send_textual_tweet(tweet_contents)
+    tweet = twitter.update(tweet_contents, tweet_options)
+    tweet.tap {|t| self_destruct! t.id, opts['self-destruct'] }
+  end
+
+  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 compose_tweet_with_editor
+    tweet = 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)
+      lines = file.read.each_line
+      no_newline? ? lines.map(&:chomp).join(' ') : lines.to_a.join
+    end
+    validate_tweet!(tweet)
+    tweet
+  end
+
+  def validate_tweet!(tweet)
+    if tweet.strip.empty?
+      raise Pry::CommandError, "Can't post an empty tweet."
+    elsif tweet.size > MAX_TWEET_SIZE
+      raise Pry::CommandError, "The tweet: \n" +
+                                word_wrap(tweet) +
+                                "\nis too big to publish, try to use less characters."
+    end
+  end
+
+  def self_destruct!(tweet_id, duration)
+    return if !duration
+    _, sleep_seconds = parse_duration_str(duration)
+    page bold("Tweet due to self destruct in #{sleep_seconds} seconds")
+    Thread.new do
+      sleep sleep_seconds
+      twitter.destroy_status(tweet_id)
+    end
+  end
+
+  def parse_duration_str(str)
+    if str =~ /\A\d+\z/
+      sleep_seconds = Integer(str)
+    elsif str =~ /\A\d{2}:\d{2}\z/ || str =~ /\A\d{2}:\d{2}:\d{2}\z/
+      time_obj = Time.parse(str)
+      sleep_seconds = Integer(time_obj - Time.now)
+    else
+      raise Pry::CommandError, "The argument --delay='#{str}' is not " \
+                               "something I understand."
+    end
+    [time_obj, sleep_seconds]
+  end
+  Pry.commands.add_command self
+end

data/lib/pry/send_tweet/commands/twitter_action.rb

@@ -0,0 +1,109 @@
+
+class Pry::SendTweet::TwitterAction < Pry::SendTweet::BaseCommand
+  require_relative 'twitter_action/profile_actions'
+  require_relative 'twitter_action/suggested_actions'
+  require_relative 'twitter_action/like_actions'
+  require_relative 'twitter_action/follow_actions'
+  require_relative 'twitter_action/mute_actions'
+  require_relative 'twitter_action/delete_tweet_actions'
+  include ProfileActions
+  include SuggestedActions
+  include LikeActions
+  include FollowActions
+  include MuteActions
+  include DeleteTweetActions
+
+  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 one or more tweets', as: Array
+    o.on 'unlike-tweet=', 'Unlike one or more tweets', as: Array
+    #
+    # Follow / unfollow a user
+    #
+    o.on 'follow=', 'Follow one or more users', as: Array
+    o.on 'unfollow=', 'Unfollow one or more users', as: Array
+    #
+    # Delete tweets and reweets
+    #
+    o.on 'delete-retweet=', 'Delete one or more retweets', as: Array
+    o.on 'delete-tweet=', 'Delete one or more tweets', as: Array
+    #
+    # Retweet a tweet
+    #
+    o.on 'retweet=', 'Retweet one or more tweets', as: Array
+    #
+    # Profile management
+    #
+    o.on 'set-profile-bio', 'Set your profiles bio'
+    o.on 'set-profile-url=', 'Set the URL associated with your profile'
+    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'
+    #
+    # Suggestions
+    #
+    o.on 'suggested-topics', 'View topics suggested by Twitter'
+    o.on 'suggested-users=', 'A topic from which to view users Twitter ' \
+                             'suggests following'
+    o.on 'suggested-lang=', 'Restrict suggestion results to a specific language, ' \
+                            'given in ISO 639-1 format. Default is "en"'
+    #
+    # Muting
+    #
+    o.on 'mute-user=', 'One or more usersname to mute', as: Array
+    o.on 'unmute-user=', 'One or more usernames to unmute', as: Array
+  end
+
+  def process
+    super
+    case
+    when opts.present?('like-tweet') then like_tweet(opts['like-tweet'])
+    when opts.present?('unlike-tweet') then unlike_tweet(opts['unlike-tweet'])
+    when opts.present?('follow') then follow_user(opts['follow'])
+    when opts.present?('unfollow') then unfollow_user(opts['unfollow'])
+    when opts.present?('delete-tweet') then delete_tweet(opts['delete-tweet'])
+    when opts.present?('delete-retweet') then delete_retweet(opts['delete-retweet'])
+    when opts.present?('retweet') then retweet_tweet(opts['retweet'])
+    when opts.present?('set-profile-banner-image') then set_profile_banner_image(opts['set-profile-banner-image'])
+    when opts.present?('set-profile-name') then set_profile_name(opts['set-profile-name'])
+    when opts.present?('set-profile-image') then set_profile_image(opts['set-profile-image'])
+    when opts.present?('set-profile-url') then set_profile_url(opts['set-profile-url'])
+    when opts.present?('set-profile-bio') then set_profile_bio
+    when opts.present?('suggested-topics') then suggested_topics
+    when opts.present?('suggested-users') then suggested_users(opts['suggested-users'])
+    when opts.present?('mute-user') then mute_user(opts['mute-user'])
+    when opts.present?('unmute-user') then unmute_user(opts['unmute-user'])
+    end
+  end
+
+  private
+
+  def retweet_tweet(tweets)
+    retweets = twitter.retweet(tweets)
+    error_msg = word_wrap("No retweets created. Are you sure you gave a valid reference to " \
+                          "one or more tweets, and that you haven't already retweeted the supplied " \
+                          "tweet(s) ..?")
+    retweets.size > 0 ? render_tweets(retweets, title: bright_green("Retweeted tweets"), timeout: false) :
+                        page(twitter_error(error_msg))
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  def display_followed_or_unfollowed(user, index)
+    sn = "@#{user.screen_name}"
+    "#{sn} #{bold(bright_blue('|'))} #{user.url}"
+  end
+
+  Pry.commands.add_command(self)
+  Pry.commands.alias_command "on-twitter", "twitter-action"
+end

data/lib/pry/send_tweet/commands/twitter_action/delete_tweet_actions.rb

@@ -0,0 +1,16 @@
+module Pry::SendTweet::TwitterAction::DeleteTweetActions
+  def delete_retweet(retweets)
+    tweets = twitter.unretweet(retweets)
+    tweets.size > 0 ? render_tweets(tweets, title: bold("Deleted retweets"), timeout: false) :
+                      page(twitter_error("No retweets deleted. Are you sure you gave a valid reference to the retweet?"))
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  def delete_tweet(tweets)
+    tweets = twitter.destroy_status(tweets)
+    render_tweets tweets, title: bold("Deleted tweets"), timeout: false
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+end

data/lib/pry/send_tweet/commands/twitter_action/follow_actions.rb

@@ -0,0 +1,30 @@
+module Pry::SendTweet::TwitterAction::FollowActions
+  def follow_user(users)
+    users = find_usernames_in(*users)
+    follows = twitter.follow(users)
+    follows.empty? ? page("Are you sure you are not already following #{join_usernames(users)} ?") :
+                     page(numbered_list(bold("Followed:"), follows) {|user, index|
+                       display_followed_or_unfollowed(user, index)
+                     })
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  def unfollow_user(users)
+    users = find_usernames_in(*users)
+    unfollows = twitter.unfollow(users)
+    unfollows.empty? ? page("Are you sure you are following #{join_usernames(users)} ?") :
+                       page(numbered_list(bold("Unfollowed:"), unfollows) {|user, index|
+                         display_followed_or_unfollowed(user, index)
+                       })
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  private
+  def join_usernames(users)
+    users.map do |username|
+      bold("@#{username}")
+    end.join(', ')
+  end
+end

data/lib/pry/send_tweet/commands/twitter_action/like_actions.rb

@@ -0,0 +1,17 @@
+module Pry::SendTweet::TwitterAction::LikeActions
+  def like_tweet(tweets)
+    liked = twitter.favorite(tweets)
+    liked.size > 0 ? render_tweets(liked, title: bold("Liked tweets"), timeout: false) :
+                     page(twitter_error("Tweet(s) not liked. Maybe you liked those tweet(s) already?"))
+  rescue Timeout::Error => e
+    page twitter_error(e)
+  end
+
+  def unlike_tweet(tweets)
+    unliked = twitter.unfavorite(tweets)
+    unliked.size > 0 ? render_tweets(unliked, title: bold("Unliked tweets"), timeout: false) :
+                       page(twitter_error("Tweet(s) not unliked. Maybe you haven't liked those tweet(s)?"))
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+end

data/lib/pry/send_tweet/commands/twitter_action/mute_actions.rb

@@ -0,0 +1,20 @@
+module Pry::SendTweet::TwitterAction::MuteActions
+  def mute_user(strings)
+    muted = twitter.mute(*find_usernames_in(*strings))
+    muted.empty? ? page("No users muted. Maybe you muted them already?") :
+                   page(numbered_list("Muted users", muted) {|user, index|
+                     display_followed_or_unfollowed(user, index)
+                   })
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  def unmute_user(strings)
+    unmuted = twitter.unmute(*find_usernames_in(*strings))
+    page numbered_list("Unmuted users", unmuted) {|user, index|
+      display_followed_or_unfollowed(user, index)
+    }
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+end

data/lib/pry/send_tweet/commands/twitter_action/profile_actions.rb

@@ -0,0 +1,42 @@
+module Pry::SendTweet::TwitterAction::ProfileActions
+  def set_profile_url(url)
+    if twitter.update_profile url: url
+      page "Profile URL updated"
+    else
+      raise Pry::CommandError, "Something went wrong"
+    end
+  end
+
+  def set_profile_image(path)
+    twitter.update_profile_image(path)
+    page "Profile image updated"
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  def set_profile_banner_image(path)
+    base64 = Base64.strict_encode64 File.binread(path)
+    twitter.update_profile_banner(base64)
+    page "Profile banner updated"
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+
+  def set_profile_name(name)
+    twitter.update_profile name: name
+    page "Profile name updated"
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  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
+      twitter.update_profile description: file.read
+      page "Profile bio updated"
+    end
+  rescue Twitter::Error => e
+    page twitter_error(e)
+  end
+end