Add initial cut of determining whether a file is a shell file.

I'm hoping the algorithm in the code itself should be quite
self-explanatory but here it is anyway.

- If the file has a .sh extension then it is a shell file.
- If the file has no extension and a whitelisted interpretter, then
  it is a shell file.
- Else it is not a shell file.

Author: philipcunningham

codeclimate-shellcheck.cabal

@@ -26,10 +26,12 @@ executable engine
     CC.Types
   build-depends:
       aeson      >= 0.9.0.1  && <= 0.10.0.0
+    , attoparsec >= 0.13.0.0 && <= 0.14.0.0
     , base       >= 4.7      && <= 5
     , containers >= 0.5.6.0  && <= 0.5.7.0
     , bytestring >= 0.10.4.0 && <= 0.11.0.0
     , directory  >= 1.2.1.0  && <= 1.3.0.0
+    , filepath   >= 1.3.0.0  && <= 1.4.0.0
     , Glob       >= 0.7.5    && <= 0.8.0
     , ShellCheck >= 0.4.1    && <= 0.5.0
     , text       >= 1.1.0.0  && <= 1.2.1.3

src/CC/Types.hs

@@ -7,6 +7,7 @@ module CC.Types where
 import           Control.Applicative
 import           Data.Aeson
 import           Data.Aeson.Types
+import qualified Data.ByteString as BS
 import qualified Data.Map.Strict as DM
 import qualified Data.Text as T
 import           GHC.Generics
@@ -148,3 +149,8 @@ instance FromJSON Mapping where
 -- | An env represents mappings between check names, content and remediation
 -- values.
 type Env = DM.Map T.Text Mapping
+
+--------------------------------------------------------------------------------
+
+-- | Represents a Linux shebang, i.e. #!interpreter [optional-arg].
+data Shebang = Shebang BS.ByteString BS.ByteString

src/Main.hs

@@ -5,21 +5,25 @@ module Main where
 import           CC.Analyze
 import           CC.Types
 import           Data.Aeson
+import           Data.Attoparsec.ByteString.Lazy
+import qualified Data.ByteString as BS
 import qualified Data.ByteString.Lazy as BSL
 import qualified Data.Map.Strict as DM
 import           Data.Maybe
 import           Data.Monoid
+import           Data.Word
 import qualified Data.Yaml as YML
 import           System.Directory
 import           System.FilePath.Glob
+import           System.FilePath.Posix
 
 --------------------------------------------------------------------------------
 
 main :: IO ()
 main = do
   config <- loadConfig "/config.json"
   env <- fromMaybe DM.empty <$> YML.decodeFile "data/mapping.yml"
-  paths <- shFiles $! _include_paths config
+  paths <- shellScripts $! _include_paths config
   issues <- analyzeFiles env paths
   mapM_ printIssue issues
 
@@ -38,9 +42,83 @@ printIssue = BSL.putStr . (<> "\0") . encode
 
 --------------------------------------------------------------------------------
 
-shFiles :: [FilePath] -> IO [FilePath]
-shFiles paths =
+shellScripts :: [FilePath] -> IO [FilePath]
+shellScripts paths =
   fmap concat $! sequence $! fmap (matched . globDir [compile "**/*.sh"]) paths
   where
     matched :: Functor f => f ([[a]], [b]) -> f [a]
     matched x = (concat . fst) <$> x
+
+--------------------------------------------------------------------------------
+
+-- | Determines whether a file is a shell script that we can work with.
+isShellScript :: FilePath -> IO Bool
+isShellScript path =
+  if hasExtension path
+    then return hasShellExtension
+    else do
+      header <- readHeader
+      if hasShebang header
+        then case readShebang header of
+          Just (Shebang x y) -> return $ hasValidInterpretter x y
+          Nothing            -> return False
+        else return False
+  where
+    ----------------------------------------------------------------------------
+
+    carriageReturn :: Word8 -> Bool
+    carriageReturn = (== 13)
+
+    endOfLine :: Word8 -> Bool
+    endOfLine x = newline x || carriageReturn x
+
+    newline :: Word8 -> Bool
+    newline = (== 10)
+
+    whitespace :: Word8 -> Bool
+    whitespace = (== 32)
+
+    ----------------------------------------------------------------------------
+
+    whiteList :: [BS.ByteString]
+    whiteList = [ "sh"
+                , "ash"
+                , "dash"
+                , "bash"
+                , "ksh"
+                ]
+
+    ----------------------------------------------------------------------------
+
+    hasShebang :: BSL.ByteString -> Bool
+    hasShebang x = BSL.take 2 x == "#!"
+
+    hasShellExtension :: Bool
+    hasShellExtension = takeExtension path == ".sh"
+
+    hasValidInterpretter :: BS.ByteString -> BS.ByteString -> Bool
+    hasValidInterpretter interpretter arguments =
+      if BS.isSuffixOf "env" interpretter
+        then any (`BS.isPrefixOf` arguments) whiteList
+        else any (`BS.isSuffixOf` interpretter) whiteList
+
+    ----------------------------------------------------------------------------
+
+    readHeader :: IO BSL.ByteString
+    readHeader = do
+      contents <- BSL.readFile path
+      return $ BSL.takeWhile (not . endOfLine) contents
+
+    readShebang :: BSL.ByteString -> Maybe Shebang
+    readShebang x = maybeResult $ parse shebang x
+
+    ----------------------------------------------------------------------------
+
+    shebang :: Parser Shebang
+    shebang = do
+      _            <- string "#!"
+      interpretter <- takeTill whitespace
+      arguments    <- option "" $ do
+        _ <- string " "
+        takeTill endOfLine
+      return $ Shebang interpretter arguments

test/example

@@ -0,0 +1,7 @@
+#!/bin/sh
+## Example of a broken script. Hit the Down Arrow button to ShellCheck it!
+for f in $(ls *.m3u)
+do
+  grep -qi hq.*mp3 $f \
+    && echo -e 'Playlist $f contains a HQ file in mp3 format'
+done