tumblr_client 0.6.11 → 0.7.0

data/.gitignore

@@ -1,2 +1,11 @@
 *.gem
-.DS_Store
+.DS_Store
+
+*.swp
+*.swo
+
+tmp
+coverage
+.rspec
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,10 @@
+script: 'rspec spec'
+notifications:
+  email:
+    - john.crepezzi@gmail.com
+branches:
+  only:
+    - master
+rvm:
+  - 1.9.2
+  - 1.9.3

data/README.md

@@ -1,5 +1,7 @@
 # Tumblr Ruby Gem
 
+[![Build Status](https://secure.travis-ci.org/codingjester/tumblr_client.png)](http://travis-ci.org/codingjester/tumblr_client)
+
 This is a ruby wrapper for the Tumblr v2 API. There should be support for all endpoints
 currently available on the [Tumblr API](http://www.tumblr.com/docs/en/api/v2).
 
@@ -18,10 +20,10 @@ your life easier when using the v2 api. If you need to do the full oauth workflo
 Configuration for the gem is actually pretty easy:
 
     Tumblr.configure do |config|
-        config.consumer_key = "consumer_key"
-        config.consumer_secret = "consumer_secret"
-        config.oauth_token = "access_token"
-        config.oauth_token_secret = "access_token_secret"
+      config.consumer_key = "consumer_key"
+      config.consumer_secret = "consumer_secret"
+      config.oauth_token = "access_token"
+      config.oauth_token_secret = "access_token_secret"
     end
 
 Once you have your configuration squared away it's time to make some requests!
@@ -33,27 +35,31 @@ That's it! You now have a client that can make any request to the Tumblr API.
 ### Some quick examples
 
 Getting user information:
-    
+
     >> client.info
 
 Getting a specific blog's posts and type:
-    
+
     #Grabbing a specific blogs posts
     >> client.posts("codingjester.tumblr.com")
-    
-    #Grabbing only the last 10 photos off the blog 
+
+    #Grabbing only the last 10 photos off the blog
     >> client.posts("codingjester.tumblr.com", :type => "photo", :limit => 10)
 
 
 Posting some photos to Tumblr:
 
-    #Uploads a great photoset
+    # Uploads a great photoset
     >> client.photo("codingjester.tumblr.com", {:data => ['/path/to/pic.jpg', '/path/to/pic.jpg']}) 
 
+    # You can also post with the raw data
+    >> raw = File.open('/path/to/pic.jpg', 'rb').read
+    >> client.photo('codingjester.tumblr.com', :data_raw => [raw]
+
 ### The irb Console
 
 Finally, there is an irb console packaged with the gem that should help you test any calls you want to make.
-The magic here is that you have a ```.tumblr``` file in your home directory. Inside this file it's just a basic
+The magic here is that you have a `.tumblr` file in your home directory. Inside this file it's just a basic
 YAML layout with four lines:
 
     consumer_key: "your_consumer_key"
@@ -61,12 +67,25 @@ YAML layout with four lines:
     oauth_token: "your_access_token"
     oauth_token_secret: "your_access_token_secret"
 
-From there, you should be able to run any of the above commands, with no problem! Just fire off the command ```tumblr``
+From there, you should be able to run any of the above commands, with no problem! Just fire off the command `tumblr`
 from the terminal and you should be dropped into a console.
 
+---
+
+The first time that you go to use the irb console, if you have no `.tumblr`
+file, it will walk you through the process of generating one.  You will
+be prompted for your consumer_key and consumer_secret (which you can get
+here: http://www.tumblr.com/oauth/register) and then sent out to the site
+to verify your account.  Once you verify, you will be redirected to your
+redirect URL (localhost by default) and copy the `oauth_verifier` back into the
+console.  Then you're all set!
 
 ### Contributions and Pull Requests
 
 No request is too small and I encourage everyone to get involved. As you can see, we're sorely lacking in tests! So
 please if you would like to contribute, let me know and throw me a pull request!
 
+
+### Requirements
+
+* Ruby >= 1.9.2

data/lib/tumblr/blog.rb

@@ -1,73 +1,59 @@
 module Tumblr
-  class Client
-    module Blog
-      
-      @@standard_options = [:type, :id, :tag, :limit, :offset, :reblog_info, :notes_info, :filter]
-      #
-      #Gets the info about the blog
-      #
-      def blog_info(blog_name)
-        get("v2/blog/#{blog_name}/info", {:api_key => @consumer_key})
-      end
+  module Blog
 
-      #
-      # Gets the avatar URL of specified size
-      #
-      def avatar(blog_name, size = nil)
-        response = get_response("v2/blog/#{blog_name}/avatar", :size => size)
-        if response.status == 301
-          response.headers['Location']
-        end
-      end
+    # Gets the info about the blog
+    def blog_info(blog_name)
+      get("v2/blog/#{blog_name}/info", :api_key => @consumer_key)
+    end
 
-      #
-      # Gets the list of followers for the blog
-      #
-      def followers(blog_name, options={})
-        if valid_options([:limit, :offset], options)
-           get("v2/blog/#{blog_name}/followers", options)
-        end
-      end
-      
-      #
-      # Gets the list of likes for the blog
-      #
-      def blog_likes(blog_name, options={})
-        if valid_options([:limit, :offset], options)
-          url = "v2/blog/#{blog_name}/likes"
-          params = {:api_key => @consumer_key}
-          unless options.empty?
-            params.merge!(options)
-          end
-          get(url, params)
-        end
-      end
+    # Gets the avatar URL of specified size
+    def avatar(blog_name, size = nil)
+      url = "v2/blog/#{blog_name}/avatar"
+      url = "#{url}/#{size}" if size
+      get_redirect_url(url)
+    end
 
-      def posts(blog_name, options={})
-        url = "v2/blog/#{blog_name}/posts"
-        
-        if options.has_key?(:type)
-          url = "#{url}/#{options[:type]}"
-        end
-        
-        params = {:api_key => @consumer_key}
-        unless options.empty?
-          params.merge!(options)
-        end
-        get(url, params)
-      end
+    # Gets the list of followers for the blog
+    def followers(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get("v2/blog/#{blog_name}/followers", options)
+    end
 
-      def queue(blog_name)
-        get("v2/blog/#{blog_name}/posts/queue", {})
-      end
-      
-      def draft(blog_name)
-        get("v2/blog/#{blog_name}/posts/draft", {})
-      end
-        
-      def submissions(blog_name)
-        get("v2/blog/#{blog_name}/posts/submission", {})
+    # Gets the list of likes for the blog
+    def blog_likes(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      url = "v2/blog/#{blog_name}/likes"
+
+      params = { :api_key => @consumer_key }
+      params.merge! options
+      get(url, params)
+    end
+
+    def posts(blog_name, options = {})
+      url = "v2/blog/#{blog_name}/posts"
+      if options.has_key?(:type)
+        url = "#{url}/#{options[:type]}"
       end
+
+      params = { :api_key => @consumer_key }
+      params.merge! options
+      get(url, params)
+    end
+
+    def queue(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get("v2/blog/#{blog_name}/posts/queue", options)
     end
+
+    def draft(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get("v2/blog/#{blog_name}/posts/draft", options)
+    end
+
+    def submissions(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get("v2/blog/#{blog_name}/posts/submission", options)
+    end
+
   end
 end

data/lib/tumblr/client.rb

@@ -8,14 +8,15 @@ require 'tumblr/helpers'
 
 module Tumblr
   class Client
+
     include Tumblr::Request
-    include Tumblr::Client::Blog
-    include Tumblr::Client::User
-    include Tumblr::Client::Post
-    include Tumblr::Client::Tagged
-    include Tumblr::Client::Helper
+    include Tumblr::Blog
+    include Tumblr::User
+    include Tumblr::Post
+    include Tumblr::Tagged
+    include Tumblr::Helper
     include Tumblr::Connection
-    
+
     def initialize(attrs= {})
       attrs = Tumblr.options.merge(attrs)
       Config::VALID_OPTIONS_KEYS.each do |key|
@@ -35,5 +36,6 @@ module Tumblr
         :token_secret => @oauth_token_secret
       }
     end
+
   end
 end

data/lib/tumblr/config.rb

@@ -1,5 +1,4 @@
 module Tumblr
-  
   module Config
 
     VALID_OPTIONS_KEYS = [
@@ -8,29 +7,28 @@ module Tumblr
       :oauth_token,
       :oauth_token_secret
     ]
-    
+
     attr_accessor *VALID_OPTIONS_KEYS
 
     def configure
       yield self
       self
     end
-    
+
     def options
       options = {}
-      VALID_OPTIONS_KEYS.each{ |k| options[k] = send(k) }
+      VALID_OPTIONS_KEYS.each{ |pname| options[pname] = send(pname) }
       options
     end
 
     def credentials
       {
-          :consumer_key => consumer_key,
-          :consumer_secret => consumer_secret,
-          :token => oauth_token,
-          :token_secret => oauth_token_secret
+        :consumer_key => consumer_key,
+        :consumer_secret => consumer_secret,
+        :token => oauth_token,
+        :token_secret => oauth_token_secret
       }
     end
 
   end
-
 end

data/lib/tumblr/connection.rb

@@ -4,21 +4,26 @@ require 'tumblr/request/oauth'
 
 module Tumblr
   module Connection
+
     def connection(options={})
+      host = api_host
       default_options = {
         :headers => {
-          :accept => "application/json",
-          :user_agent => "Tumblr v1.0"
+          :accept => 'application/json',
+          :user_agent => "tumblr_client (ruby) - #{Tumblr::VERSION}"
         },
-        :url => "http://#{api_host}/"
+        :url => "http://#{host}/"
       }
-      Faraday.new("http://#{api_host}/", default_options.merge(options)) do |builder|
-        data = { :api_host => api_host }.merge(credentials)
-        builder.use Tumblr::Request::TumblrOAuth, data unless credentials.empty?
+      Faraday.new("http://#{host}/", default_options.merge(options)) do |builder|
+        data = { :api_host => host }.merge(credentials)
+        unless credentials.empty?
+          builder.use Tumblr::Request::TumblrOAuth, data
+        end
         builder.use Faraday::Request::UrlEncoded
-        builder.use FaradayMiddleware::ParseJson, :content_type => "application/json"
+        builder.use FaradayMiddleware::ParseJson, :content_type => 'application/json'
         builder.use Faraday::Adapter::NetHttp
       end
     end
+
   end
 end

data/lib/tumblr/helpers.rb

@@ -1,14 +1,19 @@
 module Tumblr
-  class Client
-    module Helper
-      
-      def valid_options(valid_opts, opts)
-        bad_opts = opts.select { |val| !valid_opts.include?(val) }
-        if !bad_opts.empty?
-          raise Exception, "Invalid options passed, Only #{valid_opts} allowed."
-        end
-        return true
+  module Helper
+
+    def validate_options(valid_opts, opts)
+      bad_opts = opts.select { |val| !valid_opts.include?(val) }
+      if bad_opts.any?
+        raise ArgumentError.new "Invalid options (#{bad_opts.keys.join(', ')}) passed, only #{valid_opts} allowed."
       end
     end
+
+    def validate_no_collision(options, attributes)
+      count = attributes.count { |attr| options.has_key?(attr) }
+      if count > 1
+        raise ArgumentError.new "Can only use one of: #{attributes.join(', ')} (Found #{count})"
+      end
+    end
+
   end
 end

data/lib/tumblr/post.rb

@@ -1,113 +1,110 @@
 module Tumblr
-  class Client
-    module Post
-      
-      @@standard_post_options  = [:state, :tags, :tweet, :date, :markdown, :slug, :format]
-      
-      def edit(blog_name, options={})
-        post("v2/blog/#{blog_name}/post/edit", options)  
-      end
+  module Post
 
-      #Don't be lazy and create a nice interface
-      def reblog(blog_name, options={})
-        post("v2/blog/#{blog_name}/post/reblog", options)  
-      end
-      
-      def delete(blog_name, id)
-        post("v2/blog/#{blog_name}/post/delete", {:id => id})  
-      end
+    STANDARD_POST_OPTIONS = [:state, :tags, :tweet, :date, :markdown, :slug, :format]
 
-      def photo(blog_name, options={})
-        valid_opts = @@standard_post_options + [:caption, :link, :data, :source, :photoset_layout]
-        if valid_options(valid_opts, options)
-          options[:type] = "photo"
-          if (options.has_key?(:data) && options.has_key?(:source))
-            raise Exception, "You can only use one parameter, either source or data."
-          end
-          if options.has_key?(:source) && options[:source].kind_of?(Array)
-            count = 0
-            options[:source].each do |src|
-              options["source[#{count}]"] = src
-              count += 1
-            end
-            options.delete(:source)
-          end
-          if options.has_key?(:data)
-            #Probably can be refactored
-            if options[:data].kind_of?(Array)
-              count = 0
-              options[:data].each do |filepath|
-                options["data[#{count}]"] = File.open(filepath, 'rb').read()
-                count += 1
-              end
-              options.delete(:data)
-            else
-              options[:data] = File.open(options[:data],'rb').read()
-            end
-          end
-          post("v2/blog/#{blog_name}/post", options)  
-        end
-      end
-      
-      def quote(blog_name, options={})
-        valid_opts = @@standard_post_options + [:quote, :source]
-        if valid_options(valid_opts, options)
-          options[:type] = "quote"
-          post("v2/blog/#{blog_name}/post", options)
-        end
-      end
+    def edit(blog_name, options = {})
+      post("v2/blog/#{blog_name}/post/edit", options)
+    end
 
-      def text(blog_name, options={})
-        valid_opts = @@standard_post_options + [:title, :body]
-        if valid_options(valid_opts, options)
-          options[:type] = "text"
-          post("v2/blog/#{blog_name}/post", options)
-        end
-      end
+    def reblog(blog_name, options = {})
+      post("v2/blog/#{blog_name}/post/reblog", options)
+    end
 
-      def link(blog_name, options={})
-        valid_opts = @@standard_post_options + [:title, :url, :description]
-        if valid_options(valid_opts, options)
-          options[:type] = "link"
-          post("v2/blog/#{blog_name}/post", options)
-        end
-      end
+    def delete(blog_name, id)
+      post("v2/blog/#{blog_name}/post/delete", :id => id)
+    end
+
+    def photo(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:caption, :link, :data, :data_raw, :source, :photoset_layout]
+      validate_options(valid_opts, options)
+      validate_no_collision options, [:data, :source]
 
-      def chat(blog_name, options={})
-        valid_opts = @@standard_post_options + [:title, :conversation]
-        if valid_options(valid_opts, options)
-          options[:type] = "chat"
-          post("v2/blog/#{blog_name}/post", options)
+      # Allow source to be passed as an Array
+      if options.has_key?(:source) && options[:source].kind_of?(Array)
+        options[:source].each.with_index do |src, idx|
+          options["source[#{idx}]"] = src
         end
+        options.delete(:source)
       end
 
-      def audio(blog_name, options={})
-        valid_opts = @@standard_post_options + [:data, :caption, :external_url]
-        if valid_options(valid_opts, options)
-          options[:type] = "audio"
-          if (options.has_key?(:data) && options.has_key?(:external_url))
-            raise Exception, "You can only use one parameter, either data or external url."
-          end
-          if(options.has_key?(:data))
-            options[:data] = File.open(options[:data],'rb').read()
-          end
-          post("v2/blog/#{blog_name}/post", options)
+      options[:type] = 'photo'
+      extract_data!(options)
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    def quote(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:quote, :source]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'quote'
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    def text(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:title, :body]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'text'
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    def link(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:title, :url, :description]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'link'
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    def chat(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:title, :conversation]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'chat'
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    def audio(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:data, :data_raw, :caption, :external_url]
+      validate_options(valid_opts, options)
+      validate_no_collision options, [:data, :external_url]
+
+      options[:type] = 'audio'
+      extract_data!(options)
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    def video(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:data, :data_raw, :embed, :caption]
+      validate_options(valid_opts, options)
+      validate_no_collision options, [:data, :embed]
+
+      options[:type] = 'video'
+      extract_data!(options)
+      post("v2/blog/#{blog_name}/post", options)
+    end
+
+    private
+
+    # Look for the various ways that data can be passed, and normalize
+    # the result in this hash
+    def extract_data!(options)
+      validate_no_collision options, [:data, :data_raw]
+      if options.has_key?(:data)
+        data = options.delete :data
+        data = [data] unless Array === data
+        data.each.with_index do |filepath, idx|
+          options["data[#{idx}]"] = File.open(filepath, 'rb').read
         end
-      end
-      
-      def video(blog_name, options={})
-        valid_opts = @@standard_post_options + [:data, :embed, :caption]
-        if valid_options(valid_opts, options)
-          options[:type] = "video"
-          if (options.has_key?(:data) && options.has_key?(:embed))
-            raise Exception, "You can only use one parameter, either data or embed."
-          end
-          if(options.has_key?(:data))
-            options[:data] = File.open(options[:data],'rb').read()
-          end
-          post("v2/blog/#{blog_name}/post", options)
+      elsif options.has_key?(:data_raw)
+        data_raw = options.delete :data_raw
+        data_raw = [data_raw] unless Array === data_raw
+        data_raw.each.with_index do |dr, idx|
+          options["data[#{idx}]"] = dr
         end
       end
     end
-   end
+
+  end
 end