redvine 0.0.7 → 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b6a33f99d78cd7c56d3f38106a674ebeb81c5a9
+  data.tar.gz: ccd30d81ae90c4833dedbdedd2e245d0a1fef7a1
+SHA512:
+  metadata.gz: 845cba04456494faedfb305251fe1c8a1eae217ed5558f02668e9c7955a06454f9199e4a8d9021898f32d6ab507a376339f12a4ea0771159d88eea6c0bc1ba06
+  data.tar.gz: a9a121d3355572e013272497509a326d4f6669701db7ba794c10b623c9030d2ffa85b5d4df5b1d5cb2ea0b55dfe0743144fcded42dd2b48d81403bd6cbc64fa4

data/README.md

@@ -6,6 +6,8 @@ Very heavily inspired by [Vino](https://github.com/tlack/vino), and made possibl
 
 It pretty much goes without saying that this wasn't authorized by Vine or anyone who works at Vine, so don't blame me if you try to use it and Vine gets mad at you. 
 
+Thanks also to [@kdonovan](https://github.com/kdonovan) and [@ruthgsp](https://github.com/ruthgsp) for adding and improving.
+
 ## Installation
 
     gem install redvine
@@ -34,16 +36,22 @@ It pretty much goes without saying that this wasn't authorized by Vine or anyone
     client.user_timeline('908082141764657152')
     client.user_timeline('908082141764657152', :page => 2)
 
+    # Get a user's followers/following by their user ID
+    client.followers('908082141764657152')
+    client.following('908082141764657152', :page => 2)
+
     # Get popular and promoted videos
     client.popular
     client.popular(:page => 2)
     client.promoted
     client.promoted(:page => 2)
+    
+    # Get a single video by the post ID
+    client.single_post('1015405623653113856')
 
 ## Things To Do
 
-* Learn more about the API responses and objects
-* Response pagination
+* Twitter authentication
 * Make it easier to access attributes of common objects (videos and users)
 * Include all of the discovered API endpoints
 

data/lib/redvine.rb

@@ -4,6 +4,21 @@ require 'redvine/version'
 
 class Redvine
 
+  class Error < StandardError; end
+  class ConnectionError < Redvine::Error
+    attr_reader :code
+
+    def initialize(code)
+      @code = code
+    end
+  end
+  
+  class AuthenticationRequiredError < Redvine::Error
+    def initialize(msg="You must authenticate as a valid Vine user (call #connect) before accessing other API methods")
+      super(msg)
+    end
+  end
+
   attr_reader :vine_key, :username, :user_id
 
   @@baseUrl = 'https://api.vineapp.com/'
@@ -15,9 +30,14 @@ class Redvine
     query = {username: opts[:email], password: opts[:password], deviceToken: @@deviceToken}
     headers = {'User-Agent' => @@userAgent}
     response = HTTParty.post(@@baseUrl + 'users/authenticate', {body: query, headers: headers})
-    @vine_key = response.parsed_response['data']['key']
-    @username = response.parsed_response['data']['username']
-    @user_id = response.parsed_response['data']['userId']
+
+    if opts[:skip_exception] || response['success']
+      @vine_key = response.parsed_response['data']['key']
+      @username = response.parsed_response['data']['username']
+      @user_id = response.parsed_response['data']['userId']
+    else
+      raise Redvine::ConnectionError.new(response['code'].to_i), response['error']
+    end
   end
 
   def search(tag, opts={})
@@ -37,6 +57,16 @@ class Redvine
     get_request_data('timelines/graph', opts)
   end
 
+  def following(uid,opts={})
+    raise(ArgumentError, 'You must specify a user id') if !uid
+    get_request_data("users/#{uid}/following", opts)
+  end
+
+  def followers(uid,opts={})
+    raise(ArgumentError, 'You must specify a user id') if !uid
+    get_request_data("users/#{uid}/followers", opts)
+  end
+
   def user_profile(uid)
     raise(ArgumentError, 'You must specify a user id') if !uid
     get_request_data('users/profiles/' + uid, {}, false)
@@ -71,11 +101,13 @@ class Redvine
   end
 
   def get_request_data(endpoint, query={}, records=true)
+    raise Redvine::AuthenticationRequiredError unless @vine_key
+    
     query.merge!(:size => 20) if query.has_key?(:page) && !query.has_key?(:size)
     args = {:headers => session_headers}
     args.merge!(:query => query) if query != {}
     response = HTTParty.get(@@baseUrl + endpoint, args).parsed_response
-    return Hashie::Mash.new(JSON.parse('{"success": false}')) if response.kind_of?(String) 
+    return Hashie::Mash.new(JSON.parse('{"success": false}')) if response.kind_of?(String)
     if response['success'] == false
       response['error'] = true
       return Hashie::Mash.new(response)

data/lib/redvine/version.rb

@@ -1,3 +1,3 @@
 class Redvine
-  VERSION = "0.0.7"
+  VERSION = "0.1"
 end

data/redvine.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'httparty'
   gem.add_dependency 'hashie'
 
+  gem.add_development_dependency 'debugger'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'webmock'

data/spec/redvine_spec.rb

@@ -6,249 +6,342 @@ include Helpers
 
 describe Redvine do
 
-  describe '.connect' do
+  it "should require connecting before accessing other API methods" do
+    config = get_config
+    client = Redvine.new
+    expect { client.search('cat') }.to raise_error(Redvine::AuthenticationRequiredError)
+  end
 
+  describe '.connect' do
+    
+    let(:config) { get_config() }
+    let(:client) { Redvine.new }
+    
     it 'should create a new client' do
-      expect(Redvine.new).to respond_to(:connect).with(1).argument
+      expect(client).to respond_to(:connect).with(1).argument
     end
 
     it 'should raise an error without a username and password' do
-      client = Redvine.new
       expect { client.connect() }.to raise_error(ArgumentError)
     end
     
     it 'should connect and return a hash with a :vine_key' do
       VCR.use_cassette('redvine') do
-        config = get_config()
-        client = Redvine.new
         client.connect(email: config['email'], password: config['password'])
         expect(client.vine_key).to be_an_instance_of(String)
       end
     end
 
-  end
-
-  describe '.search' do
-
-    it 'should respond to a search method' do
-      VCR.use_cassette('redvine') do
-        client = setup_client()
-        expect(client).to respond_to(:search)
+    it 'should raise a specific error if username/password is incorrect' do
+      VCR.use_cassette('redvine_error') do
+        expect { client.connect(email: 'fake_email@someplace.net', password: 'nope1nope2nope3') }.to raise_error(Redvine::ConnectionError)
       end
     end
 
-    it 'should throw an error without a tag' do
-      VCR.use_cassette('redvine') do
-        client = setup_client()
-        expect{ client.search() }.to raise_error(ArgumentError)
+    it 'should extract error code and message if username/password is incorrect' do
+      VCR.use_cassette('redvine_error') do
+        begin
+          client.connect(email: 'fake_email@someplace.net', password: 'nope1nope2nope3')
+        rescue Redvine::ConnectionError => e
+          expect(e.code).to be_an_instance_of(Fixnum)
+          expect(e.code).to be > 0
+          expect(e.message).to be_an_instance_of(String)
+        end
       end
     end
 
-    it 'should return a result set with videoUrls when searching for a common keyword' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.search('cat')
-        expect(vines.count).to be > 1
-        expect(vines.first.videoUrl).to be_an_instance_of(String)
-        expect(vines.last.videoUrl).to be_an_instance_of(String)
+    it 'should not raise if passed skip_exception when username/password is incorrect' do
+      VCR.use_cassette('redvine_error') do
+        expect { client.connect(email: 'fake_email@someplace.net', password: 'nope1nope2nope3', skip_exception: true) }.to_not raise_error
       end
     end
 
-    it 'should return a second page of results' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.search('cat')
-        vinesp2 = client.search('cat', :page => 2)
-        expect(vines).to_not equal(vinesp2)
-        expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+  end
+  
+  context '(when authenticated)' do
+  
+    let(:client) { setup_client() }
+  
+    describe '.search' do
+
+      it 'should respond to a search method' do
+        VCR.use_cassette('redvine') do
+          expect(client).to respond_to(:search)
+        end
       end
-    end
 
-  end
+      it 'should throw an error without a tag' do
+        VCR.use_cassette('redvine') do
+          expect{ client.search() }.to raise_error(ArgumentError)
+        end
+      end
 
-  describe '.popular' do
+      it 'should return a result set with videoUrls when searching for a common keyword' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.search('cat')
+          expect(vines.count).to be > 1
+          expect(vines.first.videoUrl).to be_an_instance_of(String)
+          expect(vines.last.videoUrl).to be_an_instance_of(String)
+        end
+      end
+
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.search('cat')
+          vinesp2 = client.search('cat', :page => 2)
+          expect(vines).to_not equal(vinesp2)
+          expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+        end
+      end
 
-    it 'should respond to a popular method' do
-      expect(Redvine.new).to respond_to(:popular)
     end
 
-    it 'should return a set of results with VideoUrls' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.popular
-        expect(vines.count).to be > 1
-        expect(vines.first.videoUrl).to be_an_instance_of(String)
+    describe '.popular' do
+
+      it 'should respond to a popular method' do
+        expect(client).to respond_to(:popular)
+      end
+
+      it 'should return a set of results with VideoUrls' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.popular
+          expect(vines.count).to be > 1
+          expect(vines.first.videoUrl).to be_an_instance_of(String)
+        end
       end
-    end
 
-    it 'should return a second page of results' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.popular
-        vinesp2 = client.popular(:page => 2)
-        expect(vines).to_not equal(vinesp2)
-        expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.popular
+          vinesp2 = client.popular(:page => 2)
+          expect(vines).to_not equal(vinesp2)
+          expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+        end
       end
+
     end
 
-  end
 
+    describe '.promoted' do
 
-  describe '.promoted' do
+      it 'should respond to a promoted method' do
+        expect(client).to respond_to(:promoted)
+      end
 
-    it 'should respond to a promoted method' do
-      expect(Redvine.new).to respond_to(:promoted)
-    end
+      it 'should return a set of results with VideoUrls' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.promoted
+          expect(vines.count).to be > 1
+          expect(vines.first.videoUrl).to be_an_instance_of(String)
+        end
+      end
 
-    it 'should return a set of results with VideoUrls' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.promoted
-        expect(vines.count).to be > 1
-        expect(vines.first.videoUrl).to be_an_instance_of(String)
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.promoted
+          vinesp2 = client.promoted(:page => 2)
+          expect(vines).to_not equal(vinesp2)
+          expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+        end
       end
+
     end
 
-    it 'should return a second page of results' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.promoted
-        vinesp2 = client.promoted(:page => 2)
-        expect(vines).to_not equal(vinesp2)
-        expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+    describe '.timeline' do
+
+      it 'should respond to a timeline method' do
+        expect(client).to respond_to(:timeline)
       end
-    end
 
-  end
+      it 'should return a set of results with VideoUrls' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.timeline
+          expect(vines.count).to be > 1
+          expect(vines.first.videoUrl).to be_an_instance_of(String)
+        end
+      end
 
-  describe '.timeline' do
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.timeline()
+          vinesp2 = client.timeline(:page => 2)
+          expect(vines).to_not equal(vinesp2)
+          expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+        end
+      end
 
-    it 'should respond to a timeline method' do
-      expect(Redvine.new).to respond_to(:timeline)
     end
 
-    it 'should return a set of results with VideoUrls' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.timeline
-        expect(vines.count).to be > 1
-        expect(vines.first.videoUrl).to be_an_instance_of(String)
+    describe '.user_profile' do
+
+      it 'should respond to a user_profile method' do
+        expect(client).to respond_to(:user_profile)
       end
-    end
 
-    it 'should return a second page of results' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.timeline()
-        vinesp2 = client.timeline(:page => 2)
-        expect(vines).to_not equal(vinesp2)
-        expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+      it 'should throw an error without a user id' do
+        expect { client.user_profile() }.to raise_error(ArgumentError)
       end
-    end
 
-  end
+      it 'should return a user profile for the authenticated user' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          profile = client.user_profile(client.user_id.to_s)
+          expect(profile.userId).not_to be_nil
+          expect(profile.username).to be_an_instance_of(String)
+          expect(profile.avatarUrl).to be_an_instance_of(String)
+        end
+      end
 
-  describe '.user_profile' do
+      it 'should return a user profile given a valid user id' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          profile = client.user_profile('914021455983943680')
+          expect(profile.userId).not_to be_nil
+          expect(profile.username).to be_an_instance_of(String)
+          expect(profile.avatarUrl).to be_an_instance_of(String)
+        end
+      end
 
-    it 'should respond to a user_profile method' do
-      expect(Redvine.new).to respond_to(:user_profile)
     end
 
-    it 'should throw an error without a user id' do
-      client = Redvine.new
-      expect { client.user_profile() }.to raise_error(ArgumentError)
-    end
+    describe '.user_timeline' do
 
-    it 'should return a user profile for the authenticated user' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        profile = client.user_profile(client.user_id.to_s)
-        expect(profile.userId).not_to be_nil
-        expect(profile.username).to be_an_instance_of(String)
-        expect(profile.avatarUrl).to be_an_instance_of(String)
+      it 'should respond to a user_timeline method' do
+        expect(client).to respond_to(:user_timeline)
       end
-    end
 
-    it 'should return a user profile given a valid user id' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        profile = client.user_profile('914021455983943680')
-        expect(profile.userId).not_to be_nil
-        expect(profile.username).to be_an_instance_of(String)
-        expect(profile.avatarUrl).to be_an_instance_of(String)
+      it 'should throw an error without a user id' do
+        expect { client.user_timeline() }.to raise_error(ArgumentError)
       end
-    end
 
-  end
+      it 'should return a set of results with VideoUrls given a valid user id' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.user_timeline('914021455983943680')
+          expect(vines.count).to be > 1
+          expect(vines.first.videoUrl).to be_an_instance_of(String)
+        end
+      end
 
-  describe '.user_timeline' do
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.user_timeline('914021455983943680')
+          vinesp2 = client.user_timeline('914021455983943680', :page => 2)
+          expect(vines).to_not equal(vinesp2)
+          expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+        end
+      end
 
-    it 'should respond to a user_timeline method' do
-      expect(Redvine.new).to respond_to(:user_timeline)
-    end
+      it 'should not break if an error is returned from Vine' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vines = client.user_timeline('965095451261071400')
+          expect(vines.success).to be_false
+          vines = client.user_timeline('XXX')
+          expect(vines.success).to be_false
+        end
+      end
 
-    it 'should throw an error without a user id' do
-      client = Redvine.new
-      expect { client.user_timeline() }.to raise_error(ArgumentError)
     end
 
-    it 'should return a set of results with VideoUrls given a valid user id' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.user_timeline('914021455983943680')
-        expect(vines.count).to be > 1
-        expect(vines.first.videoUrl).to be_an_instance_of(String)
+    describe '.following' do
+  
+      it 'should respond to a following method' do
+        expect(client).to respond_to(:following)
       end
-    end
-
-    it 'should return a second page of results' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.user_timeline('914021455983943680')
-        vinesp2 = client.user_timeline('914021455983943680', :page => 2)
-        expect(vines).to_not equal(vinesp2)
-        expect(vines.first.videoUrl).to_not equal(vinesp2.first.videoUrl)
+  
+      it 'should throw an error without a user id' do
+        expect { client.following() }.to raise_error(ArgumentError)
+      end
+  
+      it 'should return a set of results with avatar and username given a valid user id' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          users = client.following('914021455983943680')
+          expect(users.count).to be > 1
+          expect(users.first.username).to be_an_instance_of(String)
+          expect(users.first.avatarUrl).to be_an_instance_of(String)
+        end
+      end
+  
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          users = client.following('914021455983943680')
+          usersp2 = client.following('914021455983943680', :page => 2)
+          expect(users).to_not equal(usersp2)
+          expect(users.first.avatarUrl).to_not equal(usersp2.first.avatarUrl)
+        end
+      end
+  
+      it 'should not break if an error is returned from Vine' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          users = client.following('965095451261071400')
+          expect(users.success).to be_false
+          users = client.following('XXX')
+          expect(users.success).to be_false
+        end
       end
+  
     end
 
-    it 'should not break if an error is returned from Vine' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vines = client.user_timeline('965095451261071400')
-        expect(vines.success).to be_false
-        vines = client.user_timeline('XXX')
-        expect(vines.success).to be_false
+    describe '.followers' do
+  
+      it 'should respond to a followers method' do
+        expect(client).to respond_to(:followers)
+      end
+  
+      it 'should throw an error without a user id' do
+        expect { client.followers() }.to raise_error(ArgumentError)
+      end
+  
+      it 'should return a set of results with avatar and username given a valid user id' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          users = client.followers('914021455983943680')
+          expect(users.count).to be > 1
+          expect(users.first.username).to be_an_instance_of(String)
+          expect(users.first.avatarUrl).to be_an_instance_of(String)
+        end
+      end
+  
+      it 'should return a second page of results' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          users = client.followers('914021455983943680')
+          usersp2 = client.followers('914021455983943680', :page => 2)
+          expect(users).to_not equal(usersp2)
+          expect(users.first.avatarUrl).to_not equal(usersp2.first.avatarUrl)
+        end
+      end
+  
+      it 'should not break if an error is returned from Vine' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          users = client.followers('965095451261071400')
+          expect(users.success).to be_false
+          users = client.followers('XXX')
+          expect(users.success).to be_false
+        end
       end
+  
     end
 
-  end
-
-  describe '.single_post' do
+    describe '.single_post' do
 
-    it 'should respond to a single_post method' do
-      expect(Redvine.new).to respond_to(:single_post)
-    end
+      it 'should respond to a single_post method' do
+        expect(client).to respond_to(:single_post)
+      end
 
-    it 'should require a post id as an argument' do
-      client = Redvine.new
-      expect { client.single_post() }.to raise_error(ArgumentError)
-    end
+      it 'should require a post id as an argument' do
+        expect { client.single_post() }.to raise_error(ArgumentError)
+      end
 
-    it 'should return a single media result with a valid post id' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vine = client.single_post('1015405623653113856')
-        expect(vine.videoUrl).to be_an_instance_of(String)
+      it 'should return a single media result with a valid post id' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vine = client.single_post('1038918228849876992')
+          expect(vine.videoUrl).to be_an_instance_of(String)
+        end
       end
-    end
 
-    it 'should not break if no post exists with that id' do
-      VCR.use_cassette('redvine', :record => :new_episodes) do
-        client = setup_client()
-        vine = client.single_post('397923400300')
-        expect(vine.success).to be_false
-        vine2 = client.single_post('XXX')
-        expect(vine2.success).to be_false
+      it 'should not break if no post exists with that id' do
+        VCR.use_cassette('redvine', :record => :new_episodes) do
+          vine = client.single_post('397923400300')
+          expect(vine.success).to be_false
+          vine2 = client.single_post('XXX')
+          expect(vine2.success).to be_false
+        end
       end
     end
 

data/spec/spec_helper.rb

@@ -1,8 +1,12 @@
+require 'debugger'
+
 module Helpers
   def setup_client
     config = get_config()
     client = Redvine.new
-    client.connect(email: config['email'], password: config['password'])
+    VCR.use_cassette('redvine_auth') do
+      client.connect(email: config['email'], password: config['password'])
+    end
     client
   end
 

metadata

@@ -1,126 +1,125 @@
 --- !ruby/object:Gem::Specification
 name: redvine
 version: !ruby/object:Gem::Version
-  version: 0.0.7
-  prerelease: 
+  version: '0.1'
 platform: ruby
 authors:
 - Jay Stakelon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-22 00:00:00.000000000 Z
+date: 2014-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
   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: hashie
   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: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   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'
 - !ruby/object:Gem::Dependency
   name: rspec
   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'
 - !ruby/object:Gem::Dependency
   name: webmock
   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'
 - !ruby/object:Gem::Dependency
   name: vcr
   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'
 - !ruby/object:Gem::Dependency
   name: autotest-standalone
   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 client for the unofficial Vine API.
@@ -144,27 +143,26 @@ files:
 - spec/vcr_setup.rb
 homepage: http://github.com/stakes/redvine
 licenses: []
+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.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A client for the unofficial Vine API.
 test_files:
 - spec/redvine_spec.rb