fry-send_tweet.rb 0.1.0

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

@@ -0,0 +1,94 @@
+module Pry::SendTweet::ReadTweets::TranslateActions
+  YANDEX_ENDPOINT = "https://translate.yandex.net/api/v1.5/tr.json/translate?" \
+                    "key=%{key}&text=%{text}&lang=%{lang}"
+
+  LANGUAGE_STRINGS = {
+    'ar' => 'Arabic (العربية)',
+    'en' => 'English',
+    'de' => 'German (Deutsch)',
+    'pt' => 'Portuguese (Portuguesa)',
+    'fa' => 'Farsi (دریافت)',
+    'ja' => 'Japanese (日本語)',
+    'he' => 'Hebrew (עברית)',
+    'ga' => 'Irish (Gaeilge)',
+    'es' => 'Spanish (Español)',
+    'it' => 'Italinao (italiano)',
+    'nl' => 'Dutch (Nederlands)',
+    'ru' => 'Russian (русский)',
+    'uk' => 'Ukranian (країнська)',
+    'ko' => 'Korean (한국어)',
+    'fr' => 'French (Français)',
+    'da' => 'Danish (dansk)',
+    'yi' => 'Yiddish (ייִדיש)',
+    'sw' => 'Swahili'
+  }
+
+  def translate_tweet(tweet_url, source_language)
+    tweet = twitter.status(tweet_url)
+    uri_endpoint = __build_yandex_endpoint(tweet, source_language)
+    res = Net::HTTP.get_response(uri_endpoint)
+    case res
+    when Net::HTTPOK
+      tweet.attrs[:full_text] = __translated_text_from(res)
+      render_tweets [tweet], title: "#{__translation_map(res)}: "
+    else
+      raise Pry::CommandError, "Bad response from Yandex (#{res.class})"
+    end
+  end
+
+  def translate_text(text, source_language)
+    uri_endpoint = __build_yandex_endpoint(text, source_language)
+    res = Net::HTTP.get_response(uri_endpoint)
+    case res
+    when Net::HTTPOK
+      _pry_.output.puts "#{__translation_map(res)}: \n" \
+                        "#{__translated_text_from(res)}"
+    else
+      raise Pry::CommandError, "Bad response from Yandex (#{res.class})"
+    end
+  end
+
+  private
+
+  # @api private
+  def __translation_map(res)
+    b = JSON.parse(res.body)
+    from, to = b['lang'].split('-')
+    from = LANGUAGE_STRINGS[from] || from
+    to = LANGUAGE_STRINGS[to] || to
+    "#{from} => #{to}"
+  end
+
+  # @api private
+  def __translated_text_from(res)
+    JSON.parse(res.body)["text"][0]
+  end
+
+  # @api private
+  def __build_yandex_endpoint(tweet, source_language)
+    URI.parse format(YANDEX_ENDPOINT,
+      lang: URI.encode_www_form_component(__yandex_lang_param(source_language)),
+      key: URI.encode_www_form_component(__yandex_key),
+      text: URI.encode_www_form_component(
+        Twitter::Tweet === tweet ? __read_tweet_body(tweet) : tweet
+      )
+    )
+  end
+
+  # @api private
+  def __yandex_lang_param(source_language)
+    from = source_language ? "#{source_language}-" : ""
+    to = _pry_.config.twitter.yandex_lang || "en"
+    from + to
+  end
+
+  # @api private
+  def __yandex_key
+    k = _pry_.config.twitter.yandex_key
+    if !k || k.strip.empty?
+      raise Pry::CommandError,
+            "fatal: _pry_.config.twitter.yandex_key is nil, false or empty"
+    end
+    k
+  end
+end

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

