[Lsb-messages] /var/www/bzr/lsb/devel/repogen r211: Minor tweaks, fix bug in version comparison.

[Jeff Licquia]

------------------------------------------------------------
revno: 211
committer: Jeff Licquia <licquia at linuxfoundation.org>
branch nick: repogen
timestamp: Wed 2013-07-10 13:30:22 -0400
message:
  Minor tweaks, fix bug in version comparison.
modified:
  Package.hs
-------------- next part --------------
=== modified file 'Package.hs'
--- a/Package.hs	2013-06-17 20:06:08 +0000
+++ b/Package.hs	2013-07-10 17:30:22 +0000
@@ -158,16 +158,19 @@
 derivedDeb :: Package -> Maybe Package
 derivedDeb p
     | pkgtype p == Deb = Just p
-    | isJust cvtArch = Just Package {
-        path="",
-        pkgtype=Deb,
-        name=convertRpmName $ name p,
-        epoch=epoch p,
-        version=version p,
-        release=release p,
-        arch=arch p }
-    | otherwise = Nothing
-    where cvtArch = archDebName $ arch p
+    | otherwise = do
+        -- We don't need the converted name, but we care if the
+        -- conversion succeeds or not.
+        archDebName $ arch p
+        -- If it didn't succeed, we won't get this far.
+        return Package {
+            path="",
+            pkgtype=Deb,
+            name=convertRpmName $ name p,
+            epoch=epoch p,
+            version=version p,
+            release=release p,
+            arch=arch p }
 
 -- Given a Debian package, do the reverse of derivedDeb: figure out
 -- which RPM it came from.
@@ -200,9 +203,11 @@
 fileNameFromPackage :: Package -> FilePath
 fileNameFromPackage p
     | pkgtype p == Deb
-      = name p ++ "_" ++ version p ++ "-" ++ release p ++ "_" ++ (fromJust $ archDebName $ arch p) ++ ".deb"
+      = concat [name p, "_", version p, "-", release p, "_",
+                fromJust $ archDebName $ arch p, ".deb"]
     | otherwise
-      = name p ++ "-" ++ version p ++ "-" ++ release p ++ "." ++ (archRpmName $ arch p) ++ ".rpm"
+      = concat [name p, "-", version p, "-", release p, ".",
+                archRpmName $ arch p, ".rpm"]
 
 packageRecalcPath :: Package -> Package
 packageRecalcPath p = Package {
@@ -233,30 +238,29 @@
 -- to mirror the rules as specified by RPM and in the Debian Policy
 -- Manual; any deviation from those rules is a bug.
 
-fragmentCollect :: [Char] -> (String, String) -> (String, String)
-fragmentCollect charset (xs, "") = (xs, "")
-fragmentCollect charset (xs, y:ys)
-    | y `elem` charset
-      = fragmentCollect charset (xs ++ [y], ys)
-    | otherwise
-      = (xs, y:ys)
-
+-- Sets of characters that constitute parts of a version in a version
+-- string.  Each contiguous group of characters in each set is one
+-- component, while characters not in any sets are dropped and not
+-- considered part of any version component.
 getSet :: Char -> Maybe [Char]
-getSet c = let sets = filter (elem c) [ ['0'..'9'], (['A'..'Z'] ++ ['a'..'z']),
-                                        ['~'] ]
-           in if null sets then Nothing
-                           else Just $ head sets
+getSet c = listToMaybe $ filter (elem c) [ ['0'..'9'],
+                                           (['A'..'Z'] ++ ['a'..'z']), ['~'] ]
 
+-- Split a version into chunks, based on their membership (or
+-- lack thereof) in one of the above sets.
 splitVersion :: String -> [String]
 splitVersion "" = []
 splitVersion (x:xs)
     | isJust charset
-      = let (chunk, rest) = fragmentCollect (fromJust charset) ([x], xs)
+      = let (chunk, rest) = span (`elem` (fromJust charset)) (x:xs)
         in [chunk] ++ splitVersion rest
     | otherwise
       = splitVersion xs
     where charset = getSet x
 
+-- Comparison rules for each chunk.  ~ always sorts last (even after
+-- the empty string), convert numbers for comparison, otherwise
+-- do string comparisons.
 compareVersionChunks :: String -> String -> Ordering
 compareVersionChunks "" "" = EQ
 compareVersionChunks "" (y:ys) 
@@ -276,6 +280,8 @@
       = (x:xs) `compare` (y:ys)
     where numbers = ['0'..'9']
 
+-- Compare two versions as split into chunks.  The main wrinkle:
+-- we need to ensure ~ sorts as less than an empty list.
 compareVersionChunkLists :: [String] -> [String] -> Ordering
 compareVersionChunkLists [] [] = EQ
 compareVersionChunkLists [] (y:ys)
@@ -292,8 +298,9 @@
 
 comparePackageVersions :: Package -> Package -> Ordering
 comparePackageVersions x y
-    = compareVersionChunkLists [epoch x, version x, release x] 
-        [epoch y, version y, release y]
+    = compareVersionChunkLists (reduceVersions [epoch x, version x, release x])
+        (reduceVersions [epoch y, version y, release y])
+    where reduceVersions x = concat $ map splitVersion x
 
 compareVersionStrings :: String -> String -> Ordering
 compareVersionStrings x y