Convert a List to OPML for Fargo with Drafts

I’ve been using Dave Winer’s new outliner product Fargo frequently, yet I often initially enter my ideas into Drafts for iOS. Fargo works with OPML files, but if you copy a list into it (even one with tab indents), Fargo will maintain the structure, creating a new node (or “headline”) for each line and even making the tab-intended lines “children” of the main line above them.

The Problem: how to get my list in Drafts into Fargo with the least amount of effort?

It’s possible to just send the entire list to a text file in Dropbox, then access that file on the desktop, copy it, and paste it into Fargo. But there’s a better way. Inspired by Alex Guyot’s work on chopping a draft, I’ve composed a five (!) Drafts actions that let me convert a text list of any length into an OPML file that I can import into Fargo. The key to this solution is an URL Action that works as an infinite loop, in which the following occurs:

  • Take first line of draft ([[title]]) and use it to create the opening of the OPML file.
  • Take the rest of the list ([[body]]) and create a new draft with it.
  • Take the first line of the new draft and append it as an outline node to the OPML file I just created.
  • Take the rest of the list ([[body]]) and create a new draft with it.
  • Repeat those previous two steps ad infinitum until the loop is closed, i.e., we’re left with an empty draft.
  • Then close the OPML file with the final line from the list and the closing tags.

[Read more...]

How to Make Fargo.io Work With Carbonfin Outliner

Carbonfin Outliner is a basic outliner for iOS. The product has a web interface that will sync with your outlines on your iOS device, but you can also sync outlines with Dropbox (as OPML files). For any single outline you can only sync via one of these options (go to the Settings in an outline and choose the Storage option).

Frankly, I find Fargo to be the superior web app for editing outlines — it has keyboard shortcuts for nearly everything, whereas the Outliner web app is pretty rudimentary. Fortunately, Outliner has only a few attributes, which you can easily add right within Fargo.

Three Attributes

text

The text attribute is always required in the OPML file for Outliner.

_note

If you want to add a note to a task, add the _note=”" attribute

_status

No _status results in an empty checkbox. _status=”checked” results in a checkmark. _status=”" results in no box at all.

Create an Outline in Fargo for Carbonfin Outliner

All you have to do is create an outline in Fargo. Then go to the /Apps/smallPicture 1 folder in Dropbox and move your OPML file to the /Outliner folder in Dropbox. When you tap on the sync button in Outliner on your iOS device, Outliner will import the outline.

If you want to add a note to a task while in Fargo, click on Outliner and then Edit Attributes… in the dropdown menu. Tap on the +. In the left field, type in _note. In the right field, add your note. (You can also just overwrite the “Created” attribute because it isn’t really necessary.)

Click on image to view full size.


Click on image to view full size.

If you want no checkbox for a particular node, go to Edit Attributes, enter _status in the left field and leave the right field blank.

If you want a box checked, enter _status in the left field and checked in the right field.

Fargo will save an outline whose body looks something like this:

<outline text="task with note" _note="this is a note"/>
<outline text="task with box checked" _status="checked"/>
<outline text="item with no checkbox" _status=""/>

 
When synced with Outliner, this is what you’ll see for the above outline:

outliner

If you want to edit your Outliner outline again in Fargo, you’ll have to move it from /Outliner to /Apps/smallPicture.

Limitations

The only real downside to this solution is that you can’t see your notes or an item’s status without going into the Edit Attributes window in Fargo. But if you’re creating a basic outline with only text attributes, then Fargo will work just fine for your needs.


  1. I recently learned that the /smallPicture folder was only installed for early adopters — for anyone else, the folder is called /Fargo. 

The OPML Type Attribute and Font Awesome Icons Included in Fargo and Little Outliner

Small Picture Reader is a new product by Dave Winer’s Small Picture that displays any OPML file shared on Dropbox in outline form. After perusing the No Agenda #506 Shownotes Outline I noticed the use of more Font Awesome icons (please read my previous post to learn more about them). After inspecting the OPML file, I realized that there are many more type attributes than I was previously aware of.

The type attribute is discussed in the OPML spec but it appears that many more types than link, rss, and include are supported in Fargo and Little Outliner. These appear to have their origins in Dave Winer’s worldOutline. I do not pretend to know how all of these work, but I discovered that the use of the type attribute automatically “calls” the relevant icon from the Font Awesome set.

Type Attribute Icons

You can view the full outline in Small Picture Reader.

The nodes above only include text and type attributes. For example, the outline type looks like

<outline text="Outline" type="outline"/>

 
Unlike the icon attribute mentioned in my earlier post, here you only have to enter the one of these type attributes and the icon automatically shows up in the outline.

Update

Over at the small picture Google group, Eric Davis points out that “The ‘appTypeIcons’ object in http://outliner.smallpicture.com/utils.js appears to have all supported types and their icons.”

