tumblr_client 0.6.11 → 0.7.0

data/lib/tumblr/request.rb

@@ -11,6 +11,16 @@ module Tumblr
       end
     end
 
+    # get a redirect url
+    def get_redirect_url(path, params = {})
+      response = get_response path, params
+      if response.status == 301
+        response.headers['Location']
+      else
+        response.body['meta']
+      end
+    end
+
     # Performs a get request
     def get(path, params={})
       respond get_response(path, params)
@@ -18,6 +28,9 @@ module Tumblr
 
     # Performs post request
     def post(path, params={})
+      if Array === params[:tags]
+        params[:tags] = params[:tags].join(',')
+      end
       response = connection.post do |req|
         req.url path
         req.body = params unless params.empty?

data/lib/tumblr/request/oauth.rb

@@ -7,22 +7,22 @@ require 'base64'
 module Tumblr
   module Request
     class TumblrOAuth < Faraday::Middleware
+
       def call(env)
-        if env[:method].to_s == "get"
-            params = Faraday::Utils.parse_query(env[:url].query) || {}
-            url = "#{env[:url].scheme}://#{env[:url].host}#{env[:url].path}"
+        if env[:method].to_s == 'get'
+          params = Faraday::Utils.parse_query(env[:url].query) || {}
+          url = "#{env[:url].scheme}://#{env[:url].host}#{env[:url].path}"
         else
-            params = env[:body] || {}
-            url = env[:url]
+          params = env[:body] || {}
+          url = env[:url]
         end
         signature_params = params
         params.each do |key, value|
           signature_params = {} if value.respond_to?(:content_type)
         end
-        env[:request_headers]["Authorization"] = self.oauth_gen(env[:method], url, signature_params) 
-        env[:request_headers]["Content-type"] = "application/x-www-form-urlencoded"                                                                              
-        env[:request_headers]["Host"] = @options[:api_host]
-        
+        env[:request_headers]['Authorization'] = self.oauth_gen(env[:method], url, signature_params)
+        env[:request_headers]['Content-type'] = 'application/x-www-form-urlencoded'
+        env[:request_headers]['Host'] = @options[:api_host]
 
         @app.call(env)
       end
@@ -37,36 +37,36 @@ module Tumblr
          params[:oauth_signature_method] = 'HMAC-SHA1'
          params[:oauth_timestamp] = Time.now.to_i
          params[:oauth_token] = @options[:token]
-         params[:oauth_version] = "1.0"
+         params[:oauth_version] = '1.0'
          params[:oauth_signature] = self.oauth_sig(method, url, params)
-         
+
          header = []
          params.each do |key, value|
-            if key.to_s.include?("oauth")
-              header << "#{key.to_s}=#{value}"
-            end
+           if key.to_s.include?('oauth')
+             header << "#{key.to_s}=#{value}"
+           end
          end
 
          "OAuth #{header.join(", ")}"
-
       end
-      
+
       def oauth_sig(method, url, params)
         parts = [method.upcase, URI.encode(url.to_s, /[^a-z0-9\-\.\_\~]/i)]
-        
+
         #sort the parameters
         params = Hash[params.sort_by{ |key, value| key.to_s}]
-        
+
         encoded = []
         params.each do |key, value|
-            encoded << "#{key.to_s}=#{URI.encode(value.to_s, /[^a-z0-9\-\.\_\~]/i)}"
+          encoded << "#{key.to_s}=#{URI.encode(value.to_s, /[^a-z0-9\-\.\_\~]/i)}"
         end
 
-        parts << URI.encode(encoded.join("&"), /[^a-z0-9\-\.\_\~]/i)
-        signature_base = parts.join("&")
+        parts << URI.encode(encoded.join('&'), /[^a-z0-9\-\.\_\~]/i)
+        signature_base = parts.join('&')
         secret = "#{@options[:consumer_secret]}&#{@options[:token_secret]}"
         Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, secret, signature_base)).chomp.gsub(/\n/, '')
       end
+
     end
   end
 end

data/lib/tumblr/tagged.rb

@@ -1,18 +1,13 @@
 module Tumblr