@@ -0,0 +1,151 @@
+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 file(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_creator = create_tweet_creator(compose_tweet_with_editor)
+    if opts.present?('delay')
+      time_obj, sleep_seconds = parse_duration_str(opts['delay'])
+      Thread.new {
+        sleep sleep_seconds
+        tweet_creator.call
+      }
+      publish_time = (time_obj ? time_obj : Time.now + sleep_seconds)
+                      .getlocal
+                      .strftime(time_format)
+      page_ok bold("Tweet will be published at approximately #{publish_time}.")
+    else
+      tweet = tweet_creator.call
+      page_ok tweet.url
+    end
+  end
+
+  private
+
+  def paths_to_twitterio(paths)
+    paths.map do |path|
+      Pry::SendTweet::TwitterIO.new File.binread(path), File.basename(path)
+    end
+  end
+
+  def no_newline?
+    opts.present?('no-newline')
+  end
+
+  def send_tweet_with_media(tweet_contents, medias)
+    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)
+    tweet = twitter.status(tweet_url)
+    mentions = [tweet.user.screen_name].concat tweet.user_mentions.map(&:screen_name)
+    file.write mentions.uniq(&:downcase).map{|u| "@#{u}" }.join(' ')
+  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 create_tweet_creator(tweet_contents)
+    if opts.present?(:file)
+      medias = paths_to_twitterio(opts[:file])
+      lambda { send_tweet_with_media(tweet_contents, medias) }
+    else
+      lambda { send_textual_tweet(tweet_contents) }
+    end
+  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)
+      time_obj += 3600*24 if time_obj <= Time.now
+      sleep_seconds = Integer(time_obj - Time.now)
+    else
+      raise Pry::CommandError, "--delay='#{str}' or --self-destruct='#{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,118 @@
+
+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
+
+  #{description}
+  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
+    #
+    # Following / unfollowing
+    #
+    o.on 'follow=', 'Follow one or more users', as: Array
+    o.on 'unfollow=', 'Unfollow one or more users', as: Array
+    o.on 'show-followers=', 'Show the newest users to have followed you or ' \
+                            'another user', argument: :optional
+    o.on 'show-following', 'Show the newest users you currently follow'
+    #
+    # 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-name=',         'Set the name visible on your profile'
+    o.on 'set-profile-bio',           'Set the description visible on your profile'
+    o.on 'set-profile-location',      'Set the location visible on your profile'
+    o.on 'set-profile-url=',          'Set the URL visible on your profile'
+    o.on 'set-profile-banner-image=', 'Set the banner image visible on your profile'
+    o.on 'set-profile-image=',        'Set profile photo'
+    o.on 'set-profile-link-color=',   'Set the color (as a hex value) of links that ' \
+                                      'are visible on your profiles timeline '
+    #
+    # 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 usernames 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-location') then set_profile_location
+    when opts.present?('set-profile-link-color') then set_profile_link_color(opts['set-profile-link-color'])
+    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'])
+    when opts.present?('show-followers') then show_followers(opts['show-followers'])
+    when opts.present?('show-following') then show_following(opts['show-following'])
+    end
+  end
+
+  private
+
+  def retweet_tweet(tweets)
+    retweets = twitter.retweet(tweets)
+    if retweets.size > 0
+      render_tweets retweets, title: bright_green("Retweeted tweets"), timeout: false
+    else
+      page_error word_wrap("Nothing retweeted. Are you sure you gave a valid reference to " \
+        "one or more tweets, and that you haven't already retweeted the given " \
+        "tweet(s) ..?")
+    end
+  rescue Twitter::Error => e
+    page_error word_wrap("Nothing retweeted. Are you sure you gave a valid reference to " \
+      "one or more tweets, and that you haven't already retweeted the given " \
+      "tweet(s) ..?")
+  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,19 @@
+module Pry::SendTweet::TwitterAction::DeleteTweetActions
+  def delete_retweet(retweets)
+    tweets = twitter.unretweet(retweets)
+    if tweets.size == 0
+      page_error "Are you sure you gave a valid reference to one or more retweets?"
+    else
+      render_tweets tweets, title: bold("Deleted retweets"), timeout: false
+    end
+  rescue Twitter::Error => e
+    page_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_error(e)
+  end
+end

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

@@ -0,0 +1,66 @@
+module Pry::SendTweet::TwitterAction::FollowActions
+  def follow_user(users)
+    users = search_str_for_users(*users)
+    follows = twitter.follow(users)
+    if follows.size > 0
+      page_ok "followed #{join_usernames(follows.map(&:screen_name))}."
+    else
+      page_error "are you already following #{join_usernames(users)} ..?"
+    end
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def unfollow_user(users)
+    users = search_str_for_users(*users)
+    unfollows = twitter.unfollow(users)
+    if unfollows.size > 0
+      page_ok "unfollowed #{join_usernames(unfollows.map(&:screen_name))}."
+    else
+      page_error "did you already unfollow #{join_usernames(users)} ..?"
+    end
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def show_followers(pattern)
+    followers = Array twitter.followers(follow_request_options)
+    __follow_filter!(followers, pattern) if pattern
+    page numbered_list("Followers", followers) {|follower, index|
+      render_user(follower)
+    }
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def show_following(pattern)
+    followings = Array twitter.following(follow_request_options)
+    __follow_filter!(followings, pattern) if pattern
+    page numbered_list("Following", followings) {|following, index|
+      render_user(following)
+    }
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  private
+
+  # @api private
+  def __follow_filter!(users, pattern)
+    users.select! do |u|
+      u.screen_name =~ /#{pattern}/
+    end
+  end
+
+  # @api private
+  def follow_request_options
+    {skip_status: true, include_user_entities: true}
+  end
+
+  # @api private
+  def join_usernames(users)
+    users.map do |username|
+      bold("@#{username}") + " ( https://twitter.com/#{username} )"
+    end.join(', ')
+  end
+end