Rev 5267: (Jelmer) This adds {split, in file:///home/pqm/archives/thelove/bzr/%2Btrunk/
Canonical.com Patch Queue Manager
pqm at pqm.ubuntu.com
Fri May 28 03:39:37 BST 2010
At file:///home/pqm/archives/thelove/bzr/%2Btrunk/
------------------------------------------------------------
revno: 5267 [merge]
revision-id: pqm at pqm.ubuntu.com-20100528023932-s5fu0vv28yt86kzd
parent: pqm at pqm.ubuntu.com-20100528002532-9bzj1fajyxckd1rg
parent: jelmer at samba.org-20100527221042-g55b5f0z51wytboi
committer: Canonical.com Patch Queue Manager <pqm at pqm.ubuntu.com>
branch nick: +trunk
timestamp: Fri 2010-05-28 03:39:32 +0100
message:
(Jelmer) This adds {split,
join}_segment_parameters to urlutils - plumbing for colocated
branches.
modified:
bzrlib/tests/test_urlutils.py test_urlutils.py-20060502192900-46b1f9579987cf9c
bzrlib/urlutils.py urlutils.py-20060502195429-e8a161ecf8fac004
=== modified file 'bzrlib/tests/test_urlutils.py'
--- a/bzrlib/tests/test_urlutils.py 2010-02-17 17:11:16 +0000
+++ b/bzrlib/tests/test_urlutils.py 2010-05-27 22:10:42 +0000
@@ -270,6 +270,51 @@
self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
+ def test_join_segment_parameters_raw(self):
+ join_segment_parameters_raw = urlutils.join_segment_parameters_raw
+ self.assertEquals("/somedir/path",
+ join_segment_parameters_raw("/somedir/path"))
+ self.assertEquals("/somedir/path,rawdata",
+ join_segment_parameters_raw("/somedir/path", "rawdata"))
+ self.assertRaises(InvalidURLJoin,
+ join_segment_parameters_raw, "/somedir/path",
+ "rawdata1,rawdata2,rawdata3")
+ self.assertEquals("/somedir/path,bla,bar",
+ join_segment_parameters_raw("/somedir/path", "bla", "bar"))
+ self.assertEquals("/somedir,exist=some/path,bla,bar",
+ join_segment_parameters_raw("/somedir,exist=some/path",
+ "bla", "bar"))
+ self.assertRaises(TypeError, join_segment_parameters_raw,
+ "/somepath", 42)
+
+ def test_join_segment_parameters(self):
+ join_segment_parameters = urlutils.join_segment_parameters
+ self.assertEquals("/somedir/path",
+ join_segment_parameters("/somedir/path", {}))
+ self.assertEquals("/somedir/path,key1=val1",
+ join_segment_parameters("/somedir/path", {"key1": "val1"}))
+ self.assertRaises(InvalidURLJoin,
+ join_segment_parameters, "/somedir/path",
+ {"branch": "brr,brr,brr"})
+ self.assertRaises(InvalidURLJoin,
+ join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
+ self.assertEquals("/somedir/path,key1=val1,key2=val2",
+ join_segment_parameters("/somedir/path", {
+ "key1": "val1", "key2": "val2"}))
+ self.assertEquals("/somedir/path,key1=val1,key2=val2",
+ join_segment_parameters("/somedir/path,key1=val1", {
+ "key2": "val2"}))
+ self.assertEquals("/somedir/path,key1=val2",
+ join_segment_parameters("/somedir/path,key1=val1", {
+ "key1": "val2"}))
+ self.assertEquals("/somedir,exist=some/path,key1=val1",
+ join_segment_parameters("/somedir,exist=some/path",
+ {"key1": "val1"}))
+ self.assertEquals("/,key1=val1,key2=val2",
+ join_segment_parameters("/,key1=val1", {"key2": "val2"}))
+ self.assertRaises(TypeError,
+ join_segment_parameters, "/,key1=val1", {"foo": 42})
+
def test_function_type(self):
if sys.platform == 'win32':
self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
@@ -412,6 +457,53 @@
self.assertEqual(('path/..', 'foo'), split('path/../foo'))
self.assertEqual(('../path', 'foo'), split('../path/foo'))
+ def test_split_segment_parameters_raw(self):
+ split_segment_parameters_raw = urlutils.split_segment_parameters_raw
+ self.assertEquals(("/some/path", []),
+ split_segment_parameters_raw("/some/path"))
+ self.assertEquals(("/some/path", ["tip"]),
+ split_segment_parameters_raw("/some/path,tip"))
+ self.assertEquals(("/some,dir/path", ["tip"]),
+ split_segment_parameters_raw("/some,dir/path,tip"))
+ self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
+ split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
+ self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
+ split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
+ self.assertEquals(("/", ["key1=val1"]),
+ split_segment_parameters_raw(",key1=val1"))
+ self.assertEquals(("foo/", ["key1=val1"]),
+ split_segment_parameters_raw("foo/,key1=val1"))
+ self.assertEquals(("foo/base,la=bla/other/elements", []),
+ split_segment_parameters_raw("foo/base,la=bla/other/elements"))
+ self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
+ split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
+
+ def test_split_segment_parameters(self):
+ split_segment_parameters = urlutils.split_segment_parameters
+ self.assertEquals(("/some/path", {}),
+ split_segment_parameters("/some/path"))
+ self.assertEquals(("/some/path", {"branch": "tip"}),
+ split_segment_parameters("/some/path,branch=tip"))
+ self.assertEquals(("/some,dir/path", {"branch": "tip"}),
+ split_segment_parameters("/some,dir/path,branch=tip"))
+ self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
+ split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
+ self.assertEquals(("/somedir/path",
+ {"ref": "heads%2Ftip", "key1": "val1"}),
+ split_segment_parameters(
+ "/somedir/path,ref=heads%2Ftip,key1=val1"))
+ self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
+ split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
+ self.assertEquals(("/", {"key1": "val1"}),
+ split_segment_parameters(",key1=val1"))
+ self.assertEquals(("foo/", {"key1": "val1"}),
+ split_segment_parameters("foo/,key1=val1"))
+ self.assertEquals(("foo/base,key1=val1/other/elements", {}),
+ split_segment_parameters("foo/base,key1=val1/other/elements"))
+ self.assertEquals(("foo/base,key1=val1/other/elements",
+ {"key2": "val2"}), split_segment_parameters(
+ "foo/base,key1=val1/other/elements,key2=val2"))
+
def test_win32_strip_local_trailing_slash(self):
strip = urlutils._win32_strip_local_trailing_slash
self.assertEqual('file://', strip('file://'))
=== modified file 'bzrlib/urlutils.py'
--- a/bzrlib/urlutils.py 2010-02-17 17:11:16 +0000
+++ b/bzrlib/urlutils.py 2010-05-27 22:10:42 +0000
@@ -469,6 +469,78 @@
return url_base + head, tail
+def split_segment_parameters_raw(url):
+ """Split the subsegment of the last segment of a URL.
+
+ :param url: A relative or absolute URL
+ :return: (url, subsegments)
+ """
+ (parent_url, child_dir) = split(url)
+ subsegments = child_dir.split(",")
+ if len(subsegments) == 1:
+ return (url, [])
+ return (join(parent_url, subsegments[0]), subsegments[1:])
+
+
+def split_segment_parameters(url):
+ """Split the segment parameters of the last segment of a URL.
+
+ :param url: A relative or absolute URL
+ :return: (url, segment_parameters)
+ """
+ (base_url, subsegments) = split_segment_parameters_raw(url)
+ parameters = {}
+ for subsegment in subsegments:
+ (key, value) = subsegment.split("=", 1)
+ parameters[key] = value
+ return (base_url, parameters)
+
+
+def join_segment_parameters_raw(base, *subsegments):
+ """Create a new URL by adding subsegments to an existing one.
+
+ This adds the specified subsegments to the last path in the specified
+ base URL. The subsegments should be bytestrings.
+
+ :note: You probably want to use join_segment_parameters instead.
+ """
+ if not subsegments:
+ return base
+ for subsegment in subsegments:
+ if type(subsegment) is not str:
+ raise TypeError("Subsegment %r is not a bytestring" % subsegment)
+ if "," in subsegment:
+ raise errors.InvalidURLJoin(", exists in subsegments",
+ base, subsegments)
+ return ",".join((base,) + subsegments)
+
+
+def join_segment_parameters(url, parameters):
+ """Create a new URL by adding segment parameters to an existing one.
+
+ The parameters of the last segment in the URL will be updated; if a
+ parameter with the same key already exists it will be overwritten.
+
+ :param url: A URL, as string
+ :param parameters: Dictionary of parameters, keys and values as bytestrings
+ """
+ (base, existing_parameters) = split_segment_parameters(url)
+ new_parameters = {}
+ new_parameters.update(existing_parameters)
+ for key, value in parameters.iteritems():
+ if type(key) is not str:
+ raise TypeError("parameter key %r is not a bytestring" % key)
+ if type(value) is not str:
+ raise TypeError("parameter value %r for %s is not a bytestring" %
+ (key, value))
+ if "=" in key:
+ raise errors.InvalidURLJoin("= exists in parameter key", url,
+ parameters)
+ new_parameters[key] = value
+ return join_segment_parameters_raw(base,
+ *["%s=%s" % item for item in sorted(new_parameters.items())])
+
+
def _win32_strip_local_trailing_slash(url):
"""Strip slashes after the drive letter"""
if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
More information about the bazaar-commits
mailing list