-  class Client
-    module Tagged
-      
-      @@standard_options = [:before, :limit, :filter]
-      
-      def tagged(tag, options={})
-        params = {:tag => tag, :api_key => @consumer_key}
-        unless options.empty?
-          params.merge!(options)
-        end
-        if valid_options(@@standard_options, options)
-            get("v2/tagged", params)
-        end
-      end
+  module Tagged
+
+    def tagged(tag, options={})
+      validate_options([:before, :limit, :filter], options)
+
+      params = { :tag => tag, :api_key => @consumer_key }
+      params.merge!(options)
+      get("v2/tagged", params)
     end
+
   end
 end

data/lib/tumblr/user.rb

@@ -1,40 +1,41 @@
 module Tumblr
-  class Client
-    module User
-      def info
-        info = get("v2/user/info")
-      end
-
-      def dashboard(options={})
-        valid_opts = [:limit, :offset, :type, :since_id, :reblog_info, :notes_info]
-        if valid_options(valid_opts, options)
-          get("v2/user/dashboard", options)
-        end
-      end
-
-      def likes(offset=0, limit=20)
-        likes = get("v2/user/likes", {:limit => limit, :offset => offset})
-      end
-
-      def following(offset=0, limit=20)
-        following = get("v2/user/following", {:limit => limit, :offset => offset})
-      end
-
-      def follow(url)
-        follow = post("v2/user/follow", {:url => url})
-      end
-    
-      def unfollow(url)
-        follow = post("v2/user/unfollow", {:url => url})
-      end
-
-      def like(id, reblog_key)
-        like = post("v2/user/like", {:id => id, :reblog_key => reblog_key})
-      end
-
-      def unlike(id, reblog_key)
-        unlike = post("v2/user/unlike", {:id => id, :reblog_key => reblog_key})
-      end 
+  module User
+
+    def info
+      get('v2/user/info')
+    end
+
+    def dashboard(options = {})
+      valid_opts = [:limit, :offset, :type, :since_id, :reblog_info, :notes_info]
+      validate_options(valid_opts, options)
+      get('v2/user/dashboard', options)
+    end
+
+    def likes(options = {})
+      validate_options([:limit, :offset], options)
+      get('v2/user/likes', options)
+    end
+
+    def following(options = {})
+      validate_options([:limit, :offset], options)
+      get('v2/user/following', options)
+    end
+
+    def follow(url)
+      post('v2/user/follow', :url => url)
+    end
+
+    def unfollow(url)
+      post('v2/user/unfollow', :url => url)
+    end
+
+    def like(id, reblog_key)
+      post('v2/user/like', :id => id, :reblog_key => reblog_key)
+    end
+
+    def unlike(id, reblog_key)
+      post('v2/user/unlike', :id => id, :reblog_key => reblog_key)
     end
+
   end
 end

data/lib/tumblr/version.rb

@@ -0,0 +1,5 @@
+module Tumblr
+
+  VERSION = '0.7.0'
+
+end

data/lib/tumblr_client.rb

@@ -1,11 +1,16 @@
-require "tumblr/client"
-require "tumblr/config"
+require 'tumblr/client'
+require 'tumblr/config'
 
 module Tumblr
+
+  autoload :VERSION, File.join(File.dirname(__FILE__), 'tumblr/version')
+
   extend Config
+
   class << self
     def new(options={})
       Tumblr::Client.new(options)
     end
   end
+
 end

