language-dockerfile: Dockerfile linter, parser, pretty-printer and embedded DSL

[ development, gpl, library ] [ Propose Tags ]
Dependencies aeson, base (>=4.8 && <5), bytestring (>=0.10), directory, filepath, free, Glob, language‑dockerfile, mtl, parsec (>=3.1), pretty, ShellCheck, split (>=0.2), template‑haskell, text, th‑lift, th‑lift‑instances, transformers, unordered‑containers, yaml [details]
License GPL-3.0-only
Copyright Lukas Martinelli, Copyright (c) 2016, Pedro Tacla Yamada, Copyright (c) 2016
Author Lukas Martinelli, Pedro Tacla Yamada
Category Development
Home page
Bug tracker
Source repo head: git clone
Uploaded by yamadapc at Sun May 14 23:27:47 UTC 2017
Distributions NixOS:
Executables hadolint, dockerfmt
Downloads 1601 total (38 in the last 30 days)
Rating (no votes yet) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2017-05-14 [all 1 reports]
Hackage Matrix CI

Forked from hadolint.

All functions for parsing, printing and writting Dockerfiles are exported through Language.Dockerfile. For more fine-grained operations look for specific modules that implement a certain functionality.

There are two flags in this package, which enable building two executables:

See the GitHub project for the source-code and examples.

[Skip to Readme]





Build the dockerfmt executable


Build the hadolint executable


Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info


Maintainer's Corner

For package maintainers and hackage trustees

Readme for language-dockerfile-

[back to package description]


Build Status CircleCI


GH Pages Haddock

Blog Post in Portuguese

Dockerfile linter, parser, pretty-printer and embedded DSL, forked from hadolint.

Published on Hackage as language-dockerfile.

It extends hadolint with the pretty-printer and EDSL for writting Dockerfiles in Haskell.

Parsing files

import Language.Dockerfile
main = do
    ef <- parseFile "./Dockerfile"
    print ef

Parsing strings

import Language.Dockerfile
main = do
    c <- readFile "./Dockerfile"
    print (parseString c)

Pretty-printing files

import Language.Dockerfile
main = do
    Right d <- parseFile "./Dockerfile"
    putStr (prettyPrint d)

Writing Dockerfiles in Haskell

{-# LANGUAGE OverloadedStrings #-}
import Language.Dockerfile
main = putStr $ toDockerfileStr $ do
    from "node"
    run "apt-get update"
    runArgs ["apt-get", "install", "something"]
    -- ...

Using the QuasiQuoter

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes       #-}
import Language.Dockerfile
main = putStr $ toDockerfileStr $ do
    from "node"
    run "apt-get update"
    RUN apt-get update
    CMD node something.js
    -- ...

Templating Dockerfiles in Haskell

{-# LANGUAGE FlexibleContexts  #-}
{-# LANGUAGE OverloadedStrings #-}
import Control.Monad
import Language.Dockerfile
tags = ["7.8", "7.10", "8"]
cabalSandboxBuild packageName = do
    let cabalFile = packageName ++ ".cabal"
    run "cabal sandbox init"
    run "cabal update"
    add cabalFile ("/app/" ++ cabalFile)
    run "cabal install --only-dep -j"
    add "." "/app/"
    run "cabal build"
main =
    forM_ tags $ \tag -> do
        let df = toDockerfileStr $ do
            from ("haskell" `tagged` tag)
            cabalSandboxBuild "mypackage"
        writeFile ("./examples/templating-" ++ tag ++ ".dockerfile") df

Using IO in the DSL

By default the DSL runs in the Identity monad. By running in IO we can support more features like file globbing:

{-# LANGUAGE OverloadedStrings #-}
import           Language.Dockerfile
import qualified System.Directory     as Directory
import qualified System.FilePath      as FilePath
import qualified System.FilePath.Glob as Glob
main = do
    str <- toDockerfileStrIO $ do
        fs <- liftIO $ do
            cwd <- Directory.getCurrentDirectory
            fs <- Glob.glob "./test/*.hs"
            return (map (FilePath.makeRelative cwd) fs)
        from "ubuntu"
        mapM_ (\f -> add f ("/app/" ++ FilePath.takeFileName f)) fs
    putStr str