dc15dc32bb
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1052740 13f79535-47bb-0310-9956-ffa450edef68
120 lines
4.6 KiB
Python
120 lines
4.6 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you 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.
|
|
|
|
# ATOM data conversion functions
|
|
|
|
from util import *
|
|
from elemutil import *
|
|
from xmlutil import *
|
|
|
|
# Convert a list of elements to a list of values representing an ATOM entry
|
|
def entryElementsToValues(e):
|
|
lt = filter(selector((element, "'title")), e)
|
|
t = "" if isNil(lt) else elementValue(car(lt))
|
|
li = filter(selector((element, "'id")), e)
|
|
i = "" if isNil(li) else elementValue(car(li))
|
|
lc = filter(selector((element, "'content")), e)
|
|
return (t, i, elementValue(car(lc)))
|
|
|
|
# Convert a list of elements to a list of values representing ATOM entries
|
|
def entriesElementsToValues(e):
|
|
if isNil(e):
|
|
return e
|
|
return cons(entryElementsToValues(car(e)), entriesElementsToValues(cdr(e)))
|
|
|
|
# Convert a list of strings to a list of values representing an ATOM entry
|
|
def readATOMEntry(l):
|
|
e = readXML(l)
|
|
if isNil(e):
|
|
return ()
|
|
return entryElementsToValues(car(e))
|
|
|
|
# Convert a list of values representy an ATOM entry to a value
|
|
def entryValue(e):
|
|
v = elementsToValues((caddr(e),))
|
|
return cons(car(e), (cadr(e), cdr(car(v))))
|
|
|
|
# Return true if a list of strings represents an ATOM feed
|
|
def isATOMFeed(l):
|
|
if not isXML(l):
|
|
return False
|
|
return contains(car(l), "<feed") and contains(car(l), "=\"http://www.w3.org/2005/Atom\"")
|
|
|
|
# Convert a list of strings to a list of values representing an ATOM feed
|
|
def readATOMFeed(l):
|
|
f = readXML(l)
|
|
if isNil(f):
|
|
return ()
|
|
t = filter(selector((element, "'title")), car(f))
|
|
i = filter(selector((element, "'id")), car(f))
|
|
e = filter(selector((element, "'entry")), car(f))
|
|
if isNil(e):
|
|
return (elementValue(car(t)), elementValue(car(i)))
|
|
return cons(elementValue(car(t)), cons(elementValue(car(i)), entriesElementsToValues(e)))
|
|
|
|
# Convert an ATOM feed containing elements to an ATOM feed containing values
|
|
def feedValuesLoop(e):
|
|
if (isNil(e)):
|
|
return e
|
|
return cons(entryValue(car(e)), feedValuesLoop(cdr(e)))
|
|
|
|
def feedValues(e):
|
|
return cons(car(e), cons(cadr(e), feedValuesLoop(cddr(e))))
|
|
|
|
# Convert a list of values representy an ATOM entry to a list of elements
|
|
def entryElement(l):
|
|
return (element, "'entry", (attribute, "'xmlns", "http://www.w3.org/2005/Atom"),
|
|
(element, "'title", (attribute, "'type", "text"), car(l)),
|
|
(element, "'id", cadr(l)),
|
|
(element, "'content", (attribute, "'type", ("application/xml" if isList(caddr(l)) else "text")), caddr(l)),
|
|
(element, "'link", (attribute, "'href", cadr(l))))
|
|
|
|
# Convert a list of values representing ATOM entries to a list of elements
|
|
def entriesElements(l):
|
|
if isNil(l):
|
|
return l
|
|
return cons(entryElement(car(l)), entriesElements(cdr(l)))
|
|
|
|
# Convert a list of values representing an ATOM entry to an ATOM entry
|
|
def writeATOMEntry(l):
|
|
return writeXML((entryElement(l),), True)
|
|
|
|
# Convert a list of values representing an ATOM feed to an ATOM feed
|
|
def writeATOMFeed(l):
|
|
f = (element, "'feed", (attribute, "'xmlns", "http://www.w3.org/2005/Atom"),
|
|
(element, "'title", (attribute, "'type", "text"), car(l)),
|
|
(element, "'id", cadr(l)))
|
|
if isNil(cddr(l)):
|
|
return writeXML((f,), True)
|
|
fe = append(f, entriesElements(cddr(l)))
|
|
return writeXML((fe,), True)
|
|
|
|
# Convert an ATOM entry containing a value to an ATOM entry containing an item element
|
|
def entryValuesToElements(v):
|
|
if isList(caddr(v)):
|
|
return cons(car(v), cons(cadr(v), valuesToElements((cons("'item", caddr(v)),))))
|
|
return cons(car(v), cons(cadr(v), valuesToElements((("'item", caddr(v)),))))
|
|
|
|
# Convert an ATOM feed containing values to an ATOM feed containing elements
|
|
def feedValuesToElementsLoop(v):
|
|
if isNil(v):
|
|
return v
|
|
return cons(entryValuesToElements(car(v)), feedValuesToElementsLoop(cdr(v)))
|
|
|
|
def feedValuesToElements(v):
|
|
return cons(car(v), cons(cadr(v), feedValuesToElementsLoop(cddr(v))))
|
|
|