data/spec/examples/blog_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe Tumblr::Blog do
+
+  let(:blog_name) { 'seejohnrun.tumblr.com' }
+  let(:consumer_key) { 'ckey' }
+  let(:client) do
+    Tumblr::Client.new :consumer_key => consumer_key
+  end
+
+  describe :blog_info do
+
+    it 'should make the proper request' do
+      client.should_receive(:get).once.with("v2/blog/#{blog_name}/info", {
+        :api_key => consumer_key
+      }).and_return 'response'
+      r = client.blog_info blog_name
+      r.should == 'response'
+    end
+
+  end
+
+  describe :avatar do
+
+    context 'when supplying a size' do
+
+      before do
+        client.should_receive(:get_redirect_url).once.with("v2/blog/#{blog_name}/avatar/128").
+        and_return('url')
+      end
+
+      it 'should construct the request properly' do
+        r = client.avatar blog_name, 128
+        r.should == 'url'
+      end
+
+    end
+
+    context 'when no size is specified' do
+
+      before do
+        client.should_receive(:get_redirect_url).once.with("v2/blog/#{blog_name}/avatar").
+        and_return('url')
+      end
+
+      it 'should construct the request properly' do
+        r = client.avatar blog_name
+        r.should == 'url'
+      end
+
+    end
+
+  end
+
+  describe :followers do
+
+    context 'with invalid parameters' do
+
+      it 'should raise an error' do
+        lambda {
+          client.followers blog_name, :not => 'an option'
+        }.should raise_error ArgumentError
+      end
+
+    end
+
+    context 'with valid parameters' do
+
+      before do
+        client.should_receive(:get).once.with("v2/blog/#{blog_name}/followers", {
+          :limit => 1
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.followers blog_name, :limit => 1
+        r.should == 'response'
+      end
+
+    end
+
+  end
+
+  describe :blog_likes do
+
+    context 'with invalid parameters' do
+
+      it 'should raise an error' do
+        lambda {
+          client.blog_likes blog_name, :not => 'an option'
+        }.should raise_error ArgumentError
+      end
+
+    end
+
+    context 'with valid parameters' do
+
+      before do
+        client.should_receive(:get).once.with("v2/blog/#{blog_name}/likes", {
+          :limit => 1,
+          :api_key => consumer_key
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.blog_likes blog_name, :limit => 1
+        r.should == 'response'
+      end
+
+    end
+
+  end
+
+  describe :posts do
+
+    context 'without a type supplied' do
+
+      before do
+        client.should_receive(:get).once.with("v2/blog/#{blog_name}/posts", {
+          :limit => 1,
+          :api_key => consumer_key
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.posts blog_name, :limit => 1
+        r.should == 'response'
+      end
+
+    end
+
+    context 'when supplying a type' do
+
+      before do
+        client.should_receive(:get).once.with("v2/blog/#{blog_name}/posts/audio", {
+          :limit => 1,
+          :api_key => consumer_key,
+          :type => 'audio'
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.posts blog_name, :limit => 1, :type => 'audio'
+        r.should == 'response'
+      end
+
+    end
+
+  end
+
+  # These are all just lists of posts with pagination
+  [:queue, :draft, :submissions].each do |type|
+
+    ext = type == :submissions ? 'submission' : type.to_s # annoying
+
+    describe type do
+
+      context 'when using parameters other than limit & offset' do
+
+        it 'should raise an error' do
+          lambda {
+            client.send type, blog_name, :not => 'an option'
+          }.should raise_error ArgumentError
+        end
+
+      end
+
+      context 'with valid options' do
+
+        it 'should construct the call properly' do
+          limit = 5
+          client.should_receive(:get).once.with("v2/blog/#{blog_name}/posts/#{ext}", {
+            :limit => limit
+          }).and_return('response')
+          r = client.send type, blog_name, :limit => limit
+          r.should == 'response'
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/examples/client_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Tumblr::Client do
+
+  context 'when using the generic copy' do
+
+    before do
+      @key = 'thekey'
+      Tumblr.configure do |c|
+        c.consumer_key = @key
+      end
+    end
+
+    it 'should give new clients those credentials' do
+      client = Tumblr::Client.new
+      client.credentials[:consumer_key].should == @key
+    end
+
+    it 'should have it\'s own credentials' do
+      Tumblr.credentials[:consumer_key].should == @key
+    end
+
+    it 'should be able to make a new client (using these credentials)' do
+      Tumblr.new.should be_a(Tumblr::Client)
+      Tumblr.new.credentials[:consumer_key].should == @key
+    end
+
+  end
+
+  context 'when using custom copies of the client' do
+
+    before do
+      @client1 = Tumblr::Client.new(:consumer_key => 'key1')
+      @client2 = Tumblr::Client.new(:consumer_key => 'key2')
+    end
+
+    it 'should keep them separate' do
+      [
+        @client1.credentials[:consumer_key],
+        @client2.credentials[:consumer_key]
+      ].uniq.count.should == 2
+    end
+
+  end
+
+end