Rename Stylish to Step

11 files changed, 66 insertions, 66 deletions

diff --git a/src/Main.hs b/src/Main.hs
index 241fe33..6d44c35 100644
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -45,6 +45,6 @@ main = do
     let verbose'  = makeVerbose (verbose sa)
     conf <- loadConfig verbose' (config sa)
     let filePath  = listToMaybe $ files sa
-        stylish   = configStylish conf
+        steps     = configSteps conf
     contents <- maybe getContents readFile filePath
-    putStr $ unlines $ chainStylish filePath stylish $ lines contents
+    putStr $ unlines $ runSteps filePath steps $ lines contents
diff --git a/src/StylishHaskell.hs b/src/StylishHaskell.hs
index 2aaee95..6cf769b 100644
--- a/src/StylishHaskell.hs
+++ b/src/StylishHaskell.hs
@@ -1,22 +1,22 @@
 --------------------------------------------------------------------------------
 module StylishHaskell
-    ( runStylish
-    , chainStylish
+    ( runStep
+    , runSteps
     ) where
 
 
 --------------------------------------------------------------------------------
 import           StylishHaskell.Parse
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 
 
 --------------------------------------------------------------------------------
-runStylish :: Maybe FilePath -> Stylish -> Lines -> Lines
-runStylish mfp f ls = case parseModule mfp (unlines ls) of
+runStep :: Maybe FilePath -> Step -> Lines -> Lines
+runStep mfp f ls = case parseModule mfp (unlines ls) of
     Left err      -> error err  -- TODO: maybe return original lines?
     Right module' -> f ls module'
 
 
 --------------------------------------------------------------------------------
-chainStylish :: Maybe FilePath -> [Stylish] -> Lines -> Lines
-chainStylish mfp = foldr (flip (.)) id . map (runStylish mfp)
+runSteps :: Maybe FilePath -> [Step] -> Lines -> Lines
+runSteps mfp = foldr (flip (.)) id . map (runStep mfp)
diff --git a/src/StylishHaskell/Config.hs b/src/StylishHaskell/Config.hs
index 186165c..a4da1aa 100644
--- a/src/StylishHaskell/Config.hs
+++ b/src/StylishHaskell/Config.hs
@@ -23,18 +23,18 @@ import           System.FilePath                           ((</>))
 
 
 --------------------------------------------------------------------------------
-import           StylishHaskell.Stylish
-import qualified StylishHaskell.Stylish.Imports            as Imports
-import qualified StylishHaskell.Stylish.LanguagePragmas    as LanguagePragmas
-import qualified StylishHaskell.Stylish.Tabs               as Tabs
-import qualified StylishHaskell.Stylish.TrailingWhitespace as TrailingWhitespace
-import qualified StylishHaskell.Stylish.UnicodeSyntax      as UnicodeSyntax
+import           StylishHaskell.Step
+import qualified StylishHaskell.Step.Imports            as Imports
+import qualified StylishHaskell.Step.LanguagePragmas    as LanguagePragmas
+import qualified StylishHaskell.Step.Tabs               as Tabs
+import qualified StylishHaskell.Step.TrailingWhitespace as TrailingWhitespace
+import qualified StylishHaskell.Step.UnicodeSyntax      as UnicodeSyntax
 import           StylishHaskell.Verbose
 
 
 --------------------------------------------------------------------------------
 data Config = Config
-    { configStylish :: [Stylish]
+    { configSteps :: [Step]
     }
 
 
@@ -46,9 +46,9 @@ instance FromJSON Config where
 --------------------------------------------------------------------------------
 defaultConfig :: Config
 defaultConfig = Config $
-    [ Imports.stylish True
-    , LanguagePragmas.stylish LanguagePragmas.Vertical True
-    , TrailingWhitespace.stylish
+    [ Imports.step True
+    , LanguagePragmas.step LanguagePragmas.Vertical True
+    , TrailingWhitespace.step
     ]
 
 
@@ -95,12 +95,12 @@ loadConfig verbose mfp = do
 --------------------------------------------------------------------------------
 parseConfig :: A.Value -> A.Parser Config
 parseConfig (A.Object o) = Config
-    <$> (o A..: "stylish" >>= fmap concat . mapM parseStylish)
+    <$> (o A..: "steps" >>= fmap concat . mapM parseSteps)
 parseConfig _            = mzero
 
 
 --------------------------------------------------------------------------------
-catalog :: Map String (A.Object -> A.Parser Stylish)
+catalog :: Map String (A.Object -> A.Parser Step)
 catalog = M.fromList
     [ ("imports",             parseImports)
     , ("language_pragmas",    parseLanguagePragmas)
@@ -111,8 +111,8 @@ catalog = M.fromList
 
 
 --------------------------------------------------------------------------------
-parseStylish :: A.Value -> A.Parser [Stylish]
-parseStylish val = do
+parseSteps :: A.Value -> A.Parser [Step]
+parseSteps val = do
     map' <- parseJSON val :: A.Parser (Map String A.Value)
     forM (M.toList map') $ \(k, v) -> case (M.lookup k catalog, v) of
         (Just parser, A.Object o) -> parser o
@@ -130,14 +130,14 @@ parseEnum strs _   (Just k) = case lookup k strs of
 
 
 --------------------------------------------------------------------------------
-parseImports :: A.Object -> A.Parser Stylish
-parseImports o = Imports.stylish
+parseImports :: A.Object -> A.Parser Step
+parseImports o = Imports.step
     <$> o A..:? "align" A..!= True
 
 
 --------------------------------------------------------------------------------
-parseLanguagePragmas :: A.Object -> A.Parser Stylish
-parseLanguagePragmas o = LanguagePragmas.stylish
+parseLanguagePragmas :: A.Object -> A.Parser Step
+parseLanguagePragmas o = LanguagePragmas.step
     <$> (o A..:? "style" >>= parseEnum styles LanguagePragmas.Vertical)
     <*> o A..:? "remove_redundant" A..!= True
   where
@@ -148,16 +148,16 @@ parseLanguagePragmas o = LanguagePragmas.stylish
 
 
 --------------------------------------------------------------------------------
-parseTabs :: A.Object -> A.Parser Stylish
-parseTabs o = Tabs.stylish
+parseTabs :: A.Object -> A.Parser Step
+parseTabs o = Tabs.step
     <$> o A..:? "spaces" A..!= 8
 
 
 --------------------------------------------------------------------------------
-parseTrailingWhitespace :: A.Object -> A.Parser Stylish
-parseTrailingWhitespace _ = return TrailingWhitespace.stylish
+parseTrailingWhitespace :: A.Object -> A.Parser Step
+parseTrailingWhitespace _ = return TrailingWhitespace.step
 
 
 --------------------------------------------------------------------------------
-parseUnicodeSyntax :: A.Object -> A.Parser Stylish
-parseUnicodeSyntax _ = return UnicodeSyntax.stylish
+parseUnicodeSyntax :: A.Object -> A.Parser Step
+parseUnicodeSyntax _ = return UnicodeSyntax.step
diff --git a/src/StylishHaskell/Parse.hs b/src/StylishHaskell/Parse.hs
index 39ac4b2..57179b1 100644
--- a/src/StylishHaskell/Parse.hs
+++ b/src/StylishHaskell/Parse.hs
@@ -10,7 +10,7 @@ import qualified Language.Haskell.Exts.Annotated as H
 
 
 --------------------------------------------------------------------------------
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 
 
 --------------------------------------------------------------------------------
diff --git a/src/StylishHaskell/Stylish.hs b/src/StylishHaskell/Step.hs
index 2e4f863..facf37c 100644
--- a/src/StylishHaskell/Stylish.hs
+++ b/src/StylishHaskell/Step.hs
@@ -1,8 +1,8 @@
 --------------------------------------------------------------------------------
-module StylishHaskell.Stylish
+module StylishHaskell.Step
     ( Lines
     , Module
-    , Stylish
+    , Step
     ) where
 
 
@@ -20,4 +20,4 @@ type Module = (H.Module H.SrcSpanInfo, [H.Comment])
 
 
 --------------------------------------------------------------------------------
-type Stylish = Lines -> Module -> Lines
+type Step = Lines -> Module -> Lines
diff --git a/src/StylishHaskell/Stylish/Imports.hs b/src/StylishHaskell/Step/Imports.hs
index 2adb911..990a2ee 100644
--- a/src/StylishHaskell/Stylish/Imports.hs
+++ b/src/StylishHaskell/Step/Imports.hs
@@ -1,6 +1,6 @@
 --------------------------------------------------------------------------------
-module StylishHaskell.Stylish.Imports
-    ( stylish
+module StylishHaskell.Step.Imports
+    ( step
     ) where
 
 
@@ -16,7 +16,7 @@ import qualified Language.Haskell.Exts.Annotated as H
 --------------------------------------------------------------------------------
 import           StylishHaskell.Block
 import           StylishHaskell.Editor
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 import           StylishHaskell.Util
 
 
@@ -40,10 +40,10 @@ longestImport = maximum . map (length . importName)
 -- | Groups adjacent imports into larger import blocks
 groupAdjacent :: [H.ImportDecl LineBlock]
               -> [(LineBlock, [H.ImportDecl LineBlock])]
-groupAdjacent = foldr step []
+groupAdjacent = foldr go []
   where
     -- This code is ugly and not optimal, and no fucks were given.
-    step imp is = case break (adjacent b1 . fst) is of
+    go imp is = case break (adjacent b1 . fst) is of
         (_, [])                 -> (b1, [imp]) : is
         (xs, ((b2, imps) : ys)) -> (merge b1 b2, imp : imps) : (xs ++ ys)
       where
@@ -106,8 +106,8 @@ prettyImportGroup align longest =
 
 
 --------------------------------------------------------------------------------
-stylish :: Bool -> Stylish
-stylish align ls (module', _) = flip applyChanges ls
+step :: Bool -> Step
+step align ls (module', _) = flip applyChanges ls
     [ change block (prettyImportGroup align longest importGroup)
     | (block, importGroup) <- groups
     ]
diff --git a/src/StylishHaskell/Stylish/LanguagePragmas.hs b/src/StylishHaskell/Step/LanguagePragmas.hs
index 5b82f8d..aff767a 100644
--- a/src/StylishHaskell/Stylish/LanguagePragmas.hs
+++ b/src/StylishHaskell/Step/LanguagePragmas.hs
@@ -1,7 +1,7 @@
 --------------------------------------------------------------------------------
-module StylishHaskell.Stylish.LanguagePragmas
+module StylishHaskell.Step.LanguagePragmas
     ( Style (..)
-    , stylish
+    , step
 
       -- * Utilities
     , addLanguagePragma
@@ -16,7 +16,7 @@ import qualified Language.Haskell.Exts.Annotated as H
 --------------------------------------------------------------------------------
 import           StylishHaskell.Block
 import           StylishHaskell.Editor
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 import           StylishHaskell.Util
 
 
@@ -64,8 +64,8 @@ prettyPragmas Compact  = compactPragmas
 
 
 --------------------------------------------------------------------------------
-stylish :: Style -> Bool -> Stylish
-stylish style removeRedundant ls (module', _)
+step :: Style -> Bool -> Step
+step style removeRedundant ls (module', _)
     | null pragmas' = ls
     | otherwise     = applyChanges changes ls
   where
diff --git a/src/StylishHaskell/Stylish/Tabs.hs b/src/StylishHaskell/Step/Tabs.hs
index b4ad89e..df783e8 100644
--- a/src/StylishHaskell/Stylish/Tabs.hs
+++ b/src/StylishHaskell/Step/Tabs.hs
@@ -1,11 +1,11 @@
 --------------------------------------------------------------------------------
-module StylishHaskell.Stylish.Tabs
-    ( stylish
+module StylishHaskell.Step.Tabs
+    ( step
     ) where
 
 
 --------------------------------------------------------------------------------
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 
 
 --------------------------------------------------------------------------------
@@ -17,5 +17,5 @@ removeTabs spaces = concatMap removeTabs'
 
 
 --------------------------------------------------------------------------------
-stylish :: Int -> Stylish
-stylish spaces ls _ = map (removeTabs spaces) ls
+step :: Int -> Step
+step spaces ls _ = map (removeTabs spaces) ls
diff --git a/src/StylishHaskell/Stylish/TrailingWhitespace.hs b/src/StylishHaskell/Step/TrailingWhitespace.hs
index 92301d4..9239737 100644
--- a/src/StylishHaskell/Stylish/TrailingWhitespace.hs
+++ b/src/StylishHaskell/Step/TrailingWhitespace.hs
@@ -1,6 +1,6 @@
 --------------------------------------------------------------------------------
-module StylishHaskell.Stylish.TrailingWhitespace
-    ( stylish
+module StylishHaskell.Step.TrailingWhitespace
+    ( step
     ) where
 
 
@@ -9,7 +9,7 @@ import           Data.Char            (isSpace)
 
 
 --------------------------------------------------------------------------------
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 
 
 --------------------------------------------------------------------------------
@@ -18,5 +18,5 @@ dropTrailingWhitespace = reverse . dropWhile isSpace . reverse
 
 
 --------------------------------------------------------------------------------
-stylish :: Stylish
-stylish ls _ = map dropTrailingWhitespace ls
+step :: Step
+step ls _ = map dropTrailingWhitespace ls
diff --git a/src/StylishHaskell/Stylish/UnicodeSyntax.hs b/src/StylishHaskell/Step/UnicodeSyntax.hs
index 7ed96e3..d60ee08 100644
--- a/src/StylishHaskell/Stylish/UnicodeSyntax.hs
+++ b/src/StylishHaskell/Step/UnicodeSyntax.hs
@@ -1,7 +1,7 @@
 --------------------------------------------------------------------------------
 {-# LANGUAGE ViewPatterns #-}
-module StylishHaskell.Stylish.UnicodeSyntax
-    ( stylish
+module StylishHaskell.Step.UnicodeSyntax
+    ( step
     ) where
 
 
@@ -16,8 +16,8 @@ import qualified Language.Haskell.Exts.Annotated        as H
 --------------------------------------------------------------------------------
 import           StylishHaskell.Block
 import           StylishHaskell.Editor
-import           StylishHaskell.Stylish
-import           StylishHaskell.Stylish.LanguagePragmas (addLanguagePragma)
+import           StylishHaskell.Step
+import           StylishHaskell.Step.LanguagePragmas (addLanguagePragma)
 import           StylishHaskell.Util
 
 
@@ -119,8 +119,8 @@ between (startRow, startCol) (endRow, endCol) needle =
 
 
 --------------------------------------------------------------------------------
-stylish :: Stylish
-stylish ls (module', _) = applyChanges changes ls
+step :: Step
+step ls (module', _) = applyChanges changes ls
   where
     changes = addLanguagePragma "UnicodeSyntax" module' ++ replaceAll perLine ls
     perLine = sort $ groupPerLine $
diff --git a/src/StylishHaskell/Util.hs b/src/StylishHaskell/Util.hs
index 6154a9d..52e6323 100644
--- a/src/StylishHaskell/Util.hs
+++ b/src/StylishHaskell/Util.hs
@@ -18,7 +18,7 @@ import qualified Language.Haskell.Exts.Annotated as H
 
 
 --------------------------------------------------------------------------------
-import           StylishHaskell.Stylish
+import           StylishHaskell.Step
 
 
 --------------------------------------------------------------------------------