Here is a snippet from that file (copyright 2013, Small Picture):

var appTypeIcons = {
    "blogpost": "file-alt",
    "essay": "file-alt", 
    "code": "laptop",
    "directory": "folder-open-alt",
    "discusstree": "comments",
    "home": "home",
    "html": "file-alt",
    "icon-comment": "comment-alt", 
    "icon-star": "star-empty", 
    "icon-time": "time", 
    "icon-user": "user", 
    "include": "star-empty", 
    "index": "file-alt",
    "link": "bookmark-empty",
    "outline": "list-alt",
    "photo": "camera",
    "presentation": "file-alt",
    "redirect": "refresh",
    "river": "file-alt",
    "rss": "rss",
    "tabs": "file-alt",
    "thread": "comments",
    "thumblist": "th",
    "metaWeblogPost": "file-alt"
    }

 
I’ve updated my public outline to include some of these.

Add Flair to Fargo.io with 249 Icons

Dave Winer’s Fargo OPML outliner uses the Font Awesome icon set. If you’re bored of wedges, you can spruce up your outline with various icons.

icons

Just visit the Font Awesome page and scroll down to view the icons. If you have an outline node about beer, add the icon=beer attribute. (Click image below to enlarge.)

edit attributes

If you want the OPML file I used to create the above screenshot, copy this link and import it into Fargo.

iOS Bookmarklet to Convert Link into OPML File for Fargo.io

I’ve been using Dave Winer’s new outliner Fargo obsessively since its launch. It has lots of useful keyboard shortcuts, and imports/exports all outlines in OPML format. You may be familiar with OPML as a way to store a list of RSS feeds, but it’s also used by mind-mapping applications like iThoughts and MindNode, as well as outliners like Carbonfin Outliner.

Unfortunately, this application is very much desktop-focused. It barely works on the iPad. Fortunately, Fargo syncs with the /Apps/smallPicture folder in Dropbox, so if you can get an OPML file into this folder, you can import it once you’re back on the desktop.

I’ve been using Cotton Notes on my iPhone and iPad to work with outlines, because I can tap on any node and export that node and all its subnodes as an OPML file to the /Apps/Cotton Notes folder in Dropbox. This app also will import OPML files. When you import an OPML file that includes links formatted as follows

<outline text="Google" type="link" url="http://google.com" />

 
it converts it to Markdown:

[Google](http://google.com)

 
One the one hand, this is great, because it still keeps the link and you can toggle between previewing the Markdown or not. The downside is that when you export the outline, it stays in Markdown.

In Fargo, the first link format (which is according to the original spec) displays with this icon bookmark instead of a wedge, and when you use the expand shortcut, Fargo opens the link in a new tab. Fargo does not support markdown, so if I import an OPML file from Cotton Notes, the link will show as [Google](http://google.com).

Fargo does let you create an HTML link within the text, but if you export it, the HTML is URL-encoded. For example, an HTML link in Fargo (which looks like Google) will export as follows:

&lt;a href=&quot;http://google.com&quot;&gt;Google&lt;/a&gt;

 
This is unreadable if I import it into Cotton Notes.

I suppose the proper way to create a link in Fargo is to choose Edit Attributes… in the Outliner menu, and manually add them:

type link
url http://google.com

 
This creates a link according to the OPML spec and will properly import into apps like Cotton Notes and iThoughts (although these apps then change the link formatting).

The OPML Bookmarklet

All this to introduce a bookmarklet I’ve written for iOS. It will take the title and link of a page and create an OPML file in the /Apps/smallPicture folder, which you can then import into Fargo. (To import, just go to File > Open and then click on a file called “Link” with a filename that is a timestamp. This will create a new outline in Fargo.)

This bookmarklet requires Drafts. From your iOS device, you will need to tap on this link to import a Dropbox action into Drafts called opml.

Then, bookmark any page in mobile Safari and title it opml. Tap on bookmarks and edit, and remove the URL of the bookmark. Paste in the following and then save:

 
You’re all set. Next time you want to import a bookmark into Fargo, just tap on the opml bookmarklet. It will send a formatted link to Drafts, which will then insert the draft into an OPML file, which is then saved to Dropbox.

If you want to get the link into an outline in which you are already working, create a public link for the new outline, copy the URL, go to your working outline, click on Import… and enter the public URL to import the link into that outline.

Warning

If a title or URL that you’re bookmarking contains any special characters that would ordinarily have to be encoded, this bookmarklet will not work. It will create an OPML file but if you try to import it into Fargo, it will show up null. (For example, & needs to be &amp;.) I don’t know any way around this. You’ll have to actually go into the OPML file to fix the URL or just bookmark URLs that don’t have parameters.