twitter_friendly 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef71f130f04b632a363dd5dbe4f7e2b91127d3e74da06b2250d63bf939c90a86
-  data.tar.gz: 4b0796b5bb063275954bade7042cb0ebe165710d8bc519b7844d78934c6817a0
+  metadata.gz: cec5d0d0bab4de7c8cc59727c5c57ce632b76c6e40c3684a66cce539cbb509ef
+  data.tar.gz: d37e61958513f084b5eed73f68f9d073202dd58e774138072cb6a1b28b3e70bc
 SHA512:
-  metadata.gz: 473bd0e95817c1d6ff726374466fce9eace07ee8b4f3333674f0a2dcfa648b62c47e5641e88a21d4430618c09af342f4f07836fe5190aefeaa5bb3b588c8611a
-  data.tar.gz: e5af4919178d9602423a7c30944850d09080bd4e9fdc81f55de42466fe6705f23e0ce7a4d51a0abc52d7628db3bcc673791f06735e88cafd5675dac9d7995185
+  metadata.gz: 376dbce938d1e5baf735fee3ff09a869ce2b2b562c159046c1a92c37d9e5408d2f5ae4ce005f98eb62d5dbb6f10b31229b15bd402a905c949ad9adbe38aa0aae
+  data.tar.gz: 93f140337e9a317165f974e65a992e34a42d1f278add7add063379c882c51aeef54ccb179cef419e02ad21956f3d9aad2f370fad211d5bb680ab587fa8298eeb

data/.gitignore

@@ -7,4 +7,8 @@
 /spec/reports/
 /tmp/
 
+*.log
+/.pryrc
+/.env
+/.twitter_friendly
 /.idea

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,41 @@
+language: ruby
+cache: bundler
+
+# For ruby compatibility, we test the highest and lowest minor versions only.
+# For example, if our gemspec says `required_ruby_version = ">= 2.3.0"`, and
+# ruby 2.5.0 has just been released, then we test 2.3 and 2.5, but not 2.4.
+rvm:
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+
+env:
+  global:
+    - TRAVIS=true
+
+# We want to use `sudo: false` because the container infrastructure is supposed
+# to be faster, but Travis is having issues with containers lately ..
+#
+# > No output has been received in the last 10m0s
+#
+# .. and they recommend we use the VM infrastructure (`sudo: required`) in
+# the meantime.
+sudo: required
+
+before_install:
+  - gem update bundler
+
+gemfile:
+  - gemfiles/ar_4.2.gemfile
+  - gemfiles/ar_5.1.gemfile
+  - gemfiles/ar_5.2.gemfile
+matrix:
+  exclude:
+    # optimization: don't test intermediate rubies (see above)
+    - rvm: 2.4.5
+      gemfile: gemfiles/ar_4.2.gemfile
+    - rvm: 2.4.5
+      gemfile: gemfiles/ar_5.1.gemfile
+    - rvm: 2.4.5
+      gemfile: gemfiles/ar_5.2.gemfile
+  fast_finish: true

data/Gemfile.lock

@@ -1,18 +1,29 @@
 PATH
   remote: .
   specs:
-    twitter_friendly (0.1.0)
+    twitter_friendly (0.2.0)
+      activesupport (>= 4.2, < 6.0)
+      oj (~> 3.7.6)
       parallel (~> 1.12.1)
       twitter (~> 6.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (5.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
     addressable (2.5.2)
       public_suffix (>= 2.0.2, < 4.0)
     buftok (0.2.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.4)
+    diff-lcs (1.3)
     domain_name (0.5.20180417)
       unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.6.0)
     equalizer (0.0.11)
     http (3.3.0)
       addressable (~> 2.3)
@@ -23,13 +34,35 @@ GEM
       domain_name (~> 0.5)
     http-form_data (2.1.1)
     http_parser.rb (0.6.0)
+    i18n (1.5.1)
+      concurrent-ruby (~> 1.0)
     memoizable (0.4.2)
       thread_safe (~> 0.3, >= 0.3.1)
+    method_source (0.9.2)
+    minitest (5.11.3)
     multipart-post (2.0.0)
     naught (1.1.0)
+    oj (3.7.6)
     parallel (1.12.1)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
     public_suffix (3.0.3)
-    rake (10.5.0)
+    rake (12.3.2)
+    rb-readline (0.5.5)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
     simple_oauth (0.3.1)
     thread_safe (0.3.6)
     twitter (6.2.0)
@@ -43,6 +76,8 @@ GEM
       multipart-post (~> 2.0)
       naught (~> 1.0)
       simple_oauth (~> 0.3.0)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.7.5)
