Reformat ihaskell display packages

ihaskell-display/ihaskell-aeson/IHaskell/Display/Aeson.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, QuasiQuotes #-}
+
 module IHaskell.Display.Aeson () where
 
 import           ClassyPrelude

ihaskell-display/ihaskell-basic/IHaskell/Display/Basic.hs

 {-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Basic () where
 
 import           IHaskell.Display
@@ -10,6 +11,9 @@ instance Show a => IHaskellDisplay (Maybe a) where
     where
       stringDisplay = plain (show just)
       htmlDisplay = html str
-      str = case just of
+      str =
+        case just of
           Nothing -> "<span style='color: red; font-weight: bold;'>Nothing</span>"
-        Just x -> printf "<span style='color: green; font-weight: bold;'>Just</span><span style='font-family: monospace;'>%s</span>" (show x)
+          Just x -> printf
+                      "<span style='color: green; font-weight: bold;'>Just</span><span style='font-family: monospace;'>%s</span>"
+                      (show x)

ihaskell-display/ihaskell-blaze/IHaskell/Display/Blaze.hs

 {-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Blaze () where
 
 import           IHaskell.Display

ihaskell-display/ihaskell-charts/IHaskell/Display/Charts.hs

 {-# LANGUAGE NoImplicitPrelude, CPP #-}
+
 module IHaskell.Display.Charts () where
 
 import           ClassyPrelude
@@ -22,8 +23,8 @@ instance IHaskellDisplay (Renderable a) where
   display renderable = do
     pngDisp <- chartData renderable PNG
 
-    -- We can add `svg svgDisplay` to the output of `display`,
-    -- but SVGs are not resizable in the IPython notebook.
+    -- We can add `svg svgDisplay` to the output of `display`, but SVGs are not resizable in the IPython
+    -- notebook.
     svgDisp <- chartData renderable SVG
 
     return $ Display [pngDisp, svgDisp]
@@ -34,17 +35,17 @@ chartData renderable format = do
 
   -- Write the PNG image.
   let filename = ".ihaskell-chart.png"
-      opts = def{_fo_format = format, _fo_size = (width, height)}
-      toFile = renderableToFile opts
-
-#if MIN_VERSION_Chart_cairo(1,3,0)
-  toFile filename renderable
-#else
-  toFile renderable filename
-#endif
+      opts = def { _fo_format = format, _fo_size = (width, height) }
+  mkFile opts filename renderable
 
   -- Convert to base64.
   imgData <- readFile $ fpFromString filename
-  return $ case format of
+  return $
+    case format of
       PNG -> png width height $ base64 imgData
       SVG -> svg $ Char.unpack imgData
+#if MIN_VERSION_Chart_cairo(1,3,0)
+mkFile opts filename renderable = renderableToFile opts filename renderable
+#else
+mkFile opts filename renderable = renderableToFile opts renderable filename
+#endif

ihaskell-display/ihaskell-diagrams/IHaskell/Display/Diagrams.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Diagrams (diagram, animation) where
 
 import           ClassyPrelude
@@ -36,11 +37,13 @@ diagramData renderable format = do
 
   -- Convert to base64.
   imgData <- readFile $ fpFromString filename
-  let value = case format of
+  let value =
+        case format of
           PNG -> png (floor imgWidth) (floor imgHeight) $ base64 imgData
           SVG -> svg $ Char.unpack imgData
 
   return value
+
   where
     extension SVG = "svg"
     extension PNG = "png"

ihaskell-display/ihaskell-diagrams/IHaskell/Display/Diagrams/Animation.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Diagrams.Animation (animation) where
 
 import           ClassyPrelude hiding (filename)
 
 import           Diagrams.Prelude
 import           Diagrams.Backend.Cairo
-import Diagrams.Backend.Cairo.CmdLine (GifOpts (..))
-import Diagrams.Backend.CmdLine (DiagramOpts (..), mainRender)
+import           Diagrams.Backend.Cairo.CmdLine (GifOpts(..))
+import           Diagrams.Backend.CmdLine (DiagramOpts(..), mainRender)
 
 import           IHaskell.Display
 
@@ -37,16 +38,12 @@ animationData renderable = do
 
   -- Write the image.
   let filename = ".ihaskell-diagram.gif"
-      diagOpts = DiagramOpts {
-                             _width = Just . ceiling $ imgWidth
+      diagOpts = DiagramOpts
+        { _width = Just . ceiling $ imgWidth
         , _height = Just . ceiling $ imgHeight
         , _output = filename
         }
-      gifOpts = GifOpts {
-                  _dither = True
-                , _noLooping = False
-                , _loopRepeat = Nothing
-                }
+      gifOpts = GifOpts { _dither = True, _noLooping = False, _loopRepeat = Nothing }
   mainRender (diagOpts, gifOpts) frameSet
 
   -- Convert to ascii represented base64 encoding

ihaskell-display/ihaskell-hatex/IHaskell/Display/Hatex.hs

 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleInstances #-}
+
 -- | Provides 'IHaskellDisplay' instances for 'LaTeX' and 'LaTeXT'.
 module IHaskell.Display.Hatex () where
 

ihaskell-display/ihaskell-juicypixels/IHaskell/Display/Juicypixels.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances #-}
-module IHaskell.Display.Juicypixels 
-     ( module IHaskell.Display
-     , module Codec.Picture
-     ) where
+
+module IHaskell.Display.Juicypixels (module IHaskell.Display, module Codec.Picture) where
 
 import           Codec.Picture
 import           ClassyPrelude
@@ -11,20 +9,47 @@ import System.Directory
 import           System.IO.Unsafe
 
 -- instances
-instance IHaskellDisplay DynamicImage where display = displayImageAsJpg 
-instance IHaskellDisplay (Image Pixel8) where display = displayImageAsJpg . ImageY8
-instance IHaskellDisplay (Image Pixel16) where display = displayImageAsJpg . ImageY16	
-instance IHaskellDisplay (Image PixelF) where display =  displayImageAsJpg . ImageYF
-instance IHaskellDisplay (Image PixelYA8) where display = displayImageAsJpg . ImageYA8
-instance IHaskellDisplay (Image PixelYA16) where display = displayImageAsJpg . ImageYA16
-instance IHaskellDisplay (Image PixelRGB8) where display = displayImageAsJpg . ImageRGB8
-instance IHaskellDisplay (Image PixelRGB16) where display = displayImageAsJpg . ImageRGB16
-instance IHaskellDisplay (Image PixelRGBF) where display =  displayImageAsJpg . ImageRGBF
-instance IHaskellDisplay (Image PixelRGBA8) where display = displayImageAsJpg . ImageRGBA8
-instance IHaskellDisplay (Image PixelRGBA16) where display = displayImageAsJpg . ImageRGBA16	
-instance IHaskellDisplay (Image PixelYCbCr8) where display = displayImageAsJpg . ImageYCbCr8
-instance IHaskellDisplay (Image PixelCMYK8) where display = displayImageAsJpg . ImageCMYK8 
-instance IHaskellDisplay (Image PixelCMYK16) where display = displayImageAsJpg . ImageCMYK16	
+instance IHaskellDisplay DynamicImage where
+  display = displayImageAsJpg
+
+instance IHaskellDisplay (Image Pixel8) where
+  display = displayImageAsJpg . ImageY8
+
+instance IHaskellDisplay (Image Pixel16) where
+  display = displayImageAsJpg . ImageY16
+
+instance IHaskellDisplay (Image PixelF) where
+  display = displayImageAsJpg . ImageYF
+
+instance IHaskellDisplay (Image PixelYA8) where
+  display = displayImageAsJpg . ImageYA8
+
+instance IHaskellDisplay (Image PixelYA16) where
+  display = displayImageAsJpg . ImageYA16
+
+instance IHaskellDisplay (Image PixelRGB8) where
+  display = displayImageAsJpg . ImageRGB8
+
+instance IHaskellDisplay (Image PixelRGB16) where
+  display = displayImageAsJpg . ImageRGB16
+
+instance IHaskellDisplay (Image PixelRGBF) where
+  display = displayImageAsJpg . ImageRGBF
+
+instance IHaskellDisplay (Image PixelRGBA8) where
+  display = displayImageAsJpg . ImageRGBA8
+
+instance IHaskellDisplay (Image PixelRGBA16) where
+  display = displayImageAsJpg . ImageRGBA16
+
+instance IHaskellDisplay (Image PixelYCbCr8) where
+  display = displayImageAsJpg . ImageYCbCr8
+
+instance IHaskellDisplay (Image PixelCMYK8) where
+  display = displayImageAsJpg . ImageCMYK8
+
+instance IHaskellDisplay (Image PixelCMYK16) where
+  display = displayImageAsJpg . ImageCMYK16
 
 -- main rendering function
 displayImageAsJpg :: DynamicImage -> IO Display
@@ -41,11 +66,13 @@ displayImageAsJpg renderable = do
 -- The type DynamicImage does not have a function to extract width and height
 imWidth :: DynamicImage -> Int
 imWidth img = w
-   where (w, h) = imWidthHeight img
+  where
+    (w, h) = imWidthHeight img
 
 imHeight :: DynamicImage -> Int
 imHeight img = h
-   where (w, h) = imWidthHeight img
+  where
+    (w, h) = imWidthHeight img
 
 -- Helper functions to pattern match on the DynamicImage Constructors
 imWidthHeight :: DynamicImage -> (Int, Int)
@@ -65,5 +92,3 @@ imWidthHeight (ImageCMYK16 im) = imWH im
 
 imWH :: (Image a) -> (Int, Int)
 imWH im = (imageWidth im, imageHeight im)
-
-

ihaskell-display/ihaskell-magic/IHaskell/Display/Magic.hs

 {-# LANGUAGE ViewPatterns, TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Magic () where
 
 import           IHaskell.Display
@@ -54,17 +55,20 @@ JPG
 
 -}
 parseMagic :: String -> MagicClass
-parseMagic f = case words f of
-    "SVG" : _ -> SVG
-    "PNG" : _image : _data :
-        (readMaybe -> Just w) : _x :
-        (readMaybe . takeWhile isDigit -> Just h) : _ -> PNG w h
-    "LaTeX" : _ -> LaTeX
-    "HTML" : _ -> HTML
-    "JPEG" : _ -> JPG
+parseMagic f =
+  case words f of
+    "SVG":_                                                                                 -> SVG
+    "PNG":_image:_data:(readMaybe -> Just w):_x:(readMaybe . takeWhile isDigit -> Just h):_ -> PNG w
+                                                                                                 h
+    "LaTeX":_                                                                               -> LaTeX
+    "HTML":_                                                                                -> HTML
+    "JPEG":_                                                                                -> JPG
     _                                                                                       -> Unknown
 
-
-data MagicClass =
-    SVG | PNG Int Int | JPG | HTML | LaTeX | Unknown
+data MagicClass = SVG
+                | PNG Int Int
+                | JPG
+                | HTML
+                | LaTeX
+                | Unknown
   deriving Show

ihaskell-display/ihaskell-parsec/IHaskell/Display/Parsec.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, QuasiQuotes, FlexibleInstances, OverloadedStrings #-}
+
 module IHaskell.Display.Parsec () where
 
 import           ClassyPrelude hiding (fromList)
@@ -29,21 +30,17 @@ instance FromJSON ParseText where
 
 -- | Output of parsing.
 instance Show a => ToJSON (Either ParseError a) where
-  toJSON (Left err) = object [
-                        "status" .= ("error" :: String),
-                        "line" .= sourceLine (errorPos err),
-                        "col" .= sourceColumn (errorPos err),
-                        "msg" .= show err
-                      ]
-  toJSON (Right result) = object [
-                               "status" .= ("success" :: String),
-                               "result" .= show result
+  toJSON (Left err) = object
+                        [ "status" .= ("error" :: String)
+                        , "line" .= sourceLine (errorPos err)
+                        , "col" .= sourceColumn (errorPos err)
+                        , "msg" .= show err
                         ]
+  toJSON (Right result) = object ["status" .= ("success" :: String), "result" .= show result]
 
 instance Show a => IHaskellWidget (Parser a) where
   -- Name for this widget.
   targetName _ = "parsec"
-
   -- When we rece
   comm widget (Object dict) publisher = do
     let key = "text" :: Text

ihaskell-display/ihaskell-rlangqq/IHaskell/Display/Rlangqq.hs

 {-# OPTIONS_GHC -fno-warn-missing-fields #-}
 {-# LANGUAGE TupleSections, TemplateHaskell #-}
-module IHaskell.Display.Rlangqq
-  ( module RlangQQ,
+
+module IHaskell.Display.Rlangqq (
+    module RlangQQ,
     rDisp,
     rDisplayAll,
     rOutputParsed,
@@ -25,7 +26,6 @@ import IHaskell.Display
 import           IHaskell.Display.Blaze () -- to confirm it's installed
 import qualified Text.Blaze.Html5 as H
 import qualified Text.Blaze.Html5.Attributes as H
-import Data.Monoid
 import           Data.Char
 import           Control.Monad
 import           Data.Ord
@@ -40,18 +40,17 @@ import Control.Concurrent.STM
 import           Language.Haskell.TH.Quote
 
 -- | same as 'RlangQQ.r', but displays plots at the end too
-rDisp = QuasiQuoter { quoteExp = \s -> [| do
+rDisp = QuasiQuoter { quoteExp = \s -> [|do
                                            result <- $(quoteExp r s)
                                            p <- rDisplayAll
                                            printDisplay p
-  return result
-  |] }
+                                           return result|] }
 
 rOutput :: IO [Int]
 rOutput = do
   fs <- mapMaybe (readMaybe <=< stripPrefix "raw" <=< stripSuffix ".md")
         <$> getDirectoryContents "Rtmp"
-  fs' <- forM fs $ \f -> (,f) <$> getModificationTime (showf ("Rtmp/raw"%Int%".md") f)
+  fs' <- forM fs $ \f -> (,f) <$> getModificationTime (showf ("Rtmp/raw" % Int % ".md") f)
   return $ map snd $ sortBy (flip (comparing fst)) fs'
 
 -- | like 'stripPrefix' except on the end
@@ -63,35 +62,33 @@ rOutputParsed = do
   ns <- rOutput
   case ns of
     []  -> return []
-    n : _ -> parseKnitted <$> readFile (showf ("Rtmp/raw"%Int%".md") n)
-
+    n:_ -> parseKnitted <$> readFile (showf ("Rtmp/raw" % Int % ".md") n)
 
 getPlotNames :: IO [String]
 getPlotNames = do
   interactions <- rOutputParsed
-  return [ p |  KnitInteraction _ is <- interactions, KnitImage _ p <- is ]
+  return [p | KnitInteraction _ is <- interactions
+            , KnitImage _ p <- is]
 
 getCaptions :: IO [String]
 getCaptions = do
   interactions <- rOutputParsed
-  return [ c |  KnitInteraction _ is <- interactions,
-                KnitImage c _ <- is,
-                not (isBoringCaption c) ]
+  return
+    [c | KnitInteraction _ is <- interactions
+       , KnitImage c _ <- is
+       , not (isBoringCaption c)]
 
--- | true when the caption name looks like one knitr will automatically
--- generate
+-- | true when the caption name looks like one knitr will automatically generate
 isBoringCaption :: String -> Bool
-isBoringCaption s = maybe False
-                      (all isDigit)
-                      (stripPrefix "plot of chunk unnamed-chunk-" s)
+isBoringCaption s = maybe False (all isDigit) (stripPrefix "plot of chunk unnamed-chunk-" s)
 
 rDisplayAll :: IO Display
 rDisplayAll = do
   ns <- rOutputParsed
- imgs <- sequence [ displayInteraction o | KnitInteraction _ os <- ns, o <- os]
+  imgs <- sequence [displayInteraction o | KnitInteraction _ os <- ns
+                                         , o <- os]
   display (mconcat imgs)
 
-
 displayInteraction :: KnitOutput -> IO Display
 displayInteraction (KnitPrint c) = display (plain c)
 displayInteraction (KnitWarning c) = display (plain c)
@@ -102,7 +99,8 @@ displayInteraction (KnitImage cap img) = do
         | isBoringCaption cap = mempty
         | otherwise = H.p (H.toMarkup cap)
   encoded <- Base64.encode <$> B.readFile img
-  display $ H.img H.! H.src (H.unsafeByteStringValue
+  display $ H.img H.! H.src
+                        (H.unsafeByteStringValue
                            -- assumes you use the default device which is png
                            (Char.pack "data:image/png;base64," <> encoded))
             <> caption

ihaskell-display/ihaskell-static-canvas/src/IHaskell/Display/StaticCanvas.hs

@@ -23,10 +23,7 @@ getUniqueName = do
   putMVar uniqueCounter val'
   return $ pack $ "ihaskellStaticCanvasUniqueID" ++ show val
 
-data Canvas = Canvas { width :: Int
-                     , height :: Int
-                     , canvas :: CanvasFree ()
-                     }
+data Canvas = Canvas { width :: Int, height :: Int, canvas :: CanvasFree () }
 
 instance IHaskellDisplay Canvas where
   display cnv = do

ihaskell-display/ihaskell-widgets/IHaskell/Display/Widgets.hs

 {-# LANGUAGE NoImplicitPrelude, OverloadedStrings #-}
+
 module IHaskell.Display.Widgets () where
 
 import           ClassyPrelude
@@ -17,18 +18,19 @@ instance ToJSON WidgetName where
   toJSON ButtonWidget = "ButtonView"
 
 instance ToJSON WidgetMessage where
-  toJSON DisplayWidget = object [ "method" .= str "display" ]
-  toJSON (InitialState name) = object [
-                                  "method" .= str "update",
-                                  "state" .= object [
-                                    "_view_name" .= name,
-                                    "visible" .= True,
-                                    "_css" .= object [],
-                                    "msg_throttle" .= (3 :: Int),
-                                    "disabled" .= False,
-                                    "description" .= str "Button"
+  toJSON DisplayWidget = object ["method" .= str "display"]
+  toJSON (InitialState name) = object
+                                 [ "method" .= str "update"
+                                 , "state" .= object
+                                                [ "_view_name" .= name
+                                                , "visible" .= True
+                                                , "_css" .= object []
+                                                , "msg_throttle" .= (3 :: Int)
+                                                , "disabled" .= False
+                                                , "description" .= str "Button"
                                                 ]
                                  ]
+
 str :: String -> String
 str = id
 
@@ -45,7 +47,6 @@ instance FromJSON ParseText where
 instance IHaskellWidget Slider where
   -- Name for this widget.
   targetName _ = "WidgetModel"
-
   -- Start by sending messages to set up the widget.
   open widget send = do
     putStrLn "Sending widgets!"

ihaskell-display/ihaskell-widgets/IHaskell/Widgets.hs

-module IHaskell.Widgets (
-  Slider(..)
-  ) where
+module IHaskell.Widgets (Slider(..)) where
 
 data Slider = Slider

verify_formatting.py

@@ -44,14 +44,15 @@ except:
 
 # Find all the source files
 sources = []
-for source_dir in ["src", "ipython-kernel"]:
+for source_dir in ["src", "ipython-kernel", "ihaskell-display"]:
     for root, dirnames, filenames in os.walk(source_dir):
         # Skip cabal dist directories
         if "dist" in root:
             continue
 
         for filename in filenames:
-            if filename.endswith(".hs"):
+            # Take Haskell files, but ignore the Cabal Setup.hs
+            if filename.endswith(".hs") and filename != "Setup.hs":
                 sources.append(os.path.join(root, filename))