pry-twitter 1.22.0

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

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

@@ -0,0 +1,23 @@
+module Pry::SendTweet::TwitterAction::LikeActions
+  def like_tweet(tweets)
+    liked = twitter.favorite(tweets)
+    if liked.size > 0
+      render_tweets liked, title: bold("Liked tweets"), timeout: false
+    else
+      page_error "No tweets liked, are you sure you didn't already like those tweet(s) ..?"
+    end
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def unlike_tweet(tweets)
+    unliked = twitter.unfavorite(tweets)
+    if unliked.size > 0
+      render_tweets unliked, title: bold("Unliked tweets"), timeout: false
+    else
+      page_error "No tweets unliked, are you sure you had liked those tweet(s) ..?"
+    end
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+end

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

@@ -0,0 +1,23 @@
+module Pry::SendTweet::TwitterAction::MuteActions
+  def mute_user(strings)
+    muted = twitter.mute(*search_str_for_users(*strings))
+    if muted.size > 0
+      page numbered_list("Muted users", muted) {|user, index|
+        render_user(user)
+      }
+    else
+      page_error "No one was muted, did you mute those user(s) already ..?"
+    end
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def unmute_user(strings)
+    unmuted = twitter.unmute(*search_str_for_users(*strings))
+    page numbered_list("Unmuted users", unmuted) {|user, index|
+      render_user(user)
+    }
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+end

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

@@ -0,0 +1,60 @@
+module Pry::SendTweet::TwitterAction::ProfileActions
+  def set_profile_url(url)
+    if twitter.update_profile url: url
+      page_ok "URL updated"
+    else
+      raise Pry::CommandError, "Something went wrong"
+    end
+  end
+
+  def set_profile_image(path)
+    twitter.update_profile_image(path)
+    page_ok "Profile image updated"
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def set_profile_banner_image(path)
+    base64 = Base64.strict_encode64 File.binread(path)
+    twitter.update_profile_banner(base64)
+    page_ok "Profile banner updated"
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def set_profile_name(name)
+    twitter.update_profile name: name
+    page_ok "Name updated"
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def set_profile_bio
+    Tempfile.open('pry-send_tweet-set-profile-bio') do |file|
+      Pry::Editor.new(_pry_).invoke_editor(file.path, 0)
+      file.rewind
+      twitter.update_profile description: file.read
+      page_ok "Bio updated"
+    end
+  rescue Twitter::Error => e
+    page_error(e)
+  end
+
+  def set_profile_location
+    Tempfile.open('pry-send_tweet-set-profile-location') do |file|
+      Pry::Editor.new(_pry_).invoke_editor(file.path, 0)
+      file.rewind
+      twitter.update_profile location: file.read
+      page_ok "Location updated"
+    end
+  rescue Twitter::Error => e
+    page_error e
+  end
+
+  def set_profile_link_color(color)
+    twitter.update_profile profile_link_color: color
+    page_ok "Profile link color updated"
+  rescue Twitter::Error => e
+    page_error e
+  end
+end

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

@@ -0,0 +1,20 @@
+module Pry::SendTweet::TwitterAction::SuggestedActions
+  def suggested_topics
+    suggested_topics = twitter.suggestions lang: suggested_lang
+    page numbered_list("Suggested topics: ", suggested_topics) {|topic, index|
+      "#{index}. #{topic.slug}"
+    }
+  end
+
+  def suggested_users(topic)
+    topic = URI.escape(topic)
+    users = twitter.suggestions(topic, lang: suggested_lang).users
+    page numbered_list("Suggested users: ", users) {|user, index|
+      render_user(user)
+    }
+  end
+
+  def suggested_lang
+    opts['suggested-lang'] || 'en'
+  end
+end

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

@@ -0,0 +1,36 @@
+class Pry::SendTweet::TwitterSearch < Pry::SendTweet::BaseCommand
+  match 'twitter-search'
+  description 'Search Twitter.'
+  command_options argument_required: true, shellwords: false
+  banner <<-BANNER
+  twitter-search [options] query
+
+  #{description}
+  BANNER
+
+  def options(o)
+    o.on 'c=', 'count=', "The number of tweets to show. Default is " \
+                         "#{default_read_size}."
+  end
+
+  def process(query)
+    super
+    tweets = filter twitter.search(query, search_options).to_a
+    if tweets.empty?
+      page "No results to show."
+    else
+      q = bright_blue(bold(query))
+      render_tweets(tweets, title: format("Showing search results for %{q}", q: q))
+    end
+  end
+
+  private def filter(tweets)
+    tweets.reject(&:retweet?)
+  end
+
+  private def search_options
+    {count: opts['count'] || default_read_size, tweet_mode: 'extended'}
+  end
+
+  Pry.commands.add_command self
+end

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

