# -*- coding: utf-8 -*-
#
# Quis leget haec?
"""
Stumblr
Stumblr is a Sublime Text 3 interface to tumblr
:copyright: (c) 2013 marcos.a.ojeda <marcos at generic dot cx>
:license: MIT, see LICENSE for details
"""
import json
import logging
import os
import os.path
import re
# this happens to let tumblor correctly load requests and requests_oauth
# without incident, but it's not 100% ideal :(
import sys
sys.path.append(os.path.dirname(__file__))
try:
import Stumblr.tumblor as tumblor
except ImportError:
import tumblor
from lib.thread_progress import ThreadProgress
import sublime
import sublime_plugin
import tempfile
import threading
try:
from urlparse import parse_qs, urlparse
except ImportError:
from urllib.parse import parse_qs, urlparse
import webbrowser
logging.basicConfig(level=logging.DEBUG,
format='%(levelname)s\t%(asctime)s [%(filename)s:%(lineno)d] %(message)s')
PREFSFILE = 'Stumblr.sublime-settings'
class TumblrUtility(object):
def __init__(self):
self.prefsfile = 'Stumblr.sublime-settings'
self.prefs = sublime.load_settings(self.prefsfile)
self.t = self.get_tumblr()
@property
def application_tokens(self):
return (self.prefs.get('consumer_key', '') and
self.prefs.get('secret_key', ''))
@property
def oauth_tokens(self):
"""returns the oauth token and oauth token secret"""
prefs = self.prefs
if (not prefs.get('oauth_token') or
not prefs.get('oauth_token_secret')):
return None
return {
'oauth_token': prefs.get('oauth_token'),
'oauth_token_secret': prefs.get('oauth_token_secret')
}
def get_tumblr(self):
"""returns an authenticated tumblor instance ready to call"""
creds = self.oauth_tokens
prefs = self.prefs
if not creds:
logging.debug('no creds!')
return None
logging.debug('returning Tumblor')
return tumblor.Tumblor(prefs.get('consumer_key'),
prefs.get('secret_key'), credentials=creds,
base_hostname=prefs.get('base_hostname'))
def get_new_tokens(self):
prefs = self.prefs
sublime.status_message('[STUMBLR] Starting OAuth Dance')
t = tumblor.Tumblor(prefs.get('consumer_key'), prefs.get('secret_key'),
credentials=None, base_hostname=prefs.get('base_hostname'))
tokens = t.serialize_credentials()
prefs.set('oauth_token', tokens['oauth_token'])
prefs.set('oauth_token_secret', tokens['oauth_token_secret'])
sublime.save_settings(PREFSFILE)
return tokens
class CheckCredentialsCommand(sublime_plugin.WindowCommand):
"""Checks to see if user has gathered oauth tokens yet"""
def run(self):
tum = TumblrUtility()
if not tum.application_tokens:
sublime.status_message('[STUMBLR] Set application keys in %s' % PREFSFILE)
return
if tum.oauth_tokens:
sublime.status_message('[STUMBLR] Already logged in')
return
sublime.status_message('[STUMBLR] Run tumblr login')
return
class TumblrListDraftsCommand(sublime_plugin.WindowCommand):
"""Lists your tumblr drafts in the quick panel"""
def run(self):
draft_thread = ListDraftsThreaded(self.window)
draft_thread.start()
ThreadProgress(draft_thread, 'Fetching Drafts', '')
class ListDraftsThreaded(threading.Thread, TumblrUtility):
"""Fetches tumblr drafts for display in quick panel"""
def __init__(self, window):
self.window = window
self.drafts = None
self.strip_tags_re = re.compile(r'<[^>]*>?')
threading.Thread.__init__(self)
TumblrUtility.__init__(self)
def run(self):
posts = self.get_draft_list()
logging.info("loaded %s posts" % len(posts))
def show_panel():
self.window.show_quick_panel(self.draft_list, self.on_done)
if len(posts):
sublime.set_timeout(show_panel, 10)
sublime.status_message('[STUMBLR]: No drafts. Get writing!')
def get_draft_list(self):
drafts = self.t.call_api('/posts/draft', params={'filter':'raw'})
if drafts['meta']['status'] == 200:
self.drafts = drafts['response']['posts']
if len(self.drafts):
self.draft_list = [self.snippet(p) for p in self.drafts]
return self.drafts
logging.info('no drafts found')
return []
logging.error('[STUMBLR]: Request for drafts failed.')
logging.error(drafts)
return []
def snippet(self, post):
"""summarizes various kinds of posts for display in quick menu
"""
if post['type'] == 'text':
return [post['title'][:60] or post['slug'][:60],
post['date'],
self.strip_tags(post['body'])[:80]
]
if post['type'] == 'quote':
source = self.strip_tags(post.get('source', ''))
if(post.get('source_url')):
source = urlparse(post.get('source_url','')).path
source_title = post.get('source_title', '')
return [source[-60:],
"%s: %s" % (post['date'], source_title),
self.strip_tags(post['text'])[:80]
]
if post['type'] == 'link':
source = urlparse(post['url']).netloc
return [post['title'][:60],
"%s: %s" % (post['date'], source),
self.strip_tags(post['description'])[:80]
]
if post['type'] == 'photo':
return [post['slug'][:60],
post['date'],
post['caption'][:80]
]
else:
return [post['slug'], post['date'], ""]
def strip_tags(self, markup):
if markup:
return self.strip_tags_re.sub('', markup)
return ""
def on_done(self, index):
if index == -1:
logging.info("canceled out of fetch draft quick list")
else:
logging.info("picked draft:\n\n %s " % self.drafts[index])
self.new_buffer_from_post(self.drafts[index])
return
def new_buffer_from_post(self, post):
mapping = {
'text': ['title', 'body'],
'photo': ['caption'],
'quote': ['source', 'text'],
'link': ['title', 'description'],
'chat': ['title', 'conversation']
}
fields = mapping[post['type']]
for field in fields:
self.new_view_with_text(post[field], {
'id': str(post['id']),
'field': field
})
def new_view_with_text(self, text, settings={}):
"""creates a new view and fills it with text"""
temp, tempname = tempfile.mkstemp(prefix='stumblr_%s_'%settings['field'])
logging.debug('have fd: %s, path: %s' % (temp, tempname))
temp = os.fdopen(temp, 'wb')
temp.write(text.encode('utf-8'))
temp.close()
new_view = self.window.open_file(tempname)
new_view.settings().set('stumblr_post', True)
for k in settings:
logging.debug('setting %s:%s for view' % (k, settings[k]))
new_view.settings().set('stumblr_%s' % k, settings[k])
self.set_syntax(new_view)
pass
def set_syntax(self, view):
"""looks for a markdown syntax and applies it to a view"""
possible_syntaxes = sublime.find_resources("Markdown.tmLanguage")
if possible_syntaxes:
md_syntax = possible_syntaxes[0]
logging.debug('setting syntax file to: %s', md_syntax)
view.set_syntax_file(md_syntax)
else:
logging.debug('could not finde a Markdown.tmLanguage')
return None
class StumblrEvents(sublime_plugin.EventListener):
"""deletes stumblr posts when closed"""
def on_close(self, view):
view_prefs = view.settings()
if view_prefs.get('stumblr_post'):
original_name = view.file_name()
if original_name and os.path.exists(original_name):
logging.info("unlinking: %s" % original_name)
os.remove(original_name)
pass
return
def on_pre_save(self, view):
"""posts the draft to tumblr when saving a dirty buffer"""
master_prefs = sublime.load_settings(PREFSFILE)
if not master_prefs.get('update_on_save'):
return
view_prefs = view.settings()
if view_prefs.get('stumblr_post') and view.is_dirty():
logging.debug('Stumblr: trying to post draft')
postup = UpdateDraftThreaded(view)
postup.start()
ThreadProgress(postup, 'Updating draft on tumblr',
'[STUMBLR] Draft Posted successfully!',
'[STUMBLR] Draft Post failed')
return
return
class TumblrUpdateDraftCommand(sublime_plugin.TextCommand):
"""Manually update a draft if update-on-save thing is not for you"""
def run(self, edit):
view_prefs = self.view.settings()
if view_prefs.get('stumblr_post'):
postup = UpdateDraftThreaded(self.view)
postup.start()
ThreadProgress(postup, 'Updating draft on tumblr',
'[STUMBLR] Draft Updated successfully!',
'[STUMBLR] Draft Update failed')
return
def is_enabled(self):
if self.view.settings().get('stumblr_post'):
return True
return False
class UpdateDraftThreaded(threading.Thread, TumblrUtility):
"""A threaded """
def __init__(self, view):
self.view = view
view_prefs = view.settings()
self.post_id = int(view_prefs.get('stumblr_id'))
self.post_field = view_prefs.get('stumblr_field')
threading.Thread.__init__(self)
TumblrUtility.__init__(self)
def run(self):
sublime.set_timeout(self.post_view, 10)
def post_view(self):
body = self.view.substr(sublime.Region(0, self.view.size()))
logging.info("saving post: %s@%s" % (self.post_id, self.post_field))
params = {
'id': self.post_id,
self.post_field: body
}
logging.info(params)
result = self.t.call_api('/post/edit', verb='post', params=params)
logging.info(result)
if result['meta']['status'] == 200:
sublime.status_message('[STUMBLR] draft updated successfully')
else:
logging.error("Update Post failed with result: %s" % result)
sublime.status_message('[STUMBLR] there was an error updating the draft')
return
class TumblrLoginCommand(sublime_plugin.WindowCommand):
"""
Logs a user into tumblr, with nonblocking magic
"""
def run(self):
TumblrThreadedLogin(self.window).start()
class TumblrThreadedLogin(threading.Thread, TumblrUtility):
def __init__(self, window):
self.window = window
threading.Thread.__init__(self)
TumblrUtility.__init__(self)
def run(self):
self.get_new_tokens()
def show_status():
if self.oauth_tokens:
sublime.status_message('[STUMBLR] Logged in successfully!')
else:
sublime.status_message('[STUMBLR] Login failed')
return
sublime.set_timeout(show_status, 10)
class TumblrPublishDraftCommand(sublime_plugin.TextCommand):
def run(self, edit):
TumblrThreadedPublishDraft(self.view).start()
def is_enabled(self):
if self.view.settings().get('stumblr_post'):
return True
return False
class TumblrThreadedPublishDraft(threading.Thread, TumblrUtility):
def __init__(self, view):
self.view = view
self.view_settings = view.settings()
self.post_id = int(self.view_settings.get('stumblr_id'))
threading.Thread.__init__(self)
TumblrUtility.__init__(self)
def run(self):
def publish_post():
info = self.t.call_api(method='/post/edit', params={
'id': self.post_id,
'state': 'published',
}, verb='post')
logging.debug(info)
# TODO(marcos): what if the post fails? maybe set the status message?
if info['meta']['status'] == 200:
published_id = info['response']['id']
more_info = self.t.call_api(method='/posts', params={
'api_key': self.prefs.get('consumer_key'),
'id': published_id
})
logging.debug(more_info)
# TODO(marcos): what if this also fails?
if more_info['meta']['status'] == 200:
post = more_info['response']['posts'][0]
# TODO(marcos): maybe check a pref for this
webbrowser.open(post['post_url'])
sublime.set_timeout(publish_post, 10)
class TumblrPostDraftCommand(sublime_plugin.TextCommand):
"""
Posts the current view to tumblr as a draft
"""
def run(self, edit):
TumblrThreadedPostDraft(self.view).start()
class TumblrThreadedPostDraft(threading.Thread, TumblrUtility):
"""
Posts a view to tumblr
"""
def __init__(self, view):
self.view = view
self.response = None
threading.Thread.__init__(self)
TumblrUtility.__init__(self)
def run(self):
def show_status():
self.post_draft()
logging.info(self.response)
if self.response['meta']['status'] == 201:
sublime.status_message('[STUMBLR] Draft Posted successfully!')
self.view.set_name(str(self.response['response']['id']))
prefs = self.view.settings()
prefs.set('stumblr_post', True)
prefs.set('stumblr_id', str(self.response['response']['id']))
prefs.set('stumblr_field', 'body')
else:
sublime.status_message('[STUMBLR] Draft Post failed')
# clearing this prevents the underlying file being killed when
# the view gets closed
prefs.erase('stumblr_post')
return
sublime.set_timeout(show_status, 10)
def post_draft(self):
if self.t:
body = self.view.substr(sublime.Region(0, self.view.size()))
payload = {
'state':'draft', 'type':'text', 'format':'markdown',
'body':body
}
self.response = self.t.call_api('/post', params=payload, verb='post')
class TumblrDeleteDraftCommand(sublime_plugin.TextCommand):
"""Deletes the current buffer's associated post on tumblr"""
def run(self, edit):
TumblrThreadedDeleteDraftCommand(self.view).start()
def is_enabled(self):
if self.view.settings().get('stumblr_post'):
return True
return False
class TumblrThreadedDeleteDraftCommand(threading.Thread, TumblrUtility):
"""
Deletes a view on tumblr, but provides a dialog before actually doing it
"""
def __init__(self, view):
self.view = view
self.response = None
self.view_settings = view.settings()
self.post_id = int(self.view_settings.get('stumblr_id'))
threading.Thread.__init__(self)
TumblrUtility.__init__(self)
def run(self):
def delete_draft():
post = self.t.call_api(method='/posts', params={
'api_key': self.prefs.get('consumer_key'),
'id': self.post_id
})
logging.debug(post)
# does the post exist?
if post['meta']['status'] == 200:
deleted_post = self.t.call_api(method='/post/delete', params={
'id': self.post_id
}, verb='post')
logging.debug(deleted_post)
if deleted_post['meta']['status'] == 200:
sublime.status_message('[STUMBLR] Post #%s Deleted' % self.post_id)
return
sublime.status_message('[STUMBLR] Failed on Deleting Post #%s' % self.post_id)
return
sublime.set_timeout(delete_draft, 10)