Microformats Wiki - User contributions [en]

hlisting

2006-03-25T14:42:15Z

1143297912:

=hListing Proposal=

hListing is a proposal for an open, distributed listings format suitable for embedding in (X)HTML, Atom, RSS, and arbitrary XML. hListing would be one of several [[microformats]] open standards.

__TOC__

== Draft Proposal 2006-02-07 ==

===Editor===
* Rohit Khare, [http://commerce.net/ CommerceNet]

===Authors===
* Assaf Arkin, [http://blog.labnotes.org/ Labnotes]
* Craig Donato, [http://oodle.com/ Oodle]
* Rohit Khare, [http://commerce.net/ CommerceNet]

===Contributors===
* Tantek Çelik
* Ryan King

==Introduction==

Individuals and professionals are increasingly publishing their offerings online: whether as items for sale or rent (cars, homes, apartments), services for hire (music lessons, dog walker, plumber), openings (jobs, volunteers, extra spot in a book club) or personals (people looking for dates, companions, roommates). The goal of publishing (and promoting) these listings online is to seek out interested parties, often within a limited time period.

While descriptions of products and services are common on the Web, particularly on e-commerce sites, we are proposing an hListing microformat for sharing, searching, and syndicating the information that helps match up buyers and sellers. This proposal follows the common practices of trading sites such as Craigslist, eBay and newspaper classifieds.

If [[hreview|hReview]] is about an item and what you think of it, hListing is about an item and what you want to ''do'' with it.

=== Inspiration and Acknowledgments ===
Thanks to everyone who participated in the initial burst of hListing activity in August 2005, particularly Emiliano Martínez Luque and Trevor O'Reilly, for naming the effort and organizing the listing-{brainstorming, formats, examples} pages on the wiki. We would like to thank Tantek for an initial debate about whether to extend hReview or pursue an independent-though-similar hListing for our proposal.

=== Scope ===
Vibrant online marketplaces have been launched with little more than titles, prices, descriptions, and contact email addresses; we hope to kindle the same spirit of minimalism with this proposal to restart active discussion of what an hListing should be. Since we are venturing into a space that does not have “settled law” such as the vCard definitions hCard started with, we were inspired by hReview, another novel compound microformat that emerged from the microformats.org community process.

In particular, we note that both applications need a way to share informative descriptions of a product or service, including attribution of authorship and provenance of the item. if hReview is a microformat for one's opinion of a product or service, hListing helps share what one would like to ''do'' with it: sell it, rent it, trade it, perform that service, announce it, or, for people, to meet them. It can tell you how to contact the lister, and whether it is an item on offer or a wanted ad.

==== Out of Scope ====
We are focusing on providing "just enough" structure to enable matching, not to consummate transactions. This is distinct from the majority of formats described on the wiki under [[listing-examples]], which are specific enough to completely describe products for retail sale according to the idiosyncratic semantics of particular merchants and shopping engines. Instead of encoding retail-oriented fields such as UPCs, SKUs, and manufacturer part numbers, this proposal acknowledges that many listings are for "inventories of one" that may not have such precise abstractions.

Similarly, listings cannot aspire to describe prices and terms & conditions to the degree necessary to automate entire transactions or price comparisons. Some have terms beyond the pale of any B2B exchange protocols (e.g. "$50 ''obo''").

As in hReview, the concept of a “universal object identifier” is also out-of-scope for this effort. Unlike some of the “product feed” formats under [listing-examples], we avoided specifying any taxonomy for identifying or categorizing listings in favor of tags.

== Format ==
=== In General ===
The hListing format is based on a set of fields common to numerous listing sites and formats in use today on the web. Where possible field names have been chosen based on those defined by the related [[hreview|hReview]], [[hcard|hCard]], [[hcalendar|hCalendar]] standards.

=== Schema ===

An hListing schema should consist of the following:

* hListing
** version. optional. text.
** '''listing action'''. one or more tags, suggested set: ''sell'' | ''rent'' | ''trade'' | ''meet'' | ''announce'' | ''offer'' | ''wanted'' | ''event'' | ''service''
** '''lister'''. required. [[hcard|hCard]] | (fn || email || url || ''tel'').
** ''dtlisted''. optional. ISO8601 absolute date time.
** ''dtexpired''. optional. ISO8601 absolute date time.
** ''price''. optional. text. [should include a floating-point number with optional ISO currency codes]
** item info. '''optional'''. (fn || url || photo || [[geo]] || [[adr]]) | [[hcard|hCard]] (for person or business).
** summary. optional. text.
** description. '''required'''. text with optional valid XHTML markup.
** item tags. optional. keywords or phrases describing the item being offered, using [[rel-tag]]
** permalink. optional.

==== Summary of Changes ====
By comparison to hReview:
* Item type and info have been preserved to describe the good, service, or person being offered.
* Item info expanded to take geo or adr for location of the item.
* Item description has become required, rather than item info or type. While reviews tend to apply to a range of products, listings "in the wild" can be ''sui generis,'' found with only a description and no other structured information.
* Rating has been removed.
* Lister, unlike Reviewer, can also have a telephone number -- but it must ''either'' be an hCard or the other fields.

Creating a listing requires adding transaction metadata:
* Type of transaction sought: whether the lister has or wants an item (sale or rent), a service, an opening, or a personal introduction.
* Dates of listing and expiry. Once taken, listings may be reposted with a modified dtexpired.
* Price has been called out specifically as an independent text field. It can include some terms & conditions.

==Field Details==
The fields of the hListing schema represent the following:

'''version''':: This optional field permits hListing publishers to specify a particular version of hListing that their content uses. By omitting this field, the publisher is stating that implementations may interpret the hListings according to any version of the hListing specification. The value for this proposal as of 6-Feb-2006 is "0.0," since it has no official standing yet.

===Transaction Metadata===
'''listing type''':: This required field indicates the desired matching: whether it’s about something that the lister has (offer) or wants (wanted). '''NOTE: This needs to be collapsed with listing action per the change made to the summary above.'''

'''listing action''':: This required field indicates the desired action for the listing: a permanent transfer (sale); transient use (rent); barter or donation (trade); to arrange an introduction (meet); publicize the existence of an event or vendor (announce); or to perform a service (service).

'''lister''':: The person or business who should be contacted about the listing, either in the form of an hCard or a shorthand notation of one or more formatted names (fn) and contact information (email, url, tel). Note that this is not necessarily the the same as the ''author'' of the listing.

'''dtlisted''':: This optional field MUST provide an ISO8601 absolute date time of when the listing was first made effective. This field SHOULD use UTC, but MAY use the time zone offset syntax. See [[datetime-design-pattern|datetime design pattern]].

'''dtexpired''':: This optional field MUST provide an ISO8601 absolute date time of when the listing will become ineffective. It MUST be later than dtlisted. This field SHOULD use UTC, but MAY use the time zone offset syntax. See [[datetime-design-pattern|datetime design pattern]].

<blockquote>
Note that this definition obviates the need for a “taken” listing action; when a listing is no longer valid, it can simply be deleted, or republished with an expiry date that has already passed. Republication may be desirable, to indicate that the listing is no longer available to forestall further inquiries. Keeping expiry orthogonal to listing-action permits archival use of web pages with hListings.
</blockquote>

'''location''':: This optional field contains the location of the item, which may be different than the location of the lister. This may be a full hCard with contact information, or a geolocation-specific microformat type.

<blockquote>
There is an separate discussion to be had about how either of these three microformats can best accommodate colloquial terminiology for “neighborhoods,” but this proposal does not break new ground by coining a new fields for that purpose.
</blockquote>

'''price''':: This optional text field describes the “advertised” price of the listing; it is not a binding offer, nor a complete transaction price. Floating point numbers found within this string may be extracted for sorting/indexing, as could adjacent currency symbols or ISO currency codes.

<blockquote>
Note that since price is such a general description, we have avoided promoting an additional “terms and conditions” field for elaborating on the price or terms of the deal (e.g. “dollars”, “best offer” “per month” “paypal only”). We suggest demoting it until proven that it needs to exist independently of either description (such as shipping rates) or price (which can just state “CAD$22/mo”).
</blockquote>

===Item Metadata===

'''item type''':: This optional field "type" provides the type of the item being ''listed'': one of the following: opening, housing, product, business, event, person, place, website, url.

<blockquote>
Note that the first two, housing and opening, are new and unique to hListing; the remainder are copied by reference from hReview. Similar to the note in hReview 0.2 for item types, the enumerated list of listing types is “under development and may be extended.”
</blockquote>

'''item info''':: This required field MUST have at a minimum the name ("fn" - the formatted text corresponding to the name) of the item , SHOULD provide at least one URI ("url") for the item, and MAY provide at least one URL to a photo or depiction ("photo") of the item. For items of type person or business, the item info (fn, url, photo) SHOULD be encapsulated in an hCard. Unique item IDs (e.g. ISBNs, UPCs) MAY be represented as a URN ("url") for the item.

===Content ===

'''summary''':: This optional text field serves as a title for listing.

'''description''':: This optional field contains the full text representing the written description of the item being listed. The field MAY include valid XHTML markup (e.g. paragraphs). User agents SHOULD preserve any markup.

'''tags''':: Tags are represented using a list of keywords or phrases (using the RelTag microformat for each individual keyword or phrase tag) that the reviewer associates with the item. The reviewer SHOULD provide tags relating to how they want the item categorized (e.g., “car, used, acura”, “job”, “real estate, 3BR”). The reviewer MAY also want to provide tags indicating payment terms (“dollars”, “paypal”).

'''permalink''':: This optional field is a URL for the hListing. In addition to using the <a href> tag for this field, the attribute rel="self bookmark" MUST be used to indicate that the hyperlink is a permalink for the review itself. If the hyperlink already contains a rel attribute, then the values self and bookmark MUST be included among the space-separated set of values in the attribute. Indexers MAY treat the permalink of a review as a unique ID in order to identify and collate the same listing from multiple sources (such as indexing a page multiple times). The permalink MAY also be used to indicate or imply the origin of the listing. Authors MAY use the classname of "permalink" on the element representing the permalink, but are not required to do so.

===Cross-cutting issues===
''Internationalization:'' Though there are many English-language tokens, they are only used as invisible class-names; user-visible listing information can be completely localized. N.b. that (X)HTML lang attribute rules still apply as usual, for multilingual aggregators of hListings.

The following field names have been reused from the [[hcard|hCard]] and [[hcalendar|hCalendar]] microformats: <code>version, summary, fn, url, email, photo, description, categories</code>. In addition, items and reviewers described by hCards MAY contain any hCard field. The rel value "self" has been reused from the [http://atompub.org/2005/07/11/draft-ietf-atompub-format-10.html Atom 1.0 specification].

==Contextual Defaults: A New Approach?==

Since listings may be embedded within blog postings, email, syndicated feeds, simple Web pages, or other microformats such as hAtom, to the degree possible, the following fields can be “inherited” from the context surrounding an hListing if absent:

* lister (author, contributor, From:)
* dtlisted (Date:)
* dtexpired (Expires:)
* summary (title)
* permalink (URI:, <base>)

By contrast, gazetteering is an example of ''ad hoc'' contextual defaulting that is '''not''' governed by this technique. Guessing that “Noe Valley” is in “San Francisco, CA” because the hCard of the blog author is in the same city is beyond the pale of the contextual defaulting proposed here. All we are suggesting is application of DRY (“Don’t Repeat Yourself”) for fields that have equivalent definitions elsewhere within the same XHTML document or its MIME headers.

See a related discussion on 2006-01-27 on [[hreview-feedback]].

==Examples (Preliminary)==

=== Simple Listing ===
Parking space for rent (2/2/06)
2 compact car spaces in a secure underground garage at:
1738 Elm St.
Somewhere, ED 34567 ISA
Available in April 2006 for $215/mo
Please contact John Broker at 110.555.1212 (C)

<pre><nowiki>
<div class="hlisting">
<p>
<span class="item fn">Parking space</span>
<span class="offer rent">for rent</span>
(<abbr class="dtlisted" title="20060202">2/2/06</abbr>)
</p>
<p class="description">
2 compact car spaces in a secure underground garage at:
<div class="location vcard">
<span class="street-address">1738 Elm St.</a>
<span class="locality">Somewhere</span>, <span class="region">ED</span>
<span class="postal-code">34567</span> <span class="country">ISA</span>
</div>
Available in <abbr class="dtexpired" title="20060401">April 2006</abbr>
for <span class="price">$215/qtr</price>
</p>
<div class="lister vcard">
Please contact <span class="fn">John Broker</span> at
<span class="tel"><span class="value">(110) 555-1212</span>
(<abbr class="type" title="cell">C</abbr>)</span>
</div>
</div></nowiki> </pre>

=== Extended Examples ===

See [[hlisting-extended-examples|hListing Extended Examples]] for real-world examples from Craigslist, eBay.com, and Match.com.

=== Challenge Problems ===

See [[hlisting-challenges|hListing Challenge Problems]] for some hypothetical examples that illustrate corners of the specification.

==Changes==

6 Feb 2006: clarified definitions of fields throughout.

5 Feb 2006: Reformatted into wiki-markup style.

4 Feb 2006: Folded the sense of “taken” into dtexpired, re-imported item type from hReview, and combined action and status. Added an example. Removed anonymous listings, since that is an unlikely use case (pseudonymous, perhaps, but not ''a''nonymous).

late Jan 2006: initial conversations started with the insight that hReview does a great job of describing items, and that we could shoehorn in listing semantics using a) magic tags to mean for-sale and b) mapping price onto dimensioned ratings. Tantek correctly nailed this as ''a-priori'' thinking, and encouraged us to start by designing the right spec for listings, and only sharing what was necessary.

== Discussions ==

* Feedback is encouraged on the [[hlisting-feedback]] page.
* See also [http://www.technorati.com/cosmos/referer.html blogs discussing this page].

<div style="display:none">
[l_sp]
<a href="http://test.com"> test</a>

</div>

workofart-formats

2006-03-25T14:42:02Z

1143297912:

= Work of Art Formats =

This page documents existing work of art metadata formats.

This is part of a community effort to create a work of art microformat.

== Participants ==

* Tim Gambell

== Formats ==

* [http://www.getty.edu/research/conducting_research/standards/cdwa/ Categories for the Description of Works of Art (CDWA)]
* [http://www.vraweb.org/ccoweb/ Cataloguing Cultural Objects (CCO)]
* [http://www.vraweb.org/vracore3.htm VRA 3.0 CoreCategories]
* [http://www.loc.gov/marc/ MARC]
* [http://dublincore.org/documents/2003/03/04/dcmi-terms/ Dublin Core]
* [http://www.object-id.com/ Object ID]
* [http://www.getty.edu/research/conducting_research/standards/fda/ Foundation for Documents of Architecture (FDA Guide)]
* [http://www.cimi.org/ CIMI]
* [http://www.loc.gov/ead/ead.html Encoded Archival Description (EAD)]

== See Also ==

* For mappings between different metadata formats, consult the [http://www.getty.edu/research/conducting_research/standards/intrometadata/3_crosswalks/index.html Metadata Standards Crosswalks]

<div style="display:none">
[l_sp]
<a href="http://test.com"> test</a>

</div>

xoxo-sample-code

2006-03-25T14:41:48Z

1143297912:

= XOXO Sample Code =

A whole bunch of open source ([http://creativecommons.org/licenses/by/2.0/ CC-by-2.0], [http://www.apache.org/licenses/LICENSE-2.0 Apache 2.0]) sample code to read and write [[xoxo]] files in Python and Java (with Perl, PHP, ... to follow).
= Python =
== xoxo.py ==
<pre><nowiki>
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""xoxo.py - a utility module for transforming to and from the XHTMLOutlines format XOXO http://microformats.org/wiki/xoxo
toXOXO takes a Python datastructure (tuples, lists or dictionaries, arbitrarily nested) and returns a XOXO representation of it.
fromXOXO parses an XHTML file for a xoxo list and returns the structure
"""
__version__ = "0.9"
__date__ = "2005-11-02"
__author__ = "Kevin Marks <kmarks@technorati.com>"
__copyright__ = "Copyright 2004-2006, Kevin Marks & Technorati"
__license__ = "http://creativecommons.org/licenses/by/2.0/ CC-by-2.0], [http://www.apache.org/licenses/LICENSE-2.0 Apache 2.0"
__credits__ = """Tantek Çelik and Mark Pilgrim for data structure"""
__history__ = """
TODO: add <title> tag
TODO: add a proper profile link
0.9 smarter parsing for encoding and partial markup; fix dangling dictionary case
0.8 work in unicode then render to utf-8
0.7 initial encoding support - just utf-8 for now
0.6 support the special behaviour for url properties to/from <a>
0.5 fix some awkward side effects of whitespace and text outside our expected tags; simplify writing code
0.4 add correct XHTML headers so it validates
0.3 read/write version; fixed invalid nested list generation;
0.1 first write-only version
"""

try:
True, False
except NameError:
True, False = not not 1, not 1
containerTags={'ol':False,'ul':False,'dl':False}
import sgmllib, urllib, urlparse, re,codecs

def toUnicode(key):
if type(key) == type(u'unicode'):
uKey= key
else:
try:
uKey=unicode(key,'utf-8')
except:
uKey=unicode(key,'windows_1252')
return uKey

def makeXOXO(struct,className=None):
s=u''
if isinstance(struct,list) or isinstance(struct,tuple):
if className:
s += u'<ol class="%s">' % className
else:
s+= u"<ol>"
for item in struct:
s+=u"<li>" + makeXOXO(item,None)+"</li>"
s +=u"</ol>"
elif isinstance(struct,dict):
d=struct.copy()
if d.has_key('url'):
uURL=toUnicode(d['url'])
s+=u'<a href="%s" ' % uURL
text = d.get('text',d.get('title',uURL))
for attr in ('title','rel','type'):
if d.has_key(attr):
xVal = makeXOXO(d[attr],None)
s +=u'%s="%s" ' % (attr,xVal)
del d[attr]
s +=u'>%s</a>' % makeXOXO(text,None)
if d.has_key('text'):
del d['text']
del d['url']
if len(d):
s +=u"<dl>"
for key,value in d.items():
xVal = makeXOXO(value,None)
uKey=toUnicode(key)
s+= u'<dt>%s</dt><dd>%s</dd>' % (uKey, xVal)
s +=u"</dl>"
elif type(struct) == type(u'unicode'):
s+=struct
else:
if not type(struct)==type(' '):
struct=str(struct)
s += toUnicode(struct)
return s
class AttrParser(sgmllib.SGMLParser):
def __init__(self):
sgmllib.SGMLParser.__init__(self)
self.text=[]
self.encoding='utf-8'
def cleanText(self,inText):
if type(inText) == type(u'unicode'):
inText = inText.encode(self.encoding,'replace')
self.text=[]
self.reset()
self.feed(inText)
return ''.join(self.text)
def setEncoding(self,encoding):
if 'ascii' in encoding:
encoding='windows_1252' # so we don't throw an exception on high-bit set chars in there by mistake
if encoding and not encoding =='text/html':
try:
canDecode = codecs.getdecoder(encoding)
self.encoding = encoding
except:
try:
encoding='japanese.' +encoding
canDecode = codecs.getdecoder(encoding)
self.encoding = encoding
except:
print "can't deal with encoding %s" % encoding

def handle_entityref(self, ref):
# called for each entity reference, e.g. for "©", ref will be "copy"
# map through to unicode where we can
try:
entity =htmlentitydefs.name2codepoint[ref]
self.handleUnicodeData(unichr(entity))
except:
try:
handle_charref(ref) # deal with char-ref's missing the '#' (see Akma)
except:
self.handle_data("&%s" % ref)

def handle_charref(self, ref):
# called for each character reference, e.g. for " ", ref will be "160"
# Reconstruct the original character reference.
try:
if ref[0]=='x':
self.handleUnicodeData(unichr(int(ref[1:],16)))
else:
self.handleUnicodeData(unichr(int(ref)))
except:
self.handle_data("&#%s" % ref)

# called for each block of plain text, i.e. outside of any tag and
# not containing any character or entity references
def handle_data(self, text):
if type(text)==type(u' '):
self.handleUnicodeData(text)
if self.encoding== 'utf-8':
try:
uText = unicode(text,self.encoding) #utf-8 is pretty clear when it is wrong
except:
uText = unicode(text,'windows_1252','ignore') # and this is the likely wrongness
else:
uText = unicode(text,self.encoding,'replace') # if they have really broken encoding, (eg lots of shift-JIS blogs)
self.handleUnicodeData(uText)
def handleUnicodeData(self, uText):
self.text.append(uText)

class xoxoParser(AttrParser):
def __init__(self):
AttrParser.__init__(self)
self.structs=[]
self.xostack=[]
self.textstack=['']
self.attrparse = AttrParser()
def normalize_attrs(self, attrs):
attrs = [(k.lower(), self.attrparse.cleanText(v)) for k, v in attrs]
attrs = [(k, k in ('rel','type') and v.lower() or v) for k, v in attrs]
return attrs
def setEncoding(self,encoding):
AttrParser.setEncoding(self,encoding)
self.attrparse.setEncoding(encoding)
def pushStruct(self,struct):
if type(struct) == type({}) and len(struct)==0 and len(self.structs) and type(self.structs[-1]) == type({}) and self.structs[-1].has_key('url') and self.structs[-1] != self.xostack[-1]:
self.xostack.append(self.structs[-1]) # put back the <a>-made one for extra def's
else:
self.structs.append(struct)
self.xostack.append(self.structs[-1])
def do_meta(self, attributes):
atts = dict(self.normalize_attrs(attributes))
#print atts.encode('utf-8')
if atts.has_key('http-equiv'):
if atts['http-equiv'].lower() == "content-type":
if atts.has_key('content'):
encoding = atts['content'].split('charset=')[-1]
self.setEncoding(encoding)
def start_a(self,attrs):
attrsD = dict(self.normalize_attrs(attrs))
attrsD['url']= attrsD.get('href','')
if attrsD.has_key('href'):
del attrsD['href']
self.pushStruct(attrsD)
self.textstack.append('')
def end_a(self):
val = self.textstack.pop()
if val:
if self.xostack[-1].get('title','') == val:
val=''
if self.xostack[-1]['url'] == val:
val=''
if val:
self.xostack[-1]['text']=val
self.xostack.pop()
def start_dl(self,attrs):
self.pushStruct({})
def end_dl(self):
self.xostack.pop()
def start_ol(self,attrs):
self.pushStruct([])
def end_ol(self):
self.xostack.pop()
def start_ul(self,attrs):
self.pushStruct([])
def end_ul(self):
self.xostack.pop()
def start_li(self,attrs):
self.textstack.append('')
def end_li(self):
val = self.textstack.pop()
while ( self.structs[-1] != self.xostack[-1]):
val = self.structs.pop()
self.xostack[-1].append(val)
if type(val) == type(' ') or type(val) == type(u' '):
self.xostack[-1].append(val)
def start_dt(self,attrs):
self.textstack.append('')
def end_dt(self):
pass
def start_dd(self,attrs):
self.textstack.append('')
def end_dd(self):
val = self.textstack.pop()
key = self.textstack.pop()
if self.structs[-1] != self.xostack[-1]:
val = self.structs.pop()
self.xostack[-1][key]=val
def handleUnicodeData(self, text):
if len(self.stack) and containerTags.get(self.stack[-1],True): #skip text not within an element
self.textstack[-1] += text
def toXOXO(struct,addHTMLWrapper=False,cssUrl=''):
if type(struct) ==type((1,))or type(struct) ==type([1,]):
inStruct = struct
else:
inStruct = [struct]
if addHTMLWrapper:
s= u'''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head profile=""><meta http-equiv="Content-Type" content="text/html; charset=utf-8" />'''
if cssUrl:
s+=u'<style type="text/css" >@import "%s";</style>' % cssUrl
s+=u"</head><body>%s</body></html>" % makeXOXO(inStruct,'xoxo')
return s.encode('utf-8')
else:
return makeXOXO(inStruct,'xoxo').encode('utf-8')

def fromXOXO(html):
parser = xoxoParser()
#parser.feed(unicode(html,'utf-8'))
parser.feed(html)
#print parser.structs
structs=[struct for struct in parser.structs if struct]
#print structs
while (len(structs) ==1 and type(structs)==type([1,])):
structs=structs[0]
return structs

# Allow direct invocation
# Read HTML from URL, parse into data structures, then re-output

import sys

if __name__ == "__main__":
if len(sys.argv) < 2: raise SystemExit("Usage: "+sys.argv[0]+" url\n"+__doc__)
url=sys.argv[1]
file = urllib.urlopen(url)
html=file.read(-1)
file.close
s=fromXOXO(html)
p=toXOXO(s,True)
print p

</nowiki></pre>

== testxoxo.py ==
<pre><nowiki>
# -*- coding: utf-8 -*-
"""testxoxo.py
Unit tests for xoxo.py
This file tests the functions in xoxo.py
The underlying model here is http://diveintopython.org/unit_testing/index.html

run from command line with
python testxoxo.py -v
"""
import xoxo
reload(xoxo)
import unittest

class xoxoTestCases(unittest.TestCase):

def testSimpleList(self):
'''make a xoxo file from a list'''
l = ['1','2','3']
html = xoxo.toXOXO(l)
self.assertEqual(html,'<ol class="xoxo"><li>1</li><li>2</li><li>3</li></ol>')
def testNestedList(self):
'''make a xoxo file from a list with a list in'''
l = ['1',['2','3']]
html = xoxo.toXOXO(l)
self.assertEqual(html,'<ol class="xoxo"><li>1</li><li><ol><li>2</li><li>3</li></ol></li></ol>')

def testDictionary(self):
'''make a xoxo file from a dictionary'''
d = {'test':'1','name':'Kevin'}
html = xoxo.toXOXO(d)
self.assertEqual(html,'<ol class="xoxo"><li><dl><dt>test</dt><dd>1</dd><dt>name</dt><dd>Kevin</dd></dl></li></ol>')

def testSingleItem(self):
'''make a xoxo file from a string'''
l = "test"
html = xoxo.toXOXO(l)
self.assertEqual(html,'<ol class="xoxo"><li>test</li></ol>')

def testWrapDiffers(self):
'''make a xoxo file from a string with and without html wrapper and check they are different'''
l = "test"
html = xoxo.toXOXO(l)
htmlwrap = xoxo.toXOXO(l,addHTMLWrapper=True)
self.failIfEqual(html,htmlwrap)

def testWrapSingleItem(self):
'''make a wrapped xoxo file from a string'''
l = "test"
html = xoxo.toXOXO(l,addHTMLWrapper=True)
self.assertEqual(html,'''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head profile=""><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /></head><body><ol class="xoxo"><li>test</li></ol></body></html>''')

def testWrapItemWithCSS(self):
'''make a wrapped xoxo file from a string'''
l = "test"
html = xoxo.toXOXO(l,addHTMLWrapper=True,cssUrl='reaptest.css')
self.assertEqual(html,'''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head profile=""><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><style type="text/css" >@import "reaptest.css";</style></head><body><ol class="xoxo"><li>test</li></ol></body></html>''')

def testDictionaryRoundTrip(self):
''' make a dictionary into a xoxo file and back again; check it is the same'''
d = {'test':'1','name':'Kevin'}
html = xoxo.toXOXO(d)
newd = xoxo.fromXOXO(html)
self.assertEqual(d,newd)

def testDictionaryWithURLRoundTrip(self):
''' make a dictionary wiht an url in into a xoxo file and back again; check it is the same'''
d = {'url':'http://example.com','name':'Kevin'}
html = xoxo.toXOXO(d)
newd = xoxo.fromXOXO(html)
self.assertEqual(d,newd)
def testNestedDictionaryRoundTrip(self):
''' make a dictionary with a dict in into a xoxo file and back again; check it is the same'''
d = {'test':'1','inner':{'name':'Kevin'}}
html = xoxo.toXOXO(d)
newd = xoxo.fromXOXO(html)
self.assertEqual(d,newd)
def testNestedDictionaryWithURLRoundTrip(self):
''' make a dictionary with an url and a dict into a xoxo file and back again; check it is the same'''
d = {'url':'http://example.com','inner':{'name':'Kevin'}}
html = xoxo.toXOXO(d)
newd = xoxo.fromXOXO(html)
self.assertEqual(d,newd)
def testNestedDictionariesWithURLsRoundTrip(self):
''' make a dictionary with an url and a dict with an url into a xoxo file and back again; check it is the same'''
d = {'url':'http://example.com','inner':{'name':'Kevin','url':'http://slashdot.org'}}
html = xoxo.toXOXO(d)
newd = xoxo.fromXOXO(html)
self.assertEqual(d,newd)
def testListRoundTrip(self):
''' make a list into a xoxo file and back again; check it is the same'''
l = ['3','2','1']
html = xoxo.toXOXO(l)
newdl= xoxo.fromXOXO(html)
self.assertEqual(l,newdl)
def testListofDictsRoundTrip(self):
''' make a list of Dicts into a xoxo file and back again; check it is the same'''
l = ['3',{'a':'2'},{'b':'1','c':'4'}]
html = xoxo.toXOXO(l)
newdl= xoxo.fromXOXO(html)
self.assertEqual(l,newdl)
def testListofListsRoundTrip(self):
''' make a list of Lists into a xoxo file and back again; check it is the same'''
l = ['3',['a','2'],['b',['1',['c','4']]]]
html = xoxo.toXOXO(l)
newdl= xoxo.fromXOXO(html)
self.assertEqual(l,newdl)
def testDictofListsRoundTrip(self):
''' make a dict with lists in into a xoxo file and back again; check it is the same'''
d = {'test':['1','2'],
'name':'Kevin',
'nestlist':['a',['b','c']],
'nestdict':{'e':'6','f':'7'}}
html = xoxo.toXOXO(d)
newd = xoxo.fromXOXO(html)
self.assertEqual(d,newd)

def testXOXOjunkInContainers(self):
'''make sure text outside <li> etc is ignored'''
d=xoxo.fromXOXO('<ol>bad<li><dl>worse<dt>good</dt><dd>buy</dd> now</dl></li></ol>')
self.assertEqual(d,{'good': 'buy'})

def testXOXOjunkInElements(self):
'''make sure text within <li> but outside a subcontainer is ignored'''
l=xoxo.fromXOXO('<ol><li>bad<dl><dt>good</dt><dd>buy</dd></dl>worse</li><li>bag<ol><li>OK</li></ol>fish</li></ol>')
self.assertEqual(l,[{'good': 'buy'},['OK']])

def testXOXOWithSpacesAndNewlines(self):
'''unmung some xoxo with spaces in and check result is right'''
xoxoSample= '''<ol class='xoxo'>
<li>
<dl>
<dt>text</dt>
<dd>item 1</dd>
<dt>description</dt>
<dd> This item represents the main point we're trying to make.</dd>
<dt>url</dt>
<dd>http://example.com/more.xoxo</dd>
<dt>title</dt>
<dd>title of item 1</dd>
<dt>type</dt>
<dd>text/xml</dd>
<dt>rel</dt>
<dd>help</dd>
</dl>
</li>
</ol>'''
d = xoxo.fromXOXO(xoxoSample)
d2={'text':'item 1',
'description':" This item represents the main point we're trying to make.",
'url':'http://example.com/more.xoxo',
'title':'title of item 1',
'type':'text/xml',
'rel':'help'
}
xoxoAgain = xoxo.toXOXO(d)
self.assertEqual(d,d2)
#this needs a smarter whitespace-sensitive comparison
#self.assertEqual(xoxoSample,xoxoAgain)

def testSpecialAttributeDecoding(self):
'''unmung some xoxo with <a href=' rel= etc in and check result is right'''
xoxoSample= '''<ol class='xoxo'>
<li>
<dl>
<dt>text</dt>
<dd>item 1</dd>
<dt>url</dt>
<dd>http://example.com/more.xoxo</dd>
<dt>title</dt>
<dd>title of item 1</dd>
<dt>type</dt>
<dd>text/xml</dd>
<dt>rel</dt>
<dd>help</dd>
</dl>
</li>
</ol>'''
d = xoxo.fromXOXO(xoxoSample)
smartxoxoSample= '''<ol class='xoxo'>
<li><a href="http://example.com/more.xoxo"
title="title of item 1"
type="text/xml"
rel="help">item 1</a>

</li>
</ol>'''
d2 = xoxo.fromXOXO(smartxoxoSample)
self.assertEqual(d,d2)
def testSpecialAttributeAndDLDecoding(self):
'''unmung some xoxo with <a href=' rel= etc in plus a <dl> in the same item and check result is right'''
xoxoSample= '''<ol class="xoxo">
<li>
<dl>
<dt>text</dt>
<dd>item 1</dd>
<dt>description</dt>
<dd> This item represents the main point we're trying to make.</dd>
<dt>url</dt>
<dd>http://example.com/more.xoxo</dd>
<dt>title</dt>
<dd>title of item 1</dd>
<dt>type</dt>
<dd>text/xml</dd>
<dt>rel</dt>
<dd>help</dd>
</dl>
</li>
</ol>'''
d = xoxo.fromXOXO(xoxoSample)
smartxoxoSample= '''<ol class="xoxo">
<li><a href="http://example.com/more.xoxo"
title="title of item 1"
type="text/xml"
rel="help">item 1</a>

<dl>
<dt>description</dt>
<dd> This item represents the main point we're trying to make.</dd>
</dl>
</li>
</ol>'''
d2 = xoxo.fromXOXO(smartxoxoSample)
self.assertEqual(d,d2)
def testSpecialAttributeEncode(self):
'''check it makes an <a href with a url parameter'''
d={'url':'http://example.com/more.xoxo','title':'sample url','type':"text/xml",'rel':'help','text':'an example'}
html=xoxo.toXOXO(d)
expectedHTML= '<ol class="xoxo"><li><a href="http://example.com/more.xoxo" title="sample url" rel="help" type="text/xml" >an example</a></li></ol>'
self.assertEqual(html,expectedHTML)

def testSpecialAttributeRoundTripFull(self):
'''check it makes an <a href with a url parameter'''
d={'url':'http://example.com/more.xoxo','title':'sample url','type':"text/xml",'rel':'help','text':'an example'}
html=xoxo.toXOXO(d)
self.assertEqual(d,xoxo.fromXOXO(html))
def testSpecialAttributeRoundTripNoText(self):
'''check it makes an <a href with a url parameter and no text attribute'''
d={'url':'http://example.com/more.xoxo','title':'sample url','type':"text/xml",'rel':'help'}
html=xoxo.toXOXO(d)
self.assertEqual(d,xoxo.fromXOXO(html))
def testSpecialAttributeRoundTripNoTextOrTitle(self):
'''check it makes an <a href with a url parameter and no text or title attribute'''
d={'url':'http://example.com/more.xoxo'}
html=xoxo.toXOXO(d)
self.assertEqual(d,xoxo.fromXOXO(html))
def testAttentionRoundTrip(self):
'''check nested <a> and <dl> and <a> are preserved'''
kmattn='''<ol class="xoxo"><li><a href="http://www.boingboing.net/" title="Boing Boing Blog" >Boing Boing Blog</a><dl><dt>alturls</dt><dd><ol><li><a href="http://boingboing.net/rss.xml" >xmlurl</a></li></ol></dd><dt>description</dt><dd>Boing Boing Blog</dd></dl></li><li><a href="http://www.financialcryptography.com/" title="Financial Cryptography" >Financial Cryptography</a><dl><dt>alturls</dt><dd><ol><li><a href="http://www.financialcryptography.com/mt/index.rdf" >xmlurl</a></li></ol></dd><dt>description</dt><dd>Financial Cryptography</dd></dl></li><li><a href="http://hublog.hubmed.org/" title="HubLog" >HubLog</a><dl><dt>alturls</dt><dd><ol><li><a href="http://hublog.hubmed.org/index.xml" >xmlurl</a></li><li><a href="http://hublog.hubmed.org/foaf.rdf" >foafurl</a></li></ol></dd><dt>description</dt><dd>HubLog</dd></dl></li></ol>''';
d = xoxo.fromXOXO(kmattn)
newattn = xoxo.toXOXO(d)
d2 = xoxo.fromXOXO(newattn)
self.assertEqual(newattn,xoxo.toXOXO(d2))
self.assertEqual(d,d2)
self.assertEqual(kmattn,newattn)

def testUnicodeRoundtrip(self):
'''check unicode characters can go to xoxo and back'''
src=unicode('Tantek \xc3\x87elik and a snowman \xe2\x98\x83','utf-8')
html = xoxo.toXOXO(src)
self.assertEqual(src,xoxo.fromXOXO(html))
def testUtf8Roundtrip(self):
'''check utf8 characters can go to xoxo and back'''
src='Tantek \xc3\x87elik and a snowman \xe2\x98\x83'
html = xoxo.toXOXO(src)
self.assertEqual(src,xoxo.fromXOXO(html).encode('utf-8'))
def testWindows1252Roundtrip(self):
'''check 1252 characters can go to xoxo and back'''
src='This is an evil\xa0space'
html = xoxo.toXOXO(src)
self.assertEqual(src,xoxo.fromXOXO(html).encode('windows-1252'))
if __name__ == "__main__":
unittest.main()
else:
runner = unittest.TextTestRunner()
suite = unittest.makeSuite(xoxoTestCases,'test')
runner.run(suite)

</nowiki></pre>

= Java =
== XOXOWriter.java ==
<pre><nowiki>
/*
* Copyright 2005 Robert Sayre
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Portions of this code are derived from the Apache-licensed Python XOXO
* module by Kevin Marks. <http://microformats.org/wiki/xoxo-sample-code>
*/

package org.atompub.draft.xoxo;

import java.util.*;

public class XOXOWriter {

public String[] attrs = {"title","rel","type"};

public String makeXOXO(List struct, String className){
return makeXOXO(struct, className, 0, true);
}

public String makeXOXO(List struct, String className,
boolean doNSDeclaration){
return makeXOXO(struct, className, 0, doNSDeclaration);
}

public String makeXOXO(List struct){
return makeXOXO(struct, "xoxo", 0, true);
}

public String makeXOXO(Object struct, int depth){
return makeXOXO(struct, null, 0, false);
}

public String makeXOXO(Object struct, String className,
int depth, boolean doNSDeclaration){
if(struct == null) return "";
StringBuffer sb = new StringBuffer();
if(struct instanceof Object[]){
struct = Arrays.asList((Object[]) struct);
}
if(struct instanceof List){
sb.append("<ol");
if(doNSDeclaration)
sb.append(" xmlns=\"http://www.w3.org/1999/xhtml\"");
if(className != null){
sb.append(" class=\"");
sb.append(className);
sb.append("\"");
}
sb.append(">");
}
if(struct instanceof Map){
Map d = new LinkedHashMap((Map) struct);
if(d.containsKey("url")){
sb.append("<a href=\"" + d.get("url") + "\" ");
Object text;
if(d.containsKey("text")){
text = d.get("text");
}else if(d.containsKey("title")){
text = d.get("title");
}else{
text = d.get("url");
}
for(int i=0; i<attrs.length; i++){
String xVal = makeXOXO(d.get(attrs[i]),depth+1);
if(xVal != null && !xVal.equals("")){
sb.append(attrs[i] + "=\"" + xVal + "\" ");
}
d.remove(attrs[i]);
}
sb.append(">" + makeXOXO(text, depth+1) + "</a>");
d.remove("text");
d.remove("url");
}
if(d.size() > 0){
sb.append("<dl>");
for(Iterator i = d.keySet().iterator(); i.hasNext();){
Object k = i.next();
String ddVal = makeXOXO(d.get(k),depth+1);
sb.append("<dt>" + k + "</dt>");
sb.append("<dd>" + ddVal + "</dd>");
}
sb.append("</dl>");
}
}else if(struct instanceof List){
List l = (List) struct;
for(Iterator i = l.iterator(); i.hasNext();){
Object item = i.next();
sb.append("<li>" + makeXOXO(item,depth+1) + "</li>");
}
sb.append("</ol>");
}else{
sb.append(struct);
}
return sb.toString();
}

public String toXOXO(List struct){
return toXOXO(struct, false, null);
}

public String toXOXO(Object struct){
List alist = new ArrayList();
alist.add(struct);
return toXOXO(alist);
}

public String toXOXO(Object struct,
boolean addHTMLWrapper,
String cssUrl){
List alist = new ArrayList();
alist.add(struct);
return toXOXO(alist, addHTMLWrapper, cssUrl);
}

public String toXOXO(List struct,
boolean addHTMLWrapper,
String cssUrl){
String startHTML = "<!DOCTYPE html PUBLIC \"-//W3C//DTD"
+ "XHTML 1.0 Transitional//EN\n"
+ "http://www.w3.org/TR/xhtml1/DTD/"
+ "xhtml1-transitional.dtd\">"
+ "<html xmlns=\"http://www.w3.org/1999/xhtml\">"
+ "<head>";
if(addHTMLWrapper){
String s = startHTML;
if(cssUrl != null){
s += "<style type=\"text/css\">@import \""
+ cssUrl + "\";</style>";
}
s += "</head><body>" + makeXOXO(struct, "xoxo", false)
+ "</body></html>";
return s;
}else{
return makeXOXO(struct, "xoxo");
}
}
}
</nowiki></pre>

== XOXOParser.java ==
This needs some small additions to handle the XHTML DTD and named character entities.

<pre><nowiki>
/*
* Copyright 2005 Robert Sayre
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Portions of this code are derived from the Apache-licensed Python XOXO
* module by Kevin Marks. <http://microformats.org/wiki/xoxo-sample-code>
*/

package org.atompub.draft.xoxo;

import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.XMLReaderFactory;
import org.xml.sax.helpers.DefaultHandler;

import java.util.*;
import java.io.InputStream;
import java.io.StringReader;
import java.io.IOException;

public class XOXOParser extends DefaultHandler {

protected String XHTML_NS = "http://www.w3.org/1999/xhtml";
protected List elStack;
protected Map listEls;
public List structs;
public List xoStack;
public List textStack;

public XOXOParser() {
reset();
}

protected void pushStruct(Object struct){
if((struct instanceof Map) && (((Map) struct).size() > 0)
&& (structs.get(structs.size()-1) instanceof Map)
&& (((Map) struct).containsKey("url"))){
// put back the <a>-made one for extra defs
xoStack.add(structs.get(structs.size()-1));
}else{
structs.add(struct);
xoStack.add(struct);
}
}

public void startElement(String nsUri, String localName,
String qName, Attributes atts){
// bounce non-XHTML elements
if(nsUri.equals(XHTML_NS)){
elStack.add(localName);
}else{
elStack.add("foo");
return;
}

if(localName.equals("a")){
Map attmap = new LinkedHashMap();
int len = atts.getLength();
for(int i=0; i<len; i++){
attmap.put(atts.getQName(i),atts.getValue(i));
}
if(attmap.containsKey("href")){
attmap.put("url",attmap.get("href"));
attmap.remove("href");
}
pushStruct(attmap);
textStack.add("");
}else if(localName.equals("dl")){
pushStruct(new LinkedHashMap());
}else if(localName.equals("ol")){
pushStruct(new ArrayList());
}else if(localName.equals("ul")){
pushStruct(new ArrayList());
}else if(localName.equals("li")){
textStack.add("");
}else if(localName.equals("dt")){
textStack.add("");
}else if(localName.equals("dd")){
textStack.add("");
}
}

public void endElement(String nsUri, String localName,
String qName){
elStack.remove(elStack.size()-1);
// bounce non-XHTML elements
if(nsUri != XHTML_NS){
return;
}

if(localName.equals("a")){
String val = (String) textStack.remove(textStack.size()-1);
if (val.length() > 0){
Map defs = (Map) xoStack.get(xoStack.size()-1);
String defVal = (String) defs.get("title");
if((defVal != null) && (val.equals(defVal))){
val = "";
}
defVal = (String) defs.get("url");
if((defVal != null) && (val.equals(defVal))){
val = "";
}
if(val.length() > 0){
defs.put("text",val);
}
}
xoStack.remove(xoStack.size()-1);
}else if(localName.equals("dl")){
xoStack.remove(xoStack.size()-1);
}else if(localName.equals("ol")){
xoStack.remove(xoStack.size()-1);
}else if(localName.equals("ul")){
xoStack.remove(xoStack.size()-1);
}else if(localName.equals("li")){
Object val = textStack.remove(textStack.size()-1);
List last = (List) xoStack.get(xoStack.size()-1);
if(structs.get(structs.size()-1) != last){
val = structs.remove(structs.size()-1);
}
last.add(val);
}else if(localName.equals("dd")){
Object val = textStack.remove(textStack.size()-1);
Object key = textStack.remove(textStack.size()-1);
Map last = (Map) xoStack.get(xoStack.size()-1);
if(structs.get(structs.size()-1) != last){
val = structs.remove(structs.size()-1);
}
last.put(key,val);
}
}

public void characters(char[] ch, int start, int length){
if((xoStack.size() > 0)
&& (!listEls.containsKey(elStack.get(elStack.size()-1)))){
String text = (String) textStack.get(textStack.size()-1);
String test = new String(ch,start,length);
textStack.set(textStack.size()-1,text+test);
}
}

public Object parse(String s) throws SAXException, IOException{
return parse(new InputSource(new StringReader(s)));
}

public Object parse(InputStream is) throws SAXException, IOException {
return parse(new InputSource(is));
}

public Object parse(InputSource in) throws SAXException, IOException {
XMLReader parser = XMLReaderFactory.createXMLReader();
parser.setContentHandler(this);
parser.parse(in);
List returnList = new ArrayList();
for(Iterator i = this.structs.iterator(); i.hasNext();){
Object thing = i.next();
if(thing != null){
returnList.add(thing);
}
}
while((returnList.size()==1)){
if(returnList.get(0) instanceof List){
returnList = (List) returnList.get(0);
}else{
reset();
return returnList.get(0);
}
}
reset();
return returnList;
}

protected void reset(){
elStack = new ArrayList();
listEls = new HashMap();
structs = new ArrayList();
xoStack = new ArrayList();
textStack = new ArrayList();
listEls.put("ol","ol");
listEls.put("ul","ul");
listEls.put("dl","dl");
}
}

</nowiki></pre>

== XOXOTest.java ==
<pre><nowiki>
/*
* Copyright 2005 Robert Sayre
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Portions of this code are derived from the Apache-licensed Python XOXO
* module by Kevin Marks. <http://microformats.org/wiki/xoxo-sample-code>
*/

package org.atompub.draft.xoxo.tests;

import junit.framework.TestSuite;
import junit.framework.TestCase;
import junit.textui.TestRunner;
import org.atompub.draft.xoxo.XOXOWriter;
import org.atompub.draft.xoxo.XOXOParser;

import java.util.*;

public class XOXOTest extends TestCase {

public static void main(String[] args) {
new TestRunner().doRun(new TestSuite(XOXOTest.class));
}
String XHTML_DEC = "xmlns=\"http://www.w3.org/1999/xhtml\" ";
public String simpleListHTML = "<ol "
+ XHTML_DEC
+ "class=\"xoxo\">"
+ "<li>1</li><li>2</li><li>3</li></ol>";

public void testSimpleList(){
String [] numbers = {"1","2","3"};
XOXOWriter xoxo = new XOXOWriter();
assertEquals(simpleListHTML,
xoxo.toXOXO(Arrays.asList(numbers)));
}

public void testStringIntegerList(){
Object[] numbers = {new Integer(1),"2","3"};
XOXOWriter xoxo = new XOXOWriter();
assertEquals(simpleListHTML,
xoxo.toXOXO(Arrays.asList(numbers)));
}

public String nestedListHTML = "<ol "
+ XHTML_DEC
+ "class=\"xoxo\"><li>1</li><li>"
+ "<ol><li>2</li><li>3</li></ol></li></ol>";

public void testNestedList(){
Object[] arr = {"2","3"};
Object[] nested = {"1",Arrays.asList(arr)};
XOXOWriter xoxo = new XOXOWriter();
assertEquals(nestedListHTML,
xoxo.toXOXO(Arrays.asList(nested)));
}

public void testNestedArray(){
Object[] arr = {"2","3"};
Object[] nested = {"1",arr};
XOXOWriter xoxo = new XOXOWriter();
assertEquals(nestedListHTML,
xoxo.toXOXO(Arrays.asList(nested)));
}

public String dictHTML = "<ol "
+ XHTML_DEC
+ "class=\"xoxo\">"
+ "<li><dl><dt>test</dt><dd>1</dd><dt>name</dt>"
+ "<dd>Kevin</dd></dl></li></ol>";

public void testDictionary(){
Map dict = new LinkedHashMap();
dict.put("test", new Integer(1));
dict.put("name", "Kevin");
XOXOWriter xoxo = new XOXOWriter();
assertEquals(dictHTML,
xoxo.toXOXO(dict));
}

public String singleHTML = "<ol "
+ XHTML_DEC
+ "class=\"xoxo\">"
+ "<li>test</li></ol>";

public void testSingleItem(){
String item = "test";
XOXOWriter xoxo = new XOXOWriter();
assertEquals(singleHTML,
xoxo.toXOXO(item));
}

public void testWrapDiffers(){
String item = "test";
XOXOWriter xoxo = new XOXOWriter();
String nowrap = xoxo.toXOXO(item);
Object[] itemArr = {item};
String wrap = xoxo.toXOXO(Arrays.asList(itemArr),true,null);
assertFalse(wrap.equals(nowrap));
}

String startHTML = "<!DOCTYPE html PUBLIC \"-//W3C//DTD"
+ "XHTML 1.0 Transitional//EN\n"
+ "http://www.w3.org/TR/xhtml1/DTD/"
+ "xhtml1-transitional.dtd\">"
+ "<html xmlns=\"http://www.w3.org/1999/xhtml\">"
+ "<head></head><body>";
public String singleWrapHTML = "<ol "
+ "class=\"xoxo\">"
+ "<li>test</li></ol>";
public String endHTML = "</body></html>";

public void testWrapSingleItem(){
String item = "test";
XOXOWriter xoxo = new XOXOWriter();
assertEquals(startHTML + singleWrapHTML + endHTML,
xoxo.toXOXO(item,true,null));
}

public void testXOXOParser(){
XOXOParser parser = new XOXOParser();
try{
parser.parse(dictHTML);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testDictRoundTrip(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("test", "1");
dict.put("name", "Kevin");
String html = xoxo.toXOXO(dict);
try{
Object newDict = parser.parse(html);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testListRoundTrip(){
Object[] obj = {"1","2","3"};
List testList = Arrays.asList(obj);
XOXOWriter xoxo = new XOXOWriter();
String html = xoxo.toXOXO(testList);
XOXOParser parser = new XOXOParser();
try{
Object newList = parser.parse(html);
assertEquals(testList,newList);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testListOfDictsRoundTrip(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("test", "1");
dict.put("name", "Kevin");
Map dict2 = new LinkedHashMap();
dict2.put("one", "two");
dict2.put("three", "four");
dict2.put("five", "six");
Object[] obj = {"1",dict,dict2};
List testList = Arrays.asList(obj);
String html = xoxo.toXOXO(testList);
try{
Object newList = parser.parse(html);
assertEquals(testList,newList);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testListOfListsRoundTrip(){
Object[] list1 = {"1","2","3"};
Object[] list2 = {"4","5","6", Arrays.asList(list1)};
Object[] list3 = {"7", Arrays.asList(list2)};
Object[] list4 = {"8", Arrays.asList(list3)};
List testList = Arrays.asList(list4);
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
String html = xoxo.toXOXO(testList);
try{
Object newList = parser.parse(html);
assertEquals(testList,newList);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testDictOfListsRoundTrip(){
Object[] list1 = {"1","2","3"};
Object[] list2 = {"4","5","6"};
Object[] list3 = {"7"};
Object[] list4 = {"8", "9"};
Map dict = new LinkedHashMap();
dict.put("foo", Arrays.asList(list1));
dict.put("bar", Arrays.asList(list2));
dict.put("baz", Arrays.asList(list3));
dict.put("qux", Arrays.asList(list4));
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
String html = xoxo.toXOXO(dict);
try{
Object newDict = parser.parse(html);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public String junkXOXO = "<ol "
+ XHTML_DEC
+ "class=\"xoxo\">"
+ "bad<li><dl>worse<dt>good</dt><dd>buy</dd> now</dl></li></ol>";

public void testXOXOJunkInContainers(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("good","buy");
try{
Object newDict = parser.parse(junkXOXO);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public String junkElementXOXO = "<ol "
+ XHTML_DEC
+ "><li>bad<dl><dt>good</dt><dd>buy</dd></dl>"
+ "worse</li><li>bag<ol><li>OK</li></ol>fish</li></ol>";

public void testXOXOjunkInElements(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("good","buy");
Object[] ok = {"OK"};
Object[] obj ={dict, Arrays.asList(ok)};
List testList = Arrays.asList(obj);
try{
Object newList = parser.parse(junkElementXOXO);
assertEquals(testList,newList);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public String xoxoSpacesNewlines = "<ol " + XHTML_DEC +
" class='xoxo'> \n" +
" <li>\n" +
" <dl>\n" +
" <dt>text</dt>\n" +
" <dd>item 1</dd>\n" +
" <dt>description</dt>\n" +
" <dd> This item represents the main" +
" point we're trying to make.</dd>\n" +
" <dt>url</dt>\n" +
" <dd>http://example.com/more.xoxo</dd>\n" +
" <dt>title</dt>\n" +
" <dd>title of item 1</dd>\n" +
" <dt>type</dt>\n" +
" <dd>text/xml</dd>\n" +
" <dt>rel</dt>\n" +
" <dd>help</dd>\n" +
" </dl>\n" +
" </li>\n" +
"</ol>";

public void testXOXOWithSpacesAndNewlines(){
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("text","item 1");
dict.put("description"," This item represents the main" +
" point we're trying to make.");
dict.put("url","http://example.com/more.xoxo");
dict.put("title","title of item 1");
dict.put("type","text/xml");
dict.put("rel","help");
try{
Object newDict = parser.parse(xoxoSpacesNewlines);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public String xoxoSample = "<ol " + XHTML_DEC +
" class='xoxo'> \n" +
" <li>\n" +
" <dl>\n" +
" <dt>text</dt>\n" +
" <dd>item 1</dd>\n" +
" <dt>url</dt>\n" +
" <dd>http://example.com/more.xoxo</dd>\n" +
" <dt>title</dt>\n" +
" <dd>title of item 1</dd>\n" +
" <dt>type</dt>\n" +
" <dd>text/xml</dd>\n" +
" <dt>rel</dt>\n" +
" <dd>help</dd>\n" +
" </dl>\n" +
" </li>\n" +
"</ol>";

public String smartXOXOSample = "<ol " + XHTML_DEC +
"class=\"xoxo\"> \n" +
" <li><a href=\"http://example.com/more.xoxo\"\n" +
" title=\"title of item 1\"\n" +
" type=\"text/xml\"\n" +
" rel=\"help\">item 1</a> \n" +
"\n" +
" </li>\n" +
"</ol>";

public void testSpecialAttributeDecoding(){
XOXOParser parser = new XOXOParser();
try{
Object xoxoDict = parser.parse(xoxoSample);
Object xoxoDict2 = parser.parse(smartXOXOSample);
assertEquals(xoxoDict,xoxoDict2);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public String specialAttrHTML = "<ol " + XHTML_DEC +
"class=\"xoxo\">" +
"<li><a href=\"http://example.com/more.xoxo\" title=\"sample url\" " +
"rel=\"help\" type=\"text/xml\" >an example</a></li></ol>";

public void testSpecialAttributeEncode(){
XOXOWriter xoxo = new XOXOWriter();
Map dict = new LinkedHashMap();
dict.put("url","http://example.com/more.xoxo");
dict.put("title","sample url");
dict.put("type","text/xml");
dict.put("rel","help");
dict.put("text","an example");
String html = xoxo.toXOXO(dict);
assertEquals(specialAttrHTML,html);
}

public void testSpecialAttributeRoundTripFull(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("url","http://example.com/more.xoxo");
dict.put("title","sample url");
dict.put("type","text/xml");
dict.put("rel","help");
dict.put("text","an example");
String html = xoxo.toXOXO(dict);
try{
Object newDict = parser.parse(html);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testSpecialAttributeRoundTripNoText(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("url","http://example.com/more.xoxo");
dict.put("title","sample url");
dict.put("type","text/xml");
dict.put("rel","help");
String html = xoxo.toXOXO(dict);
try{
Object newDict = parser.parse(html);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testSpecialAttributeRoundTripNoTextOrTitle(){
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
Map dict = new LinkedHashMap();
dict.put("url","http://example.com/more.xoxo");
dict.put("type","text/xml");
dict.put("rel","help");
String html = xoxo.toXOXO(dict);
try{
Object newDict = parser.parse(html);
assertEquals(dict,newDict);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

public void testUnicodeRoundTrip(){
String s = "Tantek Çelik and a snowman ?";
XOXOWriter xoxo = new XOXOWriter();
XOXOParser parser = new XOXOParser();
String html = xoxo.toXOXO(s);
try{
Object newString = parser.parse(html);
assertEquals(s,newString);
}catch (Exception e){
fail(e.getMessage());
e.printStackTrace();
}
}

}

</nowiki></pre>

<div style="display:none">
[l_sp]
<a href="http://test.com"> test</a>

</div>

xfolk-scuttle

2006-03-25T14:41:27Z

1143297912:

= Scuttle =
<p>An issue with scuttle's xhtml presentation is that it specifies a collection of bookmarks with the implicit idea that bookmarks are separated each time a new URL is specfied in a <dt> element. Further, things like tags are specified as a collection in a sublist. This approach is fine if one expects that the information will always be presented in a definition list. Such will not be the general case for those not already using scuttle.</p>

<pre><div id="bookmarks">
<h2>Your Bookmarks</h2>
<dl>
<dt>
<a href="http://www.sifry.com/alerts/archives/000306.html">
Sifry&#039;s Alerts: Technorati launches Related Tags
</a>
</dt>
<dd class="description">
Ever wanted to see what posts are related to other posts, what
tags are related to others? Now you can! Just check under the
Tag description on most tag pages, like this one, or this one,
and you&#039;ll see the patterns. Can you smell the emergence?
</dd>
<dd class="tags">
2005-04-09 to
<a href="http://www.niallkennedy.com/scuttle/bookmarks.php/budgibson/folksonomy">
folksonomy
</a>,
<a href="http://www.niallkennedy.com/scuttle/bookmarks.php/budgibson/technorati">
technorati
</a>
</dd>
</dl>
</div></pre>

<p>To get this into xFolk 0.5, the easiest way is to have each xFolk entry in its own <dl> element of class xfolkentry so that individual xFolk entries can be demarcated. We will also have to add class attributes in cases where there are none. Changed and added components are marked with comments at the end of the line.</p>

<pre><div id="bookmarks">
<h2>Your Bookmarks</h2>
<dl class="xfolkentry"> 
<dt>
<a class="taggedlink" 
href="http://www.sifry.com/alerts/archives/000306.html">
Sifry&#039;s Alerts: Technorati launches Related Tags
</a>
</dt>
<dd class="description"> 
Ever wanted to see what posts are related to other posts, what
tags are related to others? Now you can! Just check under the
Tag description on most tag pages, like this one, or this one,
and you&#039;ll see the patterns. Can you smell the emergence?
</dd>
<dd class="tags">
2005-04-09 to
<a rel="tag"
href="http://www.niallkennedy.com/scuttle/bookmarks.php/budgibson/folksonomy"> 
folksonomy
</a>,
<a rel="tag"
href="http://www.niallkennedy.com/scuttle/bookmarks.php/budgibson/technorati"> 
technorati
</a>
</dd>
</dl>
</div></pre>

<div style="display:none">
[l_sp]
<a href="http://test.com"> test</a>

</div>

use

2006-03-25T14:41:18Z

1143297912:

= So you wanna use microformats? =

Microformats are designed to be similar to current markup styles. This means that it is quite possible that you won't have to do much work to produce microformats on your site. Many common kinds of content can be marked up in microformats. Chances are, you already have some of them on your site. Start with the obvious ones. For example...

* Do you have events information on your site? Then mark those events up with [[hCalendar]].
** Start with the [http://microformats.org/code/hcalendar/creator hCalendar creator].
* Do you have people, organizations, or contact information? Then mark those up with [[hCard]].
** Start with the [http://microformats.org/code/hcard/creator hCard creator] and take a look at the [[hcard-examples]].
** Read [[hcard-authoring]] for tips and guidelines on how to best markup existing content with hCard.
* Do you have an explicit copyright license on your content? Then markup the link to your license with [[rel-license]].
* Do you publish social network / relationship info? Then mark that up with [http://gmpg.org/xfn/ XFN].
* Are you tagging things? Then use [[rel-tag]] (for your own stuff) or [[xFolk]] (for tagging any URL).
* Are you publishing lists or outlines? Then use [[XOXO]].
* Do you publish reviews? Then use [[hReview]].
** Start with the [http://microformats.org/code/hreview/creator hReview creator].
* Do you publish press releases? Then use [[hatom|hAtom]].

And here's a few more tips:

* Try to produce clean, semantic xhtml. Often this will get you very close to microformats on its own.
** [http://tantek.com/log/2004/07.html#classmeaningnotshow Class for meaning not for show]
** http://microformats.org/wiki/SemanticXHTMLDesignPrinciples
** [http://tantek.com/presentations/20040928sdforumws/semantic-xhtml.html Semantic XHTML]
** [http://tantek.com/presentations/2005/03/elementsofxhtml Meaningful XHTML]
** [http://www.tantek.com/presentations/2004etech/realworldsemanticspres.html Real World Semantics]
** ''need more links here'' --[[User:RyanKing|RyanKing]] 14:42, 17 Jan 2006 (PST)

<div style="display:none">
[l_sp]
<a href="http://test.com"> test</a>

</div>