ex_twitter 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4bd5d8eb5590d0a1eebb86ac2a6d3098c1272467
+  data.tar.gz: 5c8b5655e88e08dce94069e5850d6c682c7a810a
+SHA512:
+  metadata.gz: 7e7b2026369bc3308a1982d513aff1f2fda23005054220a6bb0fbb791b903a367bc6a2fa0366e5026b12ef6f5e06e7d12ff6c64338e084d39f8625eb2c80b945
+  data.tar.gz: f7c0d73420daa1ae4d7121f982f1bbf3e6aca81d799bd8ed703504fc94a3a5009a4e47544082a39126af9a20814c7dba9e2823c4577985ddec94afd4db4ae91e

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+
+

data/ex_twitter.gemspec

@@ -5,7 +5,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'twitter'
   spec.add_dependency 'activesupport'
   spec.add_dependency 'parallel'
+
   spec.add_development_dependency 'bundler'
+
   spec.authors = ['Shinohara Teruki']
   spec.description = %q(A wrapper to the Twitter gem.)
   spec.email = %w[ts_3156@yahoo.co.jp]
@@ -18,5 +20,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = %w[lib]
   spec.summary = spec.description
   spec.test_files = Dir.glob('spec/**/*')
-  spec.version = '0.0.1'
+  spec.version = '0.0.2'
 end

data/lib/ex_twitter.rb

@@ -1,312 +1,219 @@
-# -*- coding: utf-8 -*-
 require 'twitter'
 require 'yaml'
 require 'active_support'
 require 'parallel'
+require 'logger'
 
 # extended twitter
 class ExTwitter < Twitter::REST::Client
-  attr_accessor :cache, :cache_expires_in
+  attr_accessor :cache, :cache_expires_in, :max_attempts, :wait, :auto_paginate, :logger
 
   MAX_ATTEMPTS = 1
   WAIT = false
   CACHE_EXPIRES_IN = 300
 
+  def self.get_config_value(config)
+    return {} if config.nil?
+    {
+      consumer_key: config['consumer_key'],
+      consumer_secret: config['consumer_secret'],
+      access_token: config['access_token'],
+      access_token_secret: config['access_token_secret']
+    }
+  end
+
   def initialize(config={})
+    if config.empty?
+      yml_config = if File.exists?(File.expand_path('./', 'config.yml'))
+        YAML.load_file('config.yml')
+      elsif File.exists?(File.expand_path('./config/', 'config.yml'))
+        YAML.load_file('config/config.yml')
+      end
+      config = self.class.get_config_value(yml_config)
+    end
+
+    self.auto_paginate = (config[:auto_paginate] || true)
+    self.max_attempts = (config[:max_attempts] || MAX_ATTEMPTS)
+    self.wait = (config[:wait] || WAIT)
     self.cache_expires_in = (config[:cache_expires_in] || CACHE_EXPIRES_IN)
     self.cache = ActiveSupport::Cache::FileStore.new(File.join(Dir::pwd, 'ex_twitter_cache'),
       {expires_in: self.cache_expires_in, race_condition_ttl: self.cache_expires_in})
+
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::DEBUG
     super
   end
 
   def read(key)
     self.cache.read(key)
   rescue => e
-    puts "in read #{key} #{e.inspect}"
+    logger.warn "in read #{key} #{e.inspect}"
     nil
   end
 
   def write(key, value)
     self.cache.write(key, value)
   rescue => e
-    puts "in write #{key} #{value} #{e.inspect}"
+    logger.warn "in write #{key} #{value} #{e.inspect}"
     false
   end
 
