tumblr-rb 1.3.0 → 2.0.0.alpha

data/lib/tumblr.rb

@@ -1,185 +1,8 @@
-require 'weary'
+require 'tumblr/version'
 
-class Tumblr
-  VERSION = "1.3.0"
-  GENERATOR = "The Tumblr Gem v#{VERSION}"
-  USER_AGENT = "TumblrGem/#{VERSION} (+http://github.com/mwunsch/tumblr)"
-  
-  require 'tumblr/post'
-  require 'tumblr/reader'
-  require 'tumblr/writer'
-  require 'tumblr/authenticator'
-  
-  def initialize(*credentials)
-    @credentials = {:email => credentials[0], :password => credentials[1]} unless credentials.blank?
-  end
-  
-  # Convenience method for Reader#read
-  def read(username, parameters={})
-    reader.read(username, parameters)
-  end
-  
-  # Post a document to Tumblr. If the document has a post-id, it will be edited.
-  def post(doc)
-    tumblr_post = if doc.is_a?(Tumblr::Post)
-      doc.to_h
-    elsif doc.respond_to?(:keys)
-      doc
-    else
-      Tumblr.parse(doc).to_h
-    end
-    tumblr_post.has_key?(:'post-id') ? writer.edit(tumblr_post) : writer.write(tumblr_post)
-  end
-  
-  def dashboard(parameters={})
-    raise 'Requires an e-mail address and password' unless @credentials
-    reader.dashboard(parameters)
-  end
-  
-  def authenticate(theme = false)
-    raise 'Requires an e-mail address and password' unless @credentials
-    params = theme ? {:'include-theme' => 1} : {}
-    Authenticator.new(@credentials[:email],@credentials[:password]).authenticate(params)
-  end
-  
-  def pages(username)
-    reader.pages(username)
-  end
-  
-  def all_pages(username)
-    reader.all_pages(username)
-  end
-  
-  def reader
-    if @credentials.blank?
-      Reader.new
-    else
-      Reader.new(@credentials[:email],@credentials[:password])
-    end
-  end
-  
-  def writer
-    raise 'Requires an e-mail address and password' unless @credentials
-    Writer.new(@credentials[:email],@credentials[:password])
-  end
-  
-  def self.execute(credentials, input)
-    request = new(credentials[:email],credentials[:password]).post(input)
-    request.perform
-  end
-  
-  # Parse a post out of a string
-  def self.parse(doc)
-    document = {}
-    if doc =~ /^(\s*---(.*)---\s*)/m
-      document[:data] = YAML.load(Regexp.last_match[2].strip)
-      document[:body] = doc.sub(Regexp.last_match[1],'').strip
-    else
-      document[:data] = {'type' => infer_post_type(doc)}
-      document[:body] = doc
-    end
-    create_post document
-  end
-  
-  # Guess the Type of Post for a given documents
-  def self.infer_post_type(doc)
-    begin
-      url = URI.parse(doc)
-      if url.is_a?(URI::HTTP)
-        (url.host.include?('youtube.com') || url.host.include?('vimeo.com')) ? :video : :link
-      else
-        :regular
-      end
-    rescue URI::InvalidURIError
-      :regular
-    end
-  end
-      
-  # Map a post type key to its class
-  def self.map(key)
-    case key
-      when :regular
-        Post::Regular
-      when :photo
-        Post::Photo
-      when :quote
-        Post::Quote
-      when :link
-        Post::Link
-      when :conversation
-        Post::Conversation
-      when :video
-        Post::Video
-      when :audio
-        Post::Audio
-      else
-        raise "#{key} is not an understood Tumblr post type"
-    end
-  end
-  
-  private
-  
-  def self.create_post(document)
-    post_data = document[:data]
-    type = (post_data['type'] || infer_post_type(document[:body])).to_sym
-    post = case type
-      when :regular
-        create_regular document
-      when :photo
-        create_photo document
-      when :audio
-        create_audio document
-      when :quote, :link, :conversation, :video
-        create_simple type, document
-      else
-        raise "#{type} is not a recognized Tumblr post type."
-    end
-    basic_setup post, post_data
-  end
-  
-  def self.basic_setup(post, post_data)
-    %w(format state private slug date group generator reblog-key).each do |basic|
-      post.send "#{basic}=".gsub('-','_').intern, post_data[basic] if post_data[basic]
-    end
-    %w(tags send-to-twitter publish-on).each do |attribute|
-      post.send attribute.gsub('-','_').intern, post_data[attribute] if post_data[attribute]
-    end
-    post
-  end
-  
-  def self.setup_params(post, data)
-    post_params = post.class.parameters.collect {|param| param.to_s.gsub('_','-') }
-    post_params.each do |param|
-      post.send "#{param.gsub('-','_')}=".intern, data[param] if data[param]
-    end
-    post
-  end
-    
-  def self.create_regular(doc)
-    data = doc[:data]
-    post = Tumblr::Post::Regular.new(data['post-id'])
-    post.body = doc[:body]
-    setup_params post, data
-  end
-  
-  def self.create_photo(doc)
-    data = doc[:data]
-    post = Tumblr::Post::Photo.new(data['post-id'])
-    post.source = doc[:body]
-    setup_params post, data
-  end
-  
-  def self.create_audio(doc)
-    data = doc[:data]
-    post = Tumblr::Post::Audio.new(data['post-id'])
-    post.externally_hosted_url = doc[:body]
-    setup_params post, data
-  end
-  
-  def self.create_simple(type, doc)
-    data = doc[:data]
-    post = map(type).new(doc[:body], data['post-id'])
-    setup_params post, data
-  end  
-  
-end
+module Tumblr
+  require "tumblr/client"
+  require "tumblr/post"
+
+  autoload :Authentication, "tumblr/authentication"
+end