@@ -51,9 +86,13 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
-  rake (~> 10.0)
+  bundler
+  dotenv
+  pry
+  rake
+  rb-readline
+  rspec (~> 3.8)
   twitter_friendly!
 
 BUNDLED WITH
-   1.17.2
+   2.0.1

data/README.md

@@ -1,8 +1,13 @@
-# TwitterFriendly
+# twitter_friendly
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/twitter_friendly`. To experiment with that code, run `bin/console` for an interactive prompt.
+[![Gem Version](https://badge.fury.io/rb/twitter_friendly.png)](https://badge.fury.io/rb/twitter_friendly)
+[![Build Status](https://travis-ci.org/ts-3156/twitter_friendly.svg?branch=master)](https://travis-ci.org/ts-3156/twitter_friendly)
 
-TODO: Delete this and the text above, and describe your gem
+A twitter-friendly Ruby interface to the Twitter API. This twitter_friendly gem provides multiple features.
+
+- Auto pagination
+- Auto caching
+- Parallelly fetching
 
 ## Installation
 
@@ -14,25 +19,172 @@ gem 'twitter_friendly'
 
 And then execute:
 
-    $ bundle
+```sh
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install twitter_friendly
+```sh
+$ gem install twitter_friendly
+```
+
+## Configuration
+
+You can pass configuration options as a block to `TwitterFriendly::Client.new` just like the below.
+
+```
+client = TwitterFriendly::Client.new do |config|
+  config.consumer_key        = "YOUR_CONSUMER_KEY"
+  config.consumer_secret     = "YOUR_CONSUMER_SECRET"
+  config.access_token        = "YOUR_ACCESS_TOKEN"
+  config.access_token_secret = "YOUR_ACCESS_SECRET"
+end
+```
+
+## Useful features
+
+After configuring a `client`, you can do the following things.
+
+Fetch all friends's user IDs (by screen name or user ID, or by implicit authenticated user)
+
+```ruby
+ids = client.follower_ids('gem')
+ids.size
+# => 1741
+```
+
+As using a cache, it's super fast from the second time.
+
+```ruby
+Benchmark.bm 20 do |r|
+  r.report "Fetch follower_ids" do
+    client.follower_ids('gem')
+  end
+  r.report "(Cached)" do
+    client.follower_ids('gem')
+  end
+end
+
+#                            user     system      total        real
+# Fetch follower_ids     0.010330   0.003607   0.013937 (  0.981068)
+# (Cached)               0.000865   0.000153   0.001018 (  0.001019) <- Roughly 900 times faster!
+```
+
+You don't need to write a boilerplate code as having auto pagination feature.
+
+```ruby
+users = client.follower_ids('a_user_has_many_friends')
+users.size
+# => 50000
+```
+
+If you don't use twitter_friendly gem, you must write the code like the below to fetch all follower's ids.
+
+```ruby
+def collect_with_max_id(collection=[], max_id=nil, &block)
+  response = yield(max_id)
+  collection += response
+  response.empty? ? collection.flatten : collect_with_max_id(collection, response.last.id - 1, &block)
+end
+
+ids =
+  collect_with_max_id do |max_id|
+    options = {count: 200, include_rts: true}
+    options[:max_id] = max_id unless max_id.nil?
+    client.follower_ids('user_name', options)
+  end
+```
+
+Additionally, twitter_friendly gem has a parallel execution feature.
+
+```ruby
+ids = [id1, id2, id3, ... , id1000]
+
+Benchmark.bm 25 do |r|
+  r.report "Fetch users in parallel" do
+    client.users(ids)
+  end
+
+  client.cache.clear
 
-## Usage
+  r.report "Fetch users in serial" do
+    client.users(ids, parallel: false)
+  end
+end
 
-TODO: Write usage instructions here
+#                                 user     system      total        real
+# Fetch users in parallel     0.271966   0.057981   0.329947 (  2.675270) <- Super fast!
+# Fetch users in serial       0.201375   0.044399   0.245774 (  8.068372)
+```
+
+## Usage examples
+
+Fetch all friends's user IDs (by screen name or user ID, or by implicit authenticated user)
+
+```ruby
+client.friend_ids('gem')
+client.friend_ids(213747670)
+client.friend_ids
+```
+
+Fetch all followers's user IDs (by screen name or user ID, or by implicit authenticated user)
+
+```ruby
+client.follower_ids('gem')
+client.follower_ids(213747670)
+client.follower_ids
+```
+
+Fetch all friends with profile details (by screen name or user ID, or by implicit authenticated user)
+
+```ruby
+client.friends('gem')
+client.friends(213747670)
+client.friends
+```
 
