Python Serializer.to_string方法代码示例

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def test_json_recipe():
    """
    JSON serializer roundtrips.
    """
    recipe = Recipe('other')
    recipe.set_recipe([['bagbuzz', '']])
    recipe.policy.manage = ['a']
    recipe.policy.read = ['b']
    recipe.policy.create = ['c']
    recipe.policy.delete = ['d']
    recipe.policy.owner = 'e'
    serializer = Serializer('json')
    serializer.object = recipe
    string = serializer.to_string()

    other_recipe = Recipe('other')
    serializer.object = other_recipe
    serializer.from_string(string)

    assert recipe == other_recipe

    serializer.object = other_recipe
    other_string = serializer.to_string()

    assert string == other_string

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def compare_tiddlers(rev1, rev2, format=None):
    """
	compare two Tiddler instances
	"""
    serializer = Serializer("text")
    serializer.object = rev1
    rev1 = serializer.to_string()
    serializer.object = rev2
    rev2 = serializer.to_string()
    return diff(rev1, rev2, format)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def lbags(args):
    """List all the bags on the system"""
    store = _store()
    bags = store.list_bags()
    serializer = Serializer('json')
    for bag in bags:
        bag = store.get(bag)
        serializer.object = bag
        print 'Name: %s' % bag.name
        print serializer.to_string()
        print

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def test_wrong_class():
    class Foo(object):
        pass

    foo = Foo()
    serializer = Serializer('text')
    serializer.object = foo
    string = 'haha'

    with py.test.raises(AttributeError):
        serializer.to_string()
    with py.test.raises(AttributeError):
        serializer.from_string(string)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
 def lbags(args):
     """List all the bags on the system. [<bag> <bag> <bag>] to limit."""
     from tiddlyweb.model.bag import Bag
     store = _store()
     bags = [Bag(name) for name in args]
     if not bags:
         bags = store.list_bags()
     serializer = Serializer('json')
     for listed_bag in bags:
         listed_bag = store.get(listed_bag)
         serializer.object = listed_bag
         print 'Name: %s' % listed_bag.name.encode('utf-8')
         print serializer.to_string().encode('utf-8')
         print

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def send_entity(environ, start_response, entity):
    """
    Send a :py:class:`bag <tiddlyweb.model.bag.Bag>` or :py:class:`recipe
    <tiddlyweb.model.recipe.Recipe>` out over HTTP, first
    :py:class:`serializing <tiddlyweb.serializer.Serializer>` to
    the correct type. If an incoming ``Etag`` validates, raise a
    ``304`` response.
    """
    etag_string = entity_etag(environ, entity)
    check_incoming_etag(environ, etag_string)

    try:
        serialize_type, mime_type = get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)
        serializer.object = entity
        content = serializer.to_string()
    except NoSerializationError:
        raise HTTP415('Content type %s not supported' % mime_type)

    start_response("200 OK",
            [('Content-Type', mime_type),
                ('Cache-Control', 'no-cache'),
                ('ETag', etag_string),
                ('Vary', 'Accept')])

    if isinstance(content, basestring):
        return [content]
    else:
        return content

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def test_bag_to_html():
    serializer = Serializer("html")

    serializer.object = bagfour
    html = serializer.to_string()

    assert html == expected_bag_html

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def test_generated_text():
    serializer = Serializer("text")
    serializer.object = recipe
    string = serializer.to_string()

    assert string == expected_string
    assert "%s" % serializer == expected_string

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def get(environ, start_response):
    """
    Get a representation in some serialization of
    a bag (the bag itself not the tiddlers within).
    """
    bag_name = _determine_bag_name(environ)
    bag_name = web.handle_extension(environ, bag_name)
    bag = _get_bag(environ, bag_name, True)

    bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')

    try:
        serialize_type, mime_type = web.get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)
        serializer.object = bag

        content = serializer.to_string()
    except NoSerializationError:
        raise HTTP415('Content type not supported: %s' % mime_type)

    start_response("200 Ok",
            [('Content-Type', mime_type),
                ('Vary', 'Accept')])

    return [content]

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def send_entity(environ, start_response, entity):
    """
    Send a bag or recipe out HTTP, first serializing to
    the correct type. If the incoming etag matches, raise
    304.
    """
    etag_string = entity_etag(environ, entity)
    incoming_etag = environ.get('HTTP_IF_NONE_MATCH', None)
    if incoming_etag:
        if incoming_etag == etag_string:
            raise HTTP304(incoming_etag)

    try:
        serialize_type, mime_type = get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)
        serializer.object = entity
        content = serializer.to_string()
    except NoSerializationError:
        raise HTTP415('Content type %s not supported' % mime_type)

    start_response("200 OK",
            [('Content-Type', mime_type),
                ('Cache-Control', 'no-cache'),
                ('ETag', etag_string),
                ('Vary', 'Accept')])

    if isinstance(content, basestring):
        return [content]
    else:
        return content

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def _get_tiddler_content(environ, tiddler):
    """
    Extract the content of the tiddler, either straight up if
    the content is not considered text, or serialized if it is
    """
    config = environ['tiddlyweb.config']
    default_serializer = config['default_serializer']
    default_serialize_type = config['serializers'][default_serializer][0]
    serialize_type, mime_type = web.get_serialize_type(environ)
    extension = environ.get('tiddlyweb.extension')

    if not renderable(tiddler, environ):
        if (serialize_type == default_serialize_type or
                mime_type.startswith(tiddler.type) or
                extension == 'html'):
            mime_type = tiddler.type
            content = tiddler.text
            return content, mime_type

    serializer = Serializer(serialize_type, environ)
    serializer.object = tiddler

    try:
        content = serializer.to_string()
    except (TiddlerFormatError, NoSerializationError), exc:
        raise HTTP415(exc)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def send_entity(environ, start_response, entity):
    """
    Send a bag or recipe out HTTP, first serializing to
    the correct type.
    """
    username = environ['tiddlyweb.usersign']['name']
    try:
        serialize_type, mime_type = get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)
        serializer.object = entity
        content = serializer.to_string()
    except NoSerializationError:
        raise HTTP415('Content type %s not supported' % mime_type)

    etag_string = '"%s"' % (sha(_entity_etag(entity) +
        encode_name(username) + encode_name(mime_type)).hexdigest())

    start_response("200 OK",
            [('Content-Type', mime_type),
                ('ETag', etag_string),
                ('Vary', 'Accept')])

    if isinstance(content, basestring):
        return [content]
    else:
        return content

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def test_generated_txt_string():
    serializer = Serializer('text')
    serializer.object = tiddler
    string = serializer.to_string()

    assert string == expected_string
    assert '%s' % serializer == expected_string

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def _get_tiddler_content(environ, tiddler):
    """
    Extract the content of the tiddler, either straight up if
    the content is not considered text, or serialized if it is.
    """
    config = environ['tiddlyweb.config']
    default_serializer = config['default_serializer']
    default_serialize_type = config['serializers'][default_serializer][0]
    serialize_type, mime_type = get_serialize_type(environ)
    extension = environ.get('tiddlyweb.extension')
    serialized = False

    # If this is a tiddler with a CANONICAL_URI_FIELD redirect
    # there unless we are requesting a json form
    if (CANONICAL_URI_FIELD in tiddler.fields
            and not CANONICAL_URI_PASS_TYPE in mime_type):
        raise HTTP302(tiddler.fields[CANONICAL_URI_FIELD])

    if not renderable(tiddler, environ):
        if (serialize_type == default_serialize_type or
                mime_type.startswith(tiddler.type) or
                extension == 'html'):
            mime_type = tiddler.type
            content = tiddler.text
            return content, mime_type, serialized

    serializer = Serializer(serialize_type, environ)
    serializer.object = tiddler

    try:
        content = serializer.to_string()
        serialized = True
    except (TiddlerFormatError, NoSerializationError) as exc:
        raise HTTP415(exc)
    return content, mime_type, serialized

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import to_string [as 别名]
def test_html_attribute_escape_with_bag():
    tiddler = Tiddler('escape "double" quotes in tiddler field values')
    tiddler.bag = 'foo "bar" baz'
    tiddler.modifier = 'Chris "sensei" Dent'
    tiddler.tags = ["foo", 'xxx "yyy" zzz']
    tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
    tiddler.text = ''
    serializer = Serializer('tiddlywebwiki.serialization', environ)
    serializer.object = tiddler
    string = serializer.to_string()

    assert ('title="escape "double" quotes in tiddler field values"'
        in string)
    assert ('server.title="escape "double" quotes in tiddler '
        'field values"' in string)
    assert 'bag="foo "bar" baz"' in string
    assert 'server.workspace="bags/foo "bar" baz"' in string
    assert 'modifier="Chris "sensei" Dent"' in string
    assert 'creator="Chris "sensei" Dent"' in string
    assert 'tags="foo [[xxx "yyy" zzz]]"' in string
    assert '''custom="lorem 'ipsum' dolor "sit" amet"''' in string
    # single tiddler's browse link is that tiddler in its bag
    assert ('you may still <a href="/bags/foo%20%22bar%22%20baz/tiddlers/'
            'escape%20%22double%22%20quotes%20in%20tiddler%20field%20'
            'values">browse' in string)