data/lib/tumblr/authentication.rb

@@ -0,0 +1,71 @@
+require 'sinatra/base'
+require 'weary/request'
+require 'weary/middleware'
+
+module Tumblr
+  # http://www.tumblr.com/oauth/apps
+  class Authentication < Sinatra::Base
+    HOST = "http://www.tumblr.com/oauth"
+
+    enable :sessions
+    set :credential_path, nil
+
+    def request_token(key, secret, callback)
+      Weary::Request.new "#{HOST}/request_token", :POST do |req|
+        req.params :oauth_callback => callback
+        req.use Weary::Middleware::OAuth, :consumer_key => key,
+                                          :consumer_secret => secret
+      end
+    end
+
+    def access_token(token, token_secret, verifier, consumer_key, consumer_secret)
+      Weary::Request.new "#{HOST}/access_token", :POST do |req|
+        req.use Weary::Middleware::OAuth, :token => token,
+                                          :token_secret => token_secret,
+                                          :verifier => verifier,
+                                          :consumer_key => consumer_key,
+                                          :consumer_secret => consumer_secret
+      end
+    end
+
+    get "/" do
+      halt 400, erb(:form) unless params["key"] && params["secret"]
+      session[:consumer_key] = params["key"]
+      session[:consumer_secret] = params["secret"]
+      response = request_token(session[:consumer_key], session[:consumer_secret], url("/auth")).perform
+      if response.success?
+        result = Rack::Utils.parse_query(response.body)
+        logger.info(request.host)
+        session[:request_token_secret] = result["oauth_token_secret"]
+        redirect to("#{HOST}/authorize?oauth_token=#{result['oauth_token']}")
+      else
+        status response.status
+        erb response.body
+      end
+    end
+
+    get "/auth" do
+      halt 401, erb(:error) if params.empty?
+      token = params["oauth_token"]
+      verifier = params["oauth_verifier"]
+      response = access_token(token, session[:request_token_secret], verifier,
+        session[:consumer_key], session[:consumer_secret]).perform
+      if response.success?
+        require 'tumblr/credentials'
+        result = Rack::Utils.parse_query(response.body)
+        credentials = Tumblr::Credentials.new(settings.credential_path)
+        credentials.write session[:consumer_key],
+                          session[:consumer_secret],
+                          result["oauth_token"],
+                          result["oauth_token_secret"]
+        @credential_path = credentials.path
+        status response.status
+        erb :success
+      else
+        status response.status
+        erb response.body
+      end
+    end
+
+  end
+end

data/lib/tumblr/client.rb