@@ -0,0 +1,103 @@
+module Pry::SendTweet::TweetRenderer
+  include Timeout
+  include TimeAgoInWords
+
+  def render_tweets(tweet_fetcher, title: nil, timeout: _pry_.config.twitter.refresh_interval)
+    pager = Pry::Pager::SystemPager.new(_pry_.output).tap(&:fork)
+    interval = __choose_render_interval(timeout)
+    timeout(interval) do
+      began_at, refresh_at = __find_timeout_range(interval)
+      rendered_title = __choose_title(title, began_at, refresh_at)
+      tweets = __fetch_tweets(tweet_fetcher)
+      tweets.empty? ? pager.write("No tweets to show.") :
+                      pager.write(__render_tweets(rendered_title, tweets))
+    end
+  rescue Pry::Pager::StopPaging, Interrupt
+    pager.fast_exit!
+    system 'reset'
+  rescue Timeout::Error
+    pager.fast_exit!
+    system 'reset'
+    retry
+  ensure
+    pager.close
+  end
+
+  private
+  # @api private
+  def __render_tweets(title, tweets)
+    title + tweets.map {|tweet|
+      __render_tweet(tweet)
+    }.join("\n")
+  end
+
+  # @api private
+  def __render_tweet(tweet)
+    contents = __read_tweet_body(tweet)
+    body = "#{tweet.url}\n--\n#{contents}\n"
+    height = body.lines.count > box_height ? body.lines.count : box_height
+    TTY::Box.frame(height: height,
+                   width: box_width,
+                   title: {top_left: __render_tweet_title(tweet)}) {body}.to_s
+  end
+
+  # @api private
+  def __render_tweet_title(tweet)
+    user, created_at = tweet.user, tweet.created_at.getlocal
+    title = [
+      red("@#{user.screen_name}"),
+      "Around " + time_ago_in_words(created_at) + " before Last Refresh"
+    ].join green(" | ")
+    " #{title} "
+  end
+
+  # @api private
+  def __read_tweet_body(tweet)
+    uris = tweet.uris
+    text = tweet.attrs[:full_text] ? tweet.attrs[:full_text] :
+                                     tweet.full_text
+    # 'text' might be a frozen string
+    text = text.dup
+    uris.each do |uri|
+      text.gsub!(uri.attrs[:url], uri.attrs[:expanded_url])
+    end
+    CGI.unescapeHTML(text).strip
+  end
+
+  # @api private
+  def __fetch_tweets(tweet_fetcher)
+    if tweet_fetcher.respond_to?(:call)
+      tweet_fetcher.call
+    else
+      # Already fetched
+      tweet_fetcher
+    end
+  end
+
+  # @api private
+  def __choose_title(title, began_at, refresh_at)
+    title = bold green(title || "Twitter")
+    timestamps = [bold("Last Refresh: "), began_at.strftime(time_format), "\n"]
+    timestamps.concat [
+      bold("Next Refresh: "),
+      refresh_at.strftime(time_format),
+      "\n"
+    ] if refresh_at
+    title = "#{title}\n\n"
+    title += timestamps.join
+    title << "\n\n"
+    title
+  end
+
+  # @api private
+  def __choose_render_interval(timeout)
+    return nil if timeout == false
+    timeout || (60*5)
+  end
+
+  # @api private
+  def __find_timeout_range(seconds)
+    seconds ? [Time.now.getlocal, (Time.now + seconds).getlocal] :
+              [Time.now.getlocal, nil]
+  end
+end

data/lib/pry/send_tweet/renderers/user_renderer.rb

@@ -0,0 +1,17 @@
+module Pry::SendTweet::UserRenderer
+  def render_user(user)
+    title = "@#{user.screen_name} ( https://twitter.com/#{user.screen_name} )"
+    body = CGI.unescapeHTML <<-USER.each_line.map(&:strip).join("\n")
+#{bold("Tweets")}    #{user.tweets_count}
+#{bold("Followers")} #{user.followers_count}
+#{bold("Following")} #{user.friends_count}
+#{user.description}
+USER
+    height = body.lines.count > box_height ? body.lines.count : box_height
+    TTY::Box.frame(
+      height: height,
+      width: box_width,
+      title: {top_left: title}
+    ) { body }.to_s
+  end
+end

data/lib/pry/send_tweet/tty-box.rb

@@ -0,0 +1,73 @@
+#
+# A monkey patch module that implements unicode & emoji support in the gem
+# 'tty-box' when using its `frame` method.
+#
+module Pry::SendTweet::TTYPatch
+  require 'tty-box'
+  require 'unicode/display_width'
+  # Create a frame
+  #
+  # @api public
+  def frame(top: nil, left: nil, width: 35, height: 3, align: :left, padding: 0,
+            title: {}, border: :light, style: {})
+    output = []
+    content = []
+    position = top && left
+
+    border = TTY::Box::Border.parse(border)
+    top_size    = border.top? ? 1: 0
+    bottom_size = border.bottom? ? 1: 0
+    left_size   = border.left? ? 1 : 0
+    right_size  = border.right ? 1 : 0
+
+    if block_given?
+      content = format(yield, width, padding, align)
+    end
+
+    fg, bg = *extract_style(style)
+    border_fg, border_bg = *extract_style(style[:border] || {})
+
+    if border.top?
+      output << cursor.move_to(left, top) if position
+      output << top_border(title, width, border, style)
+      output << "\n" unless position
+    end
+
+    (height - top_size - bottom_size).times do |i|
+      output << cursor.move_to(left, top + i + top_size) if position
+      if border.left?
+        output << border_bg.(border_fg.(pipe_char(border.type)))
+      end
+
+      content_size = width - left_size - right_size
+      unless content[i].nil?
+        output << bg.(fg.(content[i]))
+        plain_content = Pry::Helpers::Text.strip_color(content[i])
+        content_size -= Unicode::DisplayWidth.of(plain_content, 1, {})
+      end
+      if style[:fg] || style[:bg] || !position # something to color
+        output << bg.(fg.(' ' * content_size))
+      end
+
+      if border.right?
+        if position
+          output << cursor.move_to(left + width - right_size, top + i + top_size)
+        end
+        output << border_bg.(border_fg.(pipe_char(border.type)))
+      end
+      output << "\n" unless position
+    end
+
+    if border.bottom?
+      output << cursor.move_to(left, top + height - bottom_size) if position
+      output << bottom_border(title, width, border, style)
+      output << "\n" unless position
+    end
+    output.join
+  end
+end
+
+module TTY::Box
+  prepend Pry::SendTweet::TTYPatch
+  singleton_class.module_eval { prepend Pry::SendTweet::TTYPatch }
+end