Skip to content

A peer-to-peer stack for code collaboration

4.1 KB
Raw Blame
{-# LANGUAGE QuasiQuotes #-}

module GithubIssues (main) where

import           Protolude hiding (state)

import qualified Data.Map.Strict as Map
import           Data.Time
import           GitHub.Data.Issues
import           GitHub.Data.Name (Name(..))
import qualified GitHub.Data.Options as GH
import qualified GitHub.Endpoints.Issues as GH
import qualified GitHub.Endpoints.Issues.Comments as GH
import           Options.Applicative

import           Radicle
import           Radicle.TH

main :: IO ()
main = do
  Opts{..} <- execParser allOpts
  let auth = GH.OAuth . toS <$> token
  is_ <- runExceptT (getIssues auth owner repo)
  case is_ of
    Right is -> do
      let t = renderPrettyDef (toRad (uncurry radIssue <$> is) :: Value)
      case output of
        Just file -> writeFile file t
        Nothing   -> putStrLn t
    Left e -> print e
  where
    allOpts = info (opts <**> helper)
        ( fullDesc
       <> progDesc "Exports all issues from a GitHub repo as radicle data."
       <> header "Radicle GitHub issues exporter"
        )

getIssues :: Maybe GH.Auth -> Text -> Text -> ExceptT GH.Error IO [(Issue, [IssueComment])]
getIssues auth owner repo = do
  is <- ExceptT $ GH.issuesForRepo' auth (N owner) (N repo) GH.stateAll
  let issues = filter notPR (toList is)
  css <- traverse (getComments auth owner repo) issues
  -- We reverse to produce a list in chronological order
  pure $ reverse $ zip issues css
  where
    notPR Issue{ issuePullRequest = Nothing} = True
    notPR _                                  = False

getComments :: Maybe GH.Auth -> Text -> Text -> Issue -> ExceptT GH.Error IO [IssueComment]
getComments auth owner repo Issue{..} = do
  -- You would think we should query by issue ID, given the types, but nonono!
  -- That would be too easy!
  -- (This will probably be fixed upstream, soon, by me.)
  cs <- ExceptT $ GH.comments' auth (N owner) (N repo) (GH.mkId (Proxy :: Proxy Issue) issueNumber)
  pure (toList cs)

radIssue :: Issue -> [IssueComment] -> Value
radIssue Issue{..} cs = dict $
    [ ( [kword|github-username|], author issueUser )
    , ( [kword|title|], String issueTitle )
    , ( [kword|body|], mt issueBody )
    , ( [kword|github-assignee-usernames|], toRad $ author <$> toList issueAssignees)
    , ( [kword|state|], state issueState )
    , ( [kword|labels|]
      , toRad $ GH.untagName . GH.labelName <$> toList issueLabels
      )
    , ( [kword|created-at|], date issueCreatedAt )
    , ( [kword|comments|], toRad (radComment <$> cs) )
    ] <> catMaybes
    [ ( [kword|closed-at|],) . date <$> issueClosedAt ]
  where
    mt = String . fromMaybe ""
    state = \case GH.StateOpen -> [kword|open|]
                  GH.StateClosed -> [kword|closed|]

radComment :: IssueComment -> Value
radComment IssueComment{..} = dict
  [ ( [kword|body|], String issueCommentBody )
  , ( [kword|github-username|], author issueCommentUser )
  , ( [kword|created-at|], date issueCommentCreatedAt )
  ]

dict :: [(Value, Value)] -> Value
dict = Dict . Map.fromList

date :: UTCTime -> Value
date = String . toS . formatTime defaultTimeLocale fmt
  where
    fmt = iso8601DateFormat (Just "%H:%M:%SZ")

author :: GH.SimpleUser -> Value
author = String . GH.untagName . GH.simpleUserLogin

-- CLI

data Opts = Opts
    { owner  :: Text
    , repo   :: Text
    , output :: Maybe FilePath
    , token  :: Maybe Text
    }

opts :: Parser Opts
opts = Opts
    <$> strArgument
        ( metavar "OWNER"
        <> help "GitHub owner username."
        )
    <*> strArgument
        ( metavar "REPO"
        <> help "GitHub repo name."
        )
    <*> optional (strOption
        ( long "output"
       <> short 'o'
       <> metavar "FILE"
       <> help "Output file with the GitHub issues as radicle data."
        ))
    <*> optional (strOption
        ( long "token"
       <> short 't'
       <> metavar "TOKEN"
       <> help
           ( "GitHub personal access token. "
          <> "If the repo has a large amount of issues, this will "
          <> "be needed because of rate-limiting. "
          <> "Go to https://github.com/settings/tokens to generate a token."
           )
        ))