@@ -0,0 +1,148 @@
+require "weary"
+
+module Tumblr
+  class Client < Weary::Client
+    API_VERSION = "v2"
+
+    USER_AGENT = "Tumblr API Client (Ruby)/#{Tumblr::VERSION} (+http://github.com/mwunsch/tumblr)"
+
+    POST_OPTIONS = [
+      :state, :tags, :tweet, :date, :format, :slug,
+      :title, :body, # Text posts
+      :caption, :link, :source, :data, #Photo posts
+      :quote, # Quote posts
+      :url, :description, # Link posts
+      :conversation, # Chat posts
+      :external_url, # Audio posts
+      :embed, # Video posts
+      :answer # Answer posts ??
+    ]
+
+    domain "http://api.tumblr.com/#{API_VERSION}"
+
+    user_agent USER_AGENT
+
+    get :info, "/blog/{hostname}/info" do |r|
+      r.required :api_key
+    end
+
+    get :avatar, "/blog/{hostname}/avatar" do |r|
+      r.optional :size
+    end
+
+    get :followers, "/blog/{hostname}/followers" do |r|
+      r.oauth!
+      r.optional :limit, :offset
+    end
+
+    get :posts, "/blog/{hostname}/posts" do |r|
+      r.required :api_key
+      r.optional :type, :id, :tag, :limit, :offset, :reblog_info,
+                 :notes_info, :filter
+    end
+
+    get :queue, "/blog/{hostname}/posts/queue" do |r|
+      r.oauth!
+    end
+
+    get :draft, "/blog/{hostname}/posts/draft" do |r|
+      r.oauth!
+    end
+
+    get :submission, "/blog/{hostname}/posts/submission" do |r|
+      r.oauth!
+    end
+
+    post :post, "/blog/{hostname}/post" do |r|
+      r.oauth!
+      r.required :type
+      r.optional *POST_OPTIONS
+    end
+
+    post :edit, "/blog/{hostname}/post/edit" do |r|
+      r.oauth!
+      r.required :id
+      r.optional *POST_OPTIONS
+    end
+
+    post :reblog, "/blog/{hostname}/post/reblog" do |r|
+      r.oauth!
+      r.required :id, :reblog_key
+      r.optional *(POST_OPTIONS | [:comment])
+    end
+
+    post :delete, "/blog/{hostname}/post/delete" do |r|
+      r.oauth!
+      r.required :id
+    end
+
+    get :user, "/user/info" do |r|
+      r.oauth!
+    end
+
+    get :dashboard, "/user/dashboard" do |r|
+      r.oauth!
+      r.optional :limit, :offset, :type, :since_id, :reblog_info, :notes_info
+    end
+
+    get :likes, "/user/likes" do |r|
+      r.oauth!
+      r.optional :limit, :offset
+    end
+
+    get :following, "/user/following" do |r|
+      r.oauth!
+      r.optional :limit, :offset
+    end
+
+    post :follow, "/user/follow" do |r|
+      r.oauth!
+      r.required :url
+    end
+
+    post :unfollow, "/user/unfollow" do |r|
+      r.oauth!
+      r.required :url
+    end
+
+    post :like, "/user/like" do |r|
+      r.oauth!
+      r.required :id, :reblog_key
+    end
+
+    post :unlike, "/user/unlike" do |r|
+      r.oauth!
+      r.required :id, :reblog_key
+    end
+
+    get :tagged, "/tagged" do |r|
+      r.required :api_key, :tag
+      r.optional :before, :limit, :filter
+    end
+
+    def self.load(hostname = nil, path = nil)
+      require "tumblr/credentials"
+      credentials = Tumblr::Credentials.new(path).read
+      self.new(hostname, credentials)
+    end
+
+    def initialize(hostname = nil, oauth_params = {})
+      @defaults = {}
+      @defaults[:hostname] = hostname if hostname
+      [:consumer_key, :consumer_secret, :token, :token_secret].each do |param|
+        @defaults[param] = value_for_key_as_string_or_symbol(oauth_params, param) if hash_includes_key_as_string_or_symbol?(oauth_params, param)
+      end
+      @defaults[:api_key] = value_for_key_as_string_or_symbol(oauth_params, :consumer_key)
+    end
+
+    private
+
+    def value_for_key_as_string_or_symbol(hash, key)
+      hash[key.to_sym] || hash[key.to_s]
+    end
+
+    def hash_includes_key_as_string_or_symbol?(hash, key)
+      hash.keys.map(&:to_s).include? key.to_s
+    end
+  end
+end

