Add a test for compiler/route ordering

hakyll.cabal

@@ -64,10 +64,11 @@ Data-files:
 Extra-source-files:
   tests/data/example.md
   tests/data/example.md.metadata
+  tests/data/images/favicon.ico
+  tests/data/posts/2010-08-26-birthday.md
   tests/data/russian.md
   tests/data/template.html
   tests/data/template.html.out
-  tests/data/posts/2010-08-26-birthday.md
 
 Source-Repository head
   Type:     git

src/Hakyll/Core/Rules/Internal.hs

@@ -16,9 +16,9 @@ import           Control.Applicative            (Applicative, (<$>))
 import           Control.Monad.Reader           (ask)
 import           Control.Monad.RWS              (RWST, runRWST)
 import           Control.Monad.Trans            (liftIO)
+import qualified Data.Map                       as M
 import           Data.Monoid                    (Monoid, mappend, mempty)
 import           Data.Set                       (Set)
-import qualified Data.Set                       as S
 
 
 --------------------------------------------------------------------------------
@@ -92,25 +92,17 @@ instance MonadMetadata Rules where
 runRules :: Rules a -> Provider -> IO RuleSet
 runRules rules provider = do
     (_, _, ruleSet) <- runRWST (unRules rules) env emptyRulesState
-    case findDuplicate (map fst $ rulesCompilers ruleSet) of
-        Nothing  -> return ruleSet
-        Just id' -> error $
-            "Hakyll.Core.Rules.Internal: two different rules for " ++
-            show id' ++ " exist, bailing out"
 
+    -- Ensure compiler uniqueness
+    let ruleSet' = ruleSet
+            { rulesCompilers = M.toList $
+                M.fromListWith (flip const) (rulesCompilers ruleSet)
+            }
+
+    return ruleSet'
   where
     env = RulesRead
         { rulesProvider = provider
         , rulesMatches  = []
         , rulesVersion  = Nothing
         }
-
-
---------------------------------------------------------------------------------
-findDuplicate :: Ord a => [a] -> Maybe a
-findDuplicate = go S.empty
-  where
-    go _ []              = Nothing
-    go s (x : xs)
-        | x `S.member` s = Just x
-        | otherwise      = go (S.insert x s) xs

tests/Hakyll/Core/Rules/Tests.hs

@@ -10,7 +10,6 @@ import           Data.IORef                     (IORef, newIORef, readIORef,
                                                  writeIORef)
 import qualified Data.Set                       as S
 import           Test.Framework                 (Test, testGroup)
-import           Test.Framework.Providers.HUnit (testCase)
 import           Test.HUnit                     (Assertion, assert, (@=?))
 
 
@@ -28,18 +27,17 @@ import           TestSuite.Util
 
 --------------------------------------------------------------------------------
 tests :: Test
-tests = testGroup "Hakyll.Core.Rules.Tests"
-    [ testCase "runRules" rulesTest
-    ]
+tests = testGroup "Hakyll.Core.Rules.Tests" $ fromAssertions "runRules"
+    [case01]
 
 
 --------------------------------------------------------------------------------
-rulesTest :: Assertion
-rulesTest = do
+case01 :: Assertion
+case01 = do
     ioref    <- newIORef False
     store    <- newTestStore
     provider <- newTestProvider store
-    ruleSet  <- runRules (rules ioref) provider
+    ruleSet  <- runRules (rules01 ioref) provider
     let identifiers = S.fromList $ map fst $ rulesCompilers ruleSet
         routes      = rulesRoutes ruleSet
 
@@ -64,8 +62,8 @@ rulesTest = do
 
 
 --------------------------------------------------------------------------------
-rules :: IORef Bool -> Rules ()
-rules ioref = do
+rules01 :: IORef Bool -> Rules ()
+rules01 ioref = do
     -- Compile some posts
     match "*.md" $ do
         route $ setExtension "html"

tests/Hakyll/Core/Runtime/Tests.hs

@@ -20,7 +20,8 @@ import           TestSuite.Util
 
 --------------------------------------------------------------------------------
 tests :: Test
-tests = testGroup "Hakyll.Core.Runtime.Tests" $ fromAssertions "run" [case01]
+tests = testGroup "Hakyll.Core.Runtime.Tests" $
+    fromAssertions "run" [case01, case02]
 
 
 --------------------------------------------------------------------------------
@@ -48,3 +49,22 @@ case01 = do
     head (lines bodies) @?=  "This is an example."
 
     cleanTestEnv
+
+
+--------------------------------------------------------------------------------
+case02 :: Assertion
+case02 = do
+    _ <- run testConfiguration Logger.Error $ do
+        match "images/favicon.ico" $ do
+            route   $ gsubRoute "images/" (const "")
+            compile $ makeItem ("Test" :: String)
+
+        match "images/**" $ do
+            route   idRoute
+            compile copyFileCompiler
+
+    favicon <- readFile $
+        destinationDirectory testConfiguration </> "favicon.ico"
+    favicon @?= "Test"
+
+    cleanTestEnv