-## Development
+Fetch all followers with profile details (by screen name or user ID, or by implicit authenticated user)
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```ruby
+client.followers('gem')
+client.followers(213747670)
+client.followers
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Fetch the timeline of Tweets (by screen name or user ID, or by implicit authenticated user)
+
+```ruby
+client.user_timeline('gem')
+client.user_timeline(213747670)
+client.user_timeline
+
+result.size
+# => 588
+
+result.first.text
+# => "Your tweet text..."
+
+result.first.user.screen_name
+# => "your_screen_name"
+```
+
+Fetch the timeline of Tweets from the authenticated user's home page
+
+```ruby
+client.home_timeline
+```
+
+Fetch the timeline of Tweets mentioning the authenticated user
+
+```ruby
+client.mentions_timeline
+```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/twitter_friendly.
+Bug reports and pull requests are welcome on GitHub at https://github.com/ts-3156/twitter_friendly.
 
 ## License
 

data/bin/test/friends_and_followers.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'dotenv/load'
+require 'twitter_friendly'
+
+TwitterFriendly.cache.clear
+
+client =
+  TwitterFriendly::Client.new(
+    consumer_key: ENV['CK'],
+    consumer_secret: ENV['CS'],
+    access_token: ENV['AT'],
+    access_token_secret: ENV['ATS']
+  )
+
+def diff(ary1, ary2)
+  [ary1 - ary2, ary2 - ary1]
+end
+
+def diff?(ary1, ary2)
+  diff(ary1, ary2).flatten.any?
+end
+
+def users_diff(ary1, ary2)
+  diff(ary1.map {|a| a[:id]}, ary2.map {|a| a[:id]})
+end
+
+def users_diff?(ary1, ary2)
+  users_diff(ary1, ary2).flatten.any?
+end
+
+friend_ids = follower_ids = []
+
+%i(friend_ids follower_ids).each do |method|
+  ids = client.send(method)
+  cached_ids = client.send(method)
+  raw_ids = client.internal_client.send(method).attrs[:ids]
+
+  puts method
+  puts "  fetch #{ids.size}, cache #{cached_ids.size}, raw #{raw_ids.size}"
+  puts "  ids is different from cached_ids diff=#{diff(ids, cached_ids).inspect}" if diff?(ids, cached_ids)
+  puts "  cached_ids is different from raw_ids diff=#{diff(cached_ids, raw_ids).inspect}" if diff?(cached_ids, raw_ids)
+  puts "  ids is different from raw_ids diff=#{diff(ids, raw_ids).inspect}" if diff?(ids, raw_ids)
+  puts "  #{client.rate_limit.send(method)}"
+
+  eval("#{method}=ids")
+end
+
+client.cache.clear
+
+ids1, ids2 = client.friend_ids_and_follower_ids
+cached_ids1, cached_ids2 = client.friend_ids_and_follower_ids
+
+puts 'friend_ids_and_follower_ids'
+puts "  fetch #{ids1.size}, cache #{cached_ids1.size}"
+puts "  fetch #{ids2.size}, cache #{cached_ids2.size}"
+puts "  ids1 is different from cached_ids1 diff=#{diff(ids1, cached_ids1)}" if diff?(ids1, cached_ids1)
+puts "  ids2 is different from cached_ids2 diff=#{diff(ids2, cached_ids2)}" if diff?(ids2, cached_ids2)
+
+client.cache.clear
+
+friends = followers = []
+
+%i(friends followers).each do |method|
+  users = client.send(method)
+  cached_users = client.send(method)
+  # raw_users = client.internal_client.send(method).attrs[:users]
+
+  puts method
+  puts "  users #{users.size}, cached_users #{cached_users.size}"
+  puts "  users is different from cached_users diff=#{users_diff(users, cached_users)}" if users_diff?(users, cached_users)
+  # puts "  cached_users is different from raw_users" if cached_users != raw_users
+  # puts "  users is different from raw_users" if users != raw_users
+  puts "  #{client.rate_limit.send(method)}"
+
+  eval("#{method}=users")
+end
+
+client.cache.clear
+
+users1, users2 = client.friends_and_followers
+cached_users1, cached_users2 = client.friends_and_followers
+
+puts 'friends_and_followers'
+puts "  fetch #{users1.size}, cache #{cached_users1.size}"
+puts "  fetch #{users2.size}, cache #{cached_users2.size}"
+puts "  users1 is different from cached_users1 diff=#{users_diff(users1, cached_users1)}" if users_diff?(users1, cached_users1)
+puts "  users2 is different from cached_users2 diff=#{users_diff(users2, cached_users2)}" if users_diff?(users2, cached_users2)
+
+client.cache.clear
+
+puts friend_ids.zip(friends).all? {|id, user| id == user[:id] }
+puts follower_ids.zip(followers).all? {|id, user| id == user[:id] }
+
+puts 'ok'