data/lib/tumblr/command_line_interface.rb

@@ -0,0 +1,222 @@
+require 'thor'
+require 'tumblr'
+
+module Tumblr
+  class CommandLineInterface < Thor
+    include Thor::Actions
+
+    default_task :pipe
+
+    class_option :credentials, :type => :string,
+                               :desc => "The file path where your Tumblr OAuth keys are stored. Defaults to ~/.tumblr."
+    class_option :host, :type => :string,
+                        :desc => 'The hostname of the blog you want to post to i.e. "YOUR-NAME.tumblr.com"'
+
+
+    check_unknown_options!(:except => [])
+
+
+    desc "pipe", "Pipe post content in from STDIN"
+    method_option :publish, :type => :boolean,
+                            :aliases => "-p",
+                            :desc => "Publish this post"
+    method_option :queue, :type => :boolean,
+                          :aliases => "-q",
+                          :desc => "Add this post to the queue"
+    method_option :draft, :type => :boolean,
+                          :aliases => "-d",
+                          :desc => "Save this post as a draft"
+    long_desc <<-LONGDESC
+      Publish a post to tumblr from STDIN for HOST.
+      It is assumed that STDIN contains a document formatted according to `tumblr(5)`.
+      If STDIN contains a URL, it will create a post using the same rules as `tumblr post`.
+
+      Writes the serialized post to STDOUT.
+    LONGDESC
+    def pipe
+      if !$stdin.tty?
+        puts post($stdin).serialize
+      else
+        invoke :help
+      end
+    end
+
+    desc "post <POST> | <FILE> | <URL>", "Posts to tumblr"
+    method_option :publish, :type => :boolean,
+                            :aliases => "-p",
+                            :desc => "Publish this post"
+    method_option :queue, :type => :boolean,
+                          :aliases => "-q",
+                          :desc => "Add this post to the queue"
+    method_option :draft, :type => :boolean,
+                          :aliases => "-d",
+                          :desc => "Save this post as a draft"
+    long_desc <<-LONGDESC
+      Post a POST to Tumblr for HOST. If a FILE path is given, the file will be read and posted to Tumblr.
+      It is assumed the post follows the `tumblr(5)` format.
+
+      If the FILE is an audio, image, or video file, it will create the respective post type on tumblr.
+
+      If a URL is given, a link post will be created.
+      If URL is a YouTube or Vimeo link, it will create a video post.
+      If URL is a SoundCloud or Spotify link, an audio post will be published.
+    LONGDESC
+    def post(arg)
+      client = get_client
+      post =  if arg.respond_to? :read
+                Tumblr::Post.load arg.read
+              elsif File.file?(file_path = File.expand_path(arg))
+                Tumblr::Post.load_from_path file_path
+              else
+                Tumblr::Post.load arg.to_s
+              end
+      post.publish! if options[:publish]
+      post.queue! if options[:queue]
+      post.draft! if options[:draft]
+      response = post.post(client).perform
+      tumblr_error(response) unless response.success?
+      ui_success %Q(Post was successfully created! Post ID: #{response.parse["response"]["id"]}) if $stdin.tty?
+      post
+    end
+
+    desc "edit POST_ID", "Edit a post"
+    long_desc "Open up your $EDITOR to edit a published post."
+    long_desc <<-LONGDESC
+      Get a post from Tumblr and edit it.
+
+      Behaves similar to `git commit`, in that it will open up your editor in the foreground.
+      Look for a $TUMBLREDITOR environment variable, and if that's not found, will use $EDITOR.
+    LONGDESC
+    def edit(id)
+      client = get_client
+      response = client.posts(:id => id, :filter => :raw).perform
+      tumblr_error(response) unless response.success?
+      post = Tumblr::Post.create(response.parse["response"]["posts"].first)
+      require 'tempfile'
+      tmp_file = Tempfile.new("post_#{id}")
+      tmp_file.write(post.serialize)
+      tmp_file.rewind
+      ui_abort "Something went wrong editing the post." unless system "#{editor} #{tmp_file.path}"
+      edited_post = Tumblr::Post.load_from_path tmp_file.path
+      edited_response = edited_post.edit(client).perform
+      tumblr_error(edited_response) unless edited_response.success?
+      ui_success "Post #{id} successfully edited."
+    ensure
+      if tmp_file
+        tmp_file.close
+        tmp_file.unlink
+      end
+    end
+
+    desc "fetch POST_ID", "Fetch a post and write out its serialized form."
+    def fetch(id)
+      client = get_client
+      response = client.posts(:id => id, :filter => :raw).perform
+      tumblr_error(response) unless response.success?
+      post = Tumblr::Post.create(response.parse["response"]["posts"].first)
+      puts post.serialize
+      post
+    end
+
+    desc "delete POST_ID", "Delete a post"
+    def delete(id)
+      client = get_client
+      response = client.delete(:id => id).perform
+      tumblr_error(response) unless response.success?
+      ui_success "Post #{id} successfully deleted."
+    end
+
+    desc "authorize", "Authenticate and authorize the cli to post on your behalf"
+    option :port, :type => :string,
+                  :default => "4567",
+                  :desc => "Use PORT"
+    option :bind, :type => :string,
+                  :default => "0.0.0.0",
+                  :desc => "listen on BIND"
+    long_desc <<-LONGDESC
+      `tumblr authorize` will start up a server (listening on BIND and PORT) running
+      a small app to do the OAuth handshake with tumblr.
+
+      The app will open in the default browser, allowing you to authenticate to Tumblr
+      and authorize `tumblr` to do actions on your behalf. You will need to register
+      an application and enter the consumer key and consumer secret. The application will
+      write the OAuth keys to your CREDENTIALS file.
+
+      After authorization, you will be prompted to return to your terminal and shut down
+      the server (using CTRL-C).
+    LONGDESC
+    def authorize(*soak)
+      require 'tumblr/authentication'
+      sinatra_options = {
+        :port => options[:port],
+        :bind => options[:bind],
+        :credential_path => options[:credentials]
+      }
+      Tumblr::Authentication.run!(sinatra_options) do |server|
+        `open http://#{options[:bind]}:#{options[:port]}/`
+      end
+      if has_credentials?
+        ui_success "Success! Your Tumblr OAuth credentials were written to #{credentials.path}"
+      else
+        ui_abort "Something went wrong in authorization, and credentials were not correctly written to #{credentials.path}"
+      end
+    end
+
+    desc "version", "Print Tumblr version information"
+    def version
+      puts Tumblr::VERSION
+    end
+
+    private
+
+    def credentials
+      require 'tumblr/credentials'
+      Tumblr::Credentials.new(options[:credentials] || ENV["TUMBLRCRED"])
+    end
+
+    def editor
+      ENV["TUMBLREDITOR"] || ENV["EDITOR"]
+    end
+
+    def has_credentials?
+      !credentials.read.empty?
+    end
+
+    def check_credentials
+      ui_abort "Unable to find your OAuth keys. Run `tumblr authorize` to authenticate with Tumblr." unless has_credentials?
+    end
+
+    def get_host
+      host = ask("What is your Tumblr hostname?") if options[:host].nil? and $stdin.tty?
+      host ||= options[:host]
+      ui_abort "You need to provide a hostname i.e. --host=YOUR-NAME.tumblr.com" if host.nil? or host.empty?
+      host
+    end
+
+    def get_client
+      check_credentials
+      host = get_host
+      Tumblr::Client.load host, options[:credentials]
+    end
+
+    def tumblr_error(response)
+      parsed_response = response.parse
+      msg = parsed_response["response"].empty? ? response.parse["meta"]["msg"] : parsed_response["response"]["errors"]
+      ui_abort %Q(Tumblr returned a #{response.status} Error: #{msg})
+    end
+
+    def ui_abort(msg, exit_status = 1)
+      ui_puts msg, :red
+      exit exit_status
+    end
+
+    def ui_success(msg)
+      ui_puts msg, :green
+    end
+
+    def ui_puts(msg, color = nil)
+      say msg, $stdout.tty? ? color : nil
+    end
+
+  end
+end