-  def collect_with_max_id(collection=[], max_id=nil, &block)
-    response = yield(max_id)
-    return response unless response[1].nil?
-
-    collection += response[0]
-    response[0].empty? ? [collection.flatten, nil] : collect_with_max_id(collection, response[0].last.id - 1, &block)
-  end
-
-  def collect_with_cursor(collection=[], cursor=-1, &block)
-    response = yield(cursor)
-    return response unless response[1].nil?
+  # githubでは、レスポンスが次のエンドポイントを知っているため、ブロックをデータの結合のみに使っている。引数ではAPI名を渡している。
+  # 一方、twitterでは、レスポンスが次のエンドポイントを知らないため、ブロック内にAPI名を持ち、再帰的にブロックを呼び出している。
+  # また、再帰を使うため、引数をコレクションの引き渡しに使ってしまっている。(この問題については通常のループを使えば解決する)
+  #
+  # APIは通常繰り返しの呼び出しになるため、API名は常に同じものを保持しておき、ブロックはデータの結合に使った方が無駄がなく自由度が高い。
+  # また、再帰ではなく通常のループを使った方が分かりやすい。
+  #
+  # このgithub方式を実現するためには、メソッド名(例：user_timeline)を渡し、ループさせるか、user_timelineが内部で使っている
+  # objects_from_response_with_userをループさせればよい。
+  #
+  # この2種類の方法を比較した場合、より外側のレイヤーを使った方が、使うライブラリの内部情報に依存しなくなるため、好ましい。
+  #
+  # twitterで再帰方式がとられている理由は、おそらく、一般ユーザー向けのサンプルでメソッド名を渡すようなリフレクションを避けるため、
+  # なのかもしれない。
+  def collect_with_max_id(method_name, *args, &block)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    max_calls = options.delete(:max_calls) || 3
+    data = last_response = send(method_name, *args, options)
+    logger.info "#{method_name}, #{args.inspect} #{options.inspect}"
 
-    collection += (response[0][:users] || response[0][:ids])
-    next_cursor = response[0][:next_cursor]
-    next_cursor == 0 ? [collection.flatten, nil] : collect_with_cursor(collection, next_cursor, &block)
-  end
+    if auto_paginate
+      num_attempts = 0
+      (max_calls - 1).times do
+        break unless last_response.any?
 
-  def get_latest_200_tweets(user=nil)
-    num_attempts = 0
-    options = {count: 200, include_rts: true}
-    begin
-      num_attempts += 1
-      [user_timeline(user, options), nil]
-    rescue Twitter::Error::TooManyRequests => e
-      if num_attempts <= MAX_ATTEMPTS
-        if WAIT
-          sleep e.rate_limit.reset_in
-          retry
-        else
-          puts "retry #{e.rate_limit.reset_in} seconds later"
-          [[], e]
-        end
-      else
-        puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-        [[], e]
-      end
-    rescue => e
-      if num_attempts <= MAX_ATTEMPTS
-        retry
-      else
-        puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-        [[], e]
-      end
-    end
-  end
+        options[:max_id] = last_response.last.id - 1
 
-  def get_all_tweets(user=nil)
-    num_attempts = 0
-    collect_with_max_id do |max_id|
-      options = {count: 200, include_rts: true}
-      options[:max_id] = max_id unless max_id.nil?
-      begin
-        num_attempts += 1
-        [user_timeline(user, options), nil]
-      rescue Twitter::Error::TooManyRequests => e
-        if num_attempts <= MAX_ATTEMPTS
-          if WAIT
-            sleep e.rate_limit.reset_in
-            retry
+        begin
+          last_response = send(method_name, *args, options)
+          logger.info "#{method_name}, #{args.inspect} #{options.inspect}"
+        rescue Twitter::Error::TooManyRequests => e
+          if num_attempts <= MAX_ATTEMPTS
+            if WAIT
+              sleep e.rate_limit.reset_in
+              num_attempts += 1
+              retry
+            else
+              logger.warn "retry #{e.rate_limit.reset_in} seconds later, #{e.inspect}"
+            end
           else
-            puts "retry #{e.rate_limit.reset_in} seconds later"
-            [[], e]
+            logger.warn "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), #{e.inspect}"
           end
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-          [[], e]
-        end
-      rescue => e
-        if num_attempts <= MAX_ATTEMPTS
-          retry
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-          [[], e]
-        end
-      end
-    end
-  end
-
-  def get_all_friends(user=nil)
-    num_attempts = 0
-    collect_with_cursor do |cursor|
-      options = {count: 200, include_user_entities: true}
-      options[:cursor] = cursor unless cursor.nil?
-      cache_key = "#{self.class.name}:#{__callee__}:#{user}:#{options}"
-
-      cache = self.read(cache_key)
-      next [cache, nil] unless cache.nil?
-      begin
-        num_attempts += 1
-        object = friends(user, options)
-        self.write(cache_key, object.attrs)
-        [object.attrs, nil]
-      rescue Twitter::Error::TooManyRequests => e
-        if num_attempts <= MAX_ATTEMPTS
-          if WAIT
-            sleep e.rate_limit.reset_in
+        rescue => e
+          if num_attempts <= MAX_ATTEMPTS
+            logger.warn "retry till num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), #{e.inspect}"
+            num_attempts += 1
             retry
           else
-            puts "retry #{e.rate_limit.reset_in} seconds later"
-            [{}, e]
+            logger.warn "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
           end
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-          [{}, e]
         end
-      rescue => e
-        if num_attempts <= MAX_ATTEMPTS
-          retry
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-          [{}, e]
-        end
-      end
-    end
-  end
 
-  def get_all_followers(user=nil)
-    num_attempts = 0
-    collect_with_cursor do |cursor|
-      options = {count: 200, include_user_entities: true}
-      options[:cursor] = cursor unless cursor.nil?
-      cache_key = "#{self.class.name}:#{__callee__}:#{user}:#{options}"
-
-      cache = self.read(cache_key)
-      next [cache, nil] unless cache.nil?
-      begin
-        num_attempts += 1
-        object = followers(user, options)
-        self.write(cache_key, object.attrs)
-        [object.attrs, nil]
-      rescue Twitter::Error::TooManyRequests => e
-        if num_attempts <= MAX_ATTEMPTS
-          if WAIT
-            sleep e.rate_limit.reset_in
-            retry
-          else
-            puts "retry #{e.rate_limit.reset_in} seconds later"
-            [{}, e]
-          end
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-          [{}, e]
-        end
-      rescue => e
-        if num_attempts <= MAX_ATTEMPTS
-          retry
+        if block_given?
+          yield(data, last_response)
         else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-          [{}, e]
+          data.concat(last_response) if last_response.is_a?(Array)
         end
       end
     end
-  end
 
-  def get_all_friend_ids(user=nil)
-    num_attempts = 0
-    collect_with_cursor do |cursor|
-      options = {count: 5000}
-      options[:cursor] = cursor unless cursor.nil?
-      cache_key = "#{self.class.name}:#{__callee__}:#{user}:#{options}"
-
-      cache = self.read(cache_key)
-      next [cache, nil] unless cache.nil?
-      begin
-        num_attempts += 1
-        object = friend_ids(user, options)
-        self.write(cache_key, object.attrs)
-        [object.attrs, nil]
-      rescue Twitter::Error::TooManyRequests => e
-        if num_attempts <= MAX_ATTEMPTS
-          if WAIT
-            sleep e.rate_limit.reset_in
-            retry
-          else
-            puts "retry #{e.rate_limit.reset_in} seconds later"
-            [{}, e]
-          end
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-          [{}, e]
-        end
-      rescue => e
-        if num_attempts <= MAX_ATTEMPTS
-          retry
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-          [{}, e]
-        end
-      end
-    end
+    data
   end
 
-  def get_all_follower_ids(user=nil)
-    num_attempts = 0
-    collect_with_cursor do |cursor|
-      options = {count: 5000}
-      options[:cursor] = cursor unless cursor.nil?
-      cache_key = "#{self.class.name}:#{__callee__}:#{user}:#{options}"
-
-      cache = self.read(cache_key)
-      next [cache, nil] unless cache.nil?
-      begin
-        num_attempts += 1
-        object = follower_ids(user, options)
-        self.write(cache_key, object.attrs)
-        [object.attrs, nil]
-      rescue Twitter::Error::TooManyRequests => e
-        if num_attempts <= MAX_ATTEMPTS
-          if WAIT
-            sleep e.rate_limit.reset_in
-            retry
-          else
-            puts "retry #{e.rate_limit.reset_in} seconds later"
-            [{}, e]
-          end
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-          [{}, e]
-        end
-      rescue => e
-        if num_attempts <= MAX_ATTEMPTS
-          retry
-        else
-          puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-          [{}, e]
-        end
-      end
-    end
-  end
+  def collect_with_cursor(method_name, *args, &block)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    max_calls = options.delete(:max_calls) || 3
+    last_response = send(method_name, *args, options).attrs
+    logger.info "#{method_name}, #{args.inspect} #{options.inspect}"
+    data = last_response[:users] || last_response[:ids]
 
-  def get_users(ids)
-    ids_per_worker = []
-    while(ids.size > 0)
-      ids_per_worker << ids.slice!(0, [100, ids.size].min)
-    end
+    if auto_paginate
+      num_attempts = 0
+      (max_calls - 1).times do
+        next_cursor = last_response[:next_cursor]
+        break if !next_cursor || next_cursor == 0
+
+        options[:cursor] = next_cursor
 
-    num_attempts = 0
-    processed_users = []
-    Parallel.each_with_index(ids_per_worker, in_threads: ids_per_worker.size) do |ids, i|
-      cache_key = "#{self.class.name}:#{__callee__}:#{i}:#{ids}"
-      cache = self.read(cache_key)
-      if cache.nil?
         begin
-          num_attempts += 1
-          object = {i: i, users: users(ids)}
-          self.write(cache_key, object)
-          processed_users << object
+          last_response = send(method_name, *args, options).attrs
+          logger.info "#{method_name}, #{args.inspect} #{options.inspect}"
         rescue Twitter::Error::TooManyRequests => e
           if num_attempts <= MAX_ATTEMPTS
             if WAIT
               sleep e.rate_limit.reset_in
+              num_attempts += 1
               retry
             else
-              puts "retry #{e.rate_limit.reset_in} seconds later"
-              {i: i, users: [], e: e}
+              logger.warn "retry #{e.rate_limit.reset_in} seconds later, #{e.inspect}"
             end
           else
-            puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS})"
-            {i: i, users: [], e: e}
+            logger.warn "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), #{e.inspect}"
           end
         rescue => e
           if num_attempts <= MAX_ATTEMPTS
+            logger.warn "retry till num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), #{e.inspect}"
+            num_attempts += 1
             retry
           else
-            puts "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
-            {i: i, users: [], e: e}
+            logger.warn "fail. num_attempts > MAX_ATTEMPTS(=#{MAX_ATTEMPTS}), something error #{e.inspect}"
           end
         end
-      else
-        processed_users << cache
+
+        if block_given?
+          yield(data, last_response)
+        else
+          items = last_response[:users] || last_response[:ids]
+          data.concat(items) if items.is_a?(Array)
+        end
       end
     end
-    # TODO remove if users have error, or raise
-    processed_users.sort_by{|p|p[:i]}.map{|p|p[:users]}.flatten
+
+    data
+  end
+
+  alias :old_user_timeline :user_timeline
+  def user_timeline(user = nil, options = {})
+    options = options.merge({count: 200, include_rts: true})
+    collect_with_max_id(:old_user_timeline, user, options)
+  end
+
+  alias :old_friends :friends
+  def friends(user = nil, options = {})
+    options = options.merge({count: 200, include_user_entities: true})
+    collect_with_cursor(:old_friends, user, options)
+  end
+
+  alias :old_followers :followers
+  def followers(user = nil, options = {})
+    options = options.merge({count: 200, include_user_entities: true})
+    collect_with_cursor(:old_followers, user, options)
+  end
+
+  alias :old_friend_ids :friend_ids
+  def friend_ids(user = nil, options = {})
+    options = options.merge({count: 5000})
+    collect_with_cursor(:old_friend_ids, user, options)
+  end
+
+  alias :old_follower_ids :follower_ids
+  def follower_ids(user = nil, options = {})
+    options = options.merge({count: 5000})
+    collect_with_cursor(:old_follower_ids, user, options)
+  end
+
+  alias :old_users :users
+  def users(ids, options = {})
+    ids_per_worker = ids.each_slice(100).to_a
+    processed_users = []
+
+    Parallel.each_with_index(ids_per_worker, in_threads: ids_per_worker.size) do |ids, i|
+      _users = {i: i, users: old_users(ids, options)}
+      processed_users << _users
+    end
+
+    processed_users.sort_by{|p| p[:i] }.map{|p| p[:users] }.flatten
   end
 
   # mentions_timeline is to fetch the timeline of Tweets mentioning the authenticated user
