doomy_client 0.8.5

data/lib/tumblr/blog.rb

@@ -0,0 +1,59 @@
+module Tumblr
+  module Blog
+
+    # Gets the info about the blog
+    def blog_info(blog_name)
+      get(blog_path(blog_name, 'info'), :api_key => @consumer_key)
+    end
+
+    # Gets the avatar URL of specified size
+    def avatar(blog_name, size = nil)
+      url = blog_path(blog_name, 'avatar')
+      url = "#{url}/#{size}" if size
+      get_redirect_url(url)
+    end
+
+    # Gets the list of followers for the blog
+    def followers(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get(blog_path(blog_name, 'followers'), options)
+    end
+
+    # Gets the list of likes for the blog
+    def blog_likes(blog_name, options = {})
+      validate_options([:limit, :offset, :before, :after], options)
+      url = blog_path(blog_name, 'likes')
+
+      params = { :api_key => @consumer_key }
+      params.merge! options
+      get(url, params)
+    end
+
+    def posts(blog_name, options = {})
+      url = blog_path(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(blog_path(blog_name, 'posts/queue'), options)
+    end
+
+    def draft(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get(blog_path(blog_name, 'posts/draft'), options)
+    end
+
+    def submissions(blog_name, options = {})
+      validate_options([:limit, :offset], options)
+      get(blog_path(blog_name, 'posts/submission'), options)
+    end
+
+  end
+end

data/lib/tumblr/client.rb

@@ -0,0 +1,51 @@
+require 'tumblr/blog'
+require 'tumblr/user'
+require 'tumblr/request'
+require 'tumblr/connection'
+require 'tumblr/post'
+require 'tumblr/tagged'
+require 'tumblr/helpers'
+
+module Tumblr
+  class Client
+
+    class << self
+      def default_api_host
+        ENV['TUMBLR_API_HOST'] || 'api.tumblr.com'
+      end
+    end
+
+    include Tumblr::Request
+    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|
+        instance_variable_set("@#{key}".to_sym, attrs[key])
+      end
+    end
+
+    def api_host
+      self.class.default_api_host
+    end
+
+    def api_scheme
+      @api_scheme || 'https'
+    end
+
+    def credentials
+      {
+        :consumer_key => @consumer_key,
+        :consumer_secret => @consumer_secret,
+        :token => @oauth_token,
+        :token_secret => @oauth_token_secret
+      }
+    end
+
+  end
+end

data/lib/tumblr/config.rb

@@ -0,0 +1,36 @@
+module Tumblr
+  module Config
+
+    VALID_OPTIONS_KEYS = [
+      :consumer_key,
+      :consumer_secret,
+      :oauth_token,
+      :oauth_token_secret,
+      :client,
+      :api_scheme
+    ]
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    def configure
+      yield self
+      self
+    end
+
+    def options
+      options = {}
+      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
+      }
+    end
+
+  end
+end

data/lib/tumblr/connection.rb

@@ -0,0 +1,33 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Tumblr
+  module Connection
+
+    def connection(options={})
+      options = options.clone
+
+      default_options = {
+        :headers => {
+          :accept => 'application/json',
+          :user_agent => "tumblr_client/#{Tumblr::VERSION}"
+        },
+        :url => "#{api_scheme}://#{api_host}/"
+      }
+
+      client = Faraday.default_adapter
+
+      Faraday.new(default_options.merge(options)) do |conn|
+        data = { :api_host => api_host, :ignore_extra_keys => true}.merge(credentials)
+        unless credentials.empty?
+          conn.request :oauth, data
+        end
+        conn.request :multipart
+        conn.request :url_encoded
+        conn.response :json, :content_type => /\bjson$/
+        conn.adapter client
+      end
+    end
+
+  end
+end

data/lib/tumblr/helpers.rb

@@ -0,0 +1,29 @@
+module Tumblr
+  module Helper
+
+    private
+
+    def blog_path(blog_name, ext)
+      "v2/blog/#{full_blog_name(blog_name)}/#{ext}"
+    end
+
+    def full_blog_name(blog_name)
+      blog_name.include?('.') ? blog_name : "#{blog_name}.tumblr.com"
+    end
+
+    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

@@ -0,0 +1,147 @@
+require 'mime/types'
+
+module Tumblr
+  module Post
+
+    STANDARD_POST_OPTIONS = [:is_private, :state, :tags, :tweet, :date, :markdown, :slug, :format]
+    DATA_POST_TYPES = [:audio, :video, :photo]
+    VALID_POST_TYPES = DATA_POST_TYPES + [:quote, :text, :link, :chat]
+
+    def edit(blog_name, options = {})
+      convert_source_array :source, options
+      extract_data!(options) if DATA_POST_TYPES.include?(options[:type])
+
+      post(blog_path(blog_name, 'post/edit'), options)
+    end
+
+    def reblog(blog_name, options = {})
+      post(blog_path(blog_name, 'post/reblog'), options)
+    end
+
+    def delete(blog_name, id)
+      post(blog_path(blog_name, 'post/delete'), :id => id)
+    end
+
+    def photo(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:caption, :link, :data, :source, :photoset_layout]
+      validate_options(valid_opts, options)
+      validate_no_collision options, [:data, :source]
+      convert_source_array :source, options
+
+      options[:type] = 'photo'
+      extract_data!(options)
+      post(post_path(blog_name), options)
+    end
+
+    def quote(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:quote, :source]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'quote'
+      post(post_path(blog_name), options)
+    end
+
+    def text(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:title, :body]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'text'
+      post(post_path(blog_name), options)
+    end
+
+    def link(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:title, :url, :description]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'link'
+      post(post_path(blog_name), options)
+    end
+
+    def chat(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:title, :conversation]
+      validate_options(valid_opts, options)
+
+      options[:type] = 'chat'
+      post(post_path(blog_name), options)
+    end
+
+    def audio(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:data, :caption, :external_url]
+      validate_options(valid_opts, options)
+      validate_no_collision options, [:data, :external_url]
+
+      options[:type] = 'audio'
+      extract_data!(options)
+      post(post_path(blog_name), options)
+    end
+
+    def video(blog_name, options = {})
+      valid_opts = STANDARD_POST_OPTIONS + [:data, :embed, :caption]
+      validate_options(valid_opts, options)
+      validate_no_collision options, [:data, :embed]
+
+      options[:type] = 'video'
+      extract_data!(options)
+      post(post_path(blog_name), options)
+    end
+
+    def create_post(type, blog_name, options = {})
+      if VALID_POST_TYPES.include?(type)
+        send(type, blog_name, options)
+      else
+        raise ArgumentError.new "\"#{type}\" is not a valid post type"
+      end
+    end
+
+    private
+
+    def post_path(blog_name)
+      blog_path(blog_name, 'post')
+    end
+
+    # Allow source to be passed as an Array
+    def convert_source_array(key, options)
+      if options.has_key?(key) && options[key].kind_of?(Array)
+        options[key].each.with_index do |src, idx|
+          options["#{key.to_s}[#{idx}]"] = src
+        end
+        options.delete(key)
+      end
+    end
+
+    # Look for the various ways that data can be passed, and normalize
+    # the result in this hash
+    def extract_data!(options)
+      if options.has_key?(:data)
+        data = options.delete :data
+        
+        if Array === data
+          data.each.with_index do |filepath, idx|
+            if filepath.is_a?(Faraday::UploadIO)
+              options["data[#{idx}]"] = filepath
+            else
+              mime_type = extract_mimetype(filepath)
+              options["data[#{idx}]"] = Faraday::UploadIO.new(filepath, mime_type)
+            end
+          end
+        elsif data.is_a?(Faraday::UploadIO)
+          options["data"] = data
+        else
+          mime_type = extract_mimetype(data)
+          options["data"] = Faraday::UploadIO.new(data, mime_type)
+        end
+      end
+    end
+
+    def extract_mimetype(filepath)
+      mime = MIME::Types.type_for(filepath)
+      if (mime.empty?)
+        mime_type = "application/octet-stream"
+      else
+        mime_type = MIME::Types.type_for(filepath)[0].content_type
+      end
+      mime_type
+    end
+
+  end
+end

data/lib/tumblr/request.rb

@@ -0,0 +1,54 @@
+require 'json'
+
+module Tumblr
+  module Request
+
+    # Perform a get request and return the raw response
+    def get_response(path, params = {})
+      connection.get do |req|
+        req.url path
+        req.params = params
+      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)
+    end
+
+    # 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?
+      end
+      #Check for errors and encapsulate
+      respond(response)
+    end
+
+    def respond(response)
+      if [201, 200].include?(response.status)
+        response.body['response']
+      else
+        # surface the meta alongside response
+        res = response.body['meta'] || {}
+        res.merge! response.body['response'] if response.body['response'].is_a?(Hash)
+        res
+      end
+    end
+
+  end
+end

data/lib/tumblr/tagged.rb

@@ -0,0 +1,13 @@
+module Tumblr
+  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

@@ -0,0 +1,41 @@
+module Tumblr
+  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, :before, :after], 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