@@ -353,26 +260,4 @@ class ExTwitter < Twitter::REST::Client
   end
 end
 
-if __FILE__ == $0
-  puts '--start--'
-  yml_config = YAML.load_file('config.yml')
-  config = {
-    consumer_key: yml_config['consumer_key'],
-    consumer_secret: yml_config['consumer_secret'],
-    access_token: yml_config['access_token'],
-    access_token_secret: yml_config['access_token_secret']
-  }
-  client = ExTwitter.new(config)
-  #followers, error = client.get_all_followers
-  #puts "#{followers.size} #{error.inspect}"
-  tweets, error = client.search_tweets_except_rt('#グラドル自画撮り部')
-  puts tweets.size
-  tweets.each do |t|
-    next if !t.media?
-    puts t.text
-    puts t.media[0].attrs
-    puts '----'
-  end
-end
-
 

data/spec/ex_twitter_spec.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+describe ExTwitter do
+  let(:config) {
+    {
+      consumer_key: 'CK',
+      consumer_secret: 'CS',
+      access_token: 'AT',
+      access_token_secret: 'ATS'
+    }
+  }
+  let(:client) { ExTwitter.new(config) }
+
+  describe '#initialize' do
+  end
+
+  describe '#read' do
+  end
+
+  describe '#write' do
+  end
+
+  describe '#collect_with_max_id' do
+  end
+
+  describe '#collect_with_cursor' do
+  end
+
+  describe '#user_timeline' do
+    it 'call collect_with_max_id' do
+      expect(client).to receive(:collect_with_max_id)
+      client.user_timeline
+    end
+  end
+
+  describe '#friends' do
+    it 'call collect_with_cursor' do
+      expect(client).to receive(:collect_with_cursor)
+      client.friends
+    end
+  end
+
+  describe '#followers' do
+    it 'call collect_with_cursor' do
+      expect(client).to receive(:collect_with_cursor)
+      client.followers
+    end
+  end
+
+  describe '#friend_ids' do
+    it 'call collect_with_cursor' do
+      expect(client).to receive(:collect_with_cursor)
+      client.friend_ids
+    end
+  end
+
+  describe '#follower_ids' do
+    it 'call collect_with_cursor' do
+      expect(client).to receive(:collect_with_cursor)
+      client.follower_ids
+    end
+  end
+
+  describe '#users' do
+    it 'call old_users' do
+      expect(client).to receive(:old_users)
+      client.users([1, 2, 3])
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,8 @@
+require 'ex_twitter'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: ex_twitter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Shinohara Teruki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-16 00:00:00.000000000 Z
+date: 2014-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: twitter
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A wrapper to the Twitter gem.
@@ -86,31 +77,34 @@ files:
 - README.md
 - Rakefile
 - ex_twitter.gemspec
-- lib/ex_twitter.rb
 - lib/ex_stream.rb
+- lib/ex_twitter.rb
+- spec/ex_twitter_spec.rb
+- spec/helper.rb
 homepage: http://github.com/ts-3156/ex-twitter/
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A wrapper to the Twitter gem.
-test_files: []
+test_files:
+- spec/ex_twitter_spec.rb
+- spec/helper.rb