62a30ad · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on golang help sign in

Merge pull request #2553 from purescript/remove-bookmarks

62a30adHarry Garrood10 years ago

psc-docs/Main.hs+2−2

compare with golang

unifiedsplit

@@ -60,8 +60,8 @@ docgen (PSCDocsOptions fmt inputGlob output) = do

60 Etags -> dumpTags input dumpEtags

61 Ctags -> dumpTags input dumpCtags

62 Markdown -> do

63− ms <- runExceptT (D.parseAndBookmark input []

63+ ms <- runExceptT (D.parseFilesInPackages input []

64− >>= (fst >>> D.convertModulesInPackage))

64+ >>= uncurry D.convertModulesInPackage)

65 >>= successOrExit

67 case output of

purescript.cabal+1−1

@@ -268,7 +268,7 @@ library

268 Language.PureScript.Docs.RenderedCode.Types

269 Language.PureScript.Docs.RenderedCode.Render

270 Language.PureScript.Docs.AsMarkdown

271− Language.PureScript.Docs.ParseAndBookmark

271+ Language.PureScript.Docs.ParseInPackage

272 Language.PureScript.Docs.Utils.MonoidExtras

273

274 Language.PureScript.Publish

src/Language/PureScript/Docs.hs+1−1

@@ -8,7 +8,7 @@ module Language.PureScript.Docs (

9import Language.PureScript.Docs.Convert as Docs

10import Language.PureScript.Docs.Prim as Docs

11−import Language.PureScript.Docs.ParseAndBookmark as Docs

11+import Language.PureScript.Docs.ParseInPackage as Docs

12import Language.PureScript.Docs.Render as Docs

13import Language.PureScript.Docs.RenderedCode.Render as Docs

14import Language.PureScript.Docs.RenderedCode.Types as Docs

src/Language/PureScript/Docs/Convert.hs+42−30

@@ -3,28 +3,27 @@

4module Language.PureScript.Docs.Convert

5 ( convertModules

6+ , convertModulesWithEnv

6 , convertModulesInPackage

7 , convertModulesInPackage

7− , collectBookmarks

8+ , convertModulesInPackageWithEnv

8 ) where

9 ) where

10−import Prelude.Compat

11+import Protolude hiding (check)

12−import Control.Arrow ((&&&), second)

13+import Control.Arrow ((&&&))

13import Control.Category ((>>>))

14import Control.Category ((>>>))

14−import Control.Monad

15−import Control.Monad.Error.Class (MonadError)

16−import Control.Monad.State (runStateT)

17import Control.Monad.Writer.Strict (runWriterT)

15import Control.Monad.Writer.Strict (runWriterT)

18−import Data.List (find)

19import qualified Data.Map as Map

16import qualified Data.Map as Map

20−import Data.Text (Text)

17+import Data.String (String)

22import Language.PureScript.Docs.Convert.ReExports (updateReExports)

19import Language.PureScript.Docs.Convert.ReExports (updateReExports)

23−import Language.PureScript.Docs.Convert.Single (convertSingleModule, collectBookmarks)

20+import Language.PureScript.Docs.Convert.Single (convertSingleModule)

24import Language.PureScript.Docs.Types

21import Language.PureScript.Docs.Types

25import qualified Language.PureScript as P

22import qualified Language.PureScript as P

26import qualified Language.PureScript.Constants as C

23import qualified Language.PureScript.Constants as C

25+import Web.Bower.PackageMeta (PackageName)

26+

28import Text.Parsec (eof)

27import Text.Parsec (eof)

30-- |

29-- |

@@ -34,32 +33,36 @@ import Text.Parsec (eof)

34--

33--

35convertModulesInPackage ::

34convertModulesInPackage ::

36 (MonadError P.MultipleErrors m) =>

35 (MonadError P.MultipleErrors m) =>

37− [InPackage P.Module] ->

36+ [P.Module] ->

37+ Map P.ModuleName PackageName ->

38 m [Module]

39−convertModulesInPackage modules =

39+convertModulesInPackage modules modulesDeps =

40+ fmap fst (convertModulesInPackageWithEnv modules modulesDeps)

41+

42+convertModulesInPackageWithEnv ::

43+ (MonadError P.MultipleErrors m) =>

44+ [P.Module] ->

45+ Map P.ModuleName PackageName ->

46+ m ([Module], P.Env)

47+convertModulesInPackageWithEnv modules modulesDeps =

40 go modules

48 go modules

41 where

49 where

42− localNames =

43− map P.getModuleName (takeLocals modules)

44 go =

50 go =

45− map ignorePackage

51+ convertModulesWithEnv withPackage

46− >>> convertModules withPackage

47− >>> fmap (filter ((`elem` localNames) . modName))

52+ >>> fmap (first (filter (isLocal . modName)))

49 withPackage :: P.ModuleName -> InPackage P.ModuleName

54 withPackage :: P.ModuleName -> InPackage P.ModuleName

50 withPackage mn =

55 withPackage mn =

51− case find ((== mn) . P.getModuleName . ignorePackage) modules of

56+ case Map.lookup mn modulesDeps of

52− Just m ->

57+ Just pkgName -> FromDep pkgName mn

53− fmap P.getModuleName m

54− Nothing ->

58+ Nothing -> Local mn

55− P.internalError $ "withPackage: missing module:" ++

59+

56− show (P.runModuleName mn)

60+ isLocal :: P.ModuleName -> Bool

61+ isLocal = not . flip Map.member modulesDeps

58-- |

63-- |

59-- Convert a group of modules to the intermediate format, designed for

64-- Convert a group of modules to the intermediate format, designed for

60−-- producing documentation from. It is also necessary to pass an Env containing

65+-- producing documentation from.

61−-- imports/exports information about the list of modules, which is needed for

62−-- documenting re-exports.

63--

66--

64-- Note that the whole module dependency graph must be included in the list; if

67-- Note that the whole module dependency graph must be included in the list; if

65-- some modules import things from other modules, then those modules must also

68-- some modules import things from other modules, then those modules must also

@@ -75,6 +78,14 @@ convertModules ::

75 [P.Module] ->

78 [P.Module] ->

76 m [Module]

79 m [Module]

77convertModules withPackage =

80convertModules withPackage =

81+ fmap fst . convertModulesWithEnv withPackage

82+

83+convertModulesWithEnv ::

84+ (MonadError P.MultipleErrors m) =>

85+ (P.ModuleName -> InPackage P.ModuleName) ->

86+ [P.Module] ->

87+ m ([Module], P.Env)

88+convertModulesWithEnv withPackage =

78 P.sortModules

89 P.sortModules

79 >>> fmap (fst >>> map importPrim)

90 >>> fmap (fst >>> map importPrim)

80 >=> convertSorted withPackage

91 >=> convertSorted withPackage

@@ -83,21 +94,22 @@ importPrim :: P.Module -> P.Module

83importPrim = P.addDefaultImport (P.ModuleName [P.ProperName C.prim])

94importPrim = P.addDefaultImport (P.ModuleName [P.ProperName C.prim])

85-- |

96-- |

86−-- Convert a sorted list of modules.

97+-- Convert a sorted list of modules, returning both the list of converted

98+-- modules and the Env produced during desugaring.

87--

99--

88convertSorted ::

100convertSorted ::

89 (MonadError P.MultipleErrors m) =>

101 (MonadError P.MultipleErrors m) =>

90 (P.ModuleName -> InPackage P.ModuleName) ->

102 (P.ModuleName -> InPackage P.ModuleName) ->

91 [P.Module] ->

103 [P.Module] ->

92− m [Module]

104+ m ([Module], P.Env)

93convertSorted withPackage modules = do

105convertSorted withPackage modules = do

94 (env, convertedModules) <- second (map convertSingleModule) <$> partiallyDesugar modules

106 (env, convertedModules) <- second (map convertSingleModule) <$> partiallyDesugar modules

107

96 modulesWithTypes <- typeCheckIfNecessary modules convertedModules

108 modulesWithTypes <- typeCheckIfNecessary modules convertedModules

97− let moduleMap = Map.fromList (map (modName &&& id) modulesWithTypes)

109+ let moduleMap = Map.fromList (map (modName &&& identity) modulesWithTypes)

110

99 let traversalOrder = map P.getModuleName modules

111 let traversalOrder = map P.getModuleName modules

100− pure (Map.elems (updateReExports env traversalOrder withPackage moduleMap))

112+ pure (Map.elems (updateReExports env traversalOrder withPackage moduleMap), env)

101

113

102-- |

114-- |

103-- If any exported value declarations have either wildcard type signatures, or

115-- If any exported value declarations have either wildcard type signatures, or

@@ -166,7 +178,7 @@ insertValueTypes env m =

166 other

178 other

167

179

168 parseIdent =

180 parseIdent =

169− either (err . ("failed to parse Ident: " ++)) id . runParser P.parseIdent

181+ either (err . ("failed to parse Ident: " ++)) identity . runParser P.parseIdent

170

182

171 lookupName name =

183 lookupName name =

172 let key = P.Qualified (Just (modName m)) name

184 let key = P.Qualified (Just (modName m)) name

src/Language/PureScript/Docs/Convert/Single.hs−13

@@ -1,6 +1,5 @@

1module Language.PureScript.Docs.Convert.Single

2 ( convertSingleModule

3− , collectBookmarks

4 ) where

3 ) where

6import Protolude

5import Protolude

@@ -184,15 +183,3 @@ convertComments cs = do

184

183

185 dropPrefix prefix str =

184 dropPrefix prefix str =

186 fromMaybe str (T.stripPrefix prefix str)

185 fromMaybe str (T.stripPrefix prefix str)

187−

188−-- | Go through a PureScript module and extract a list of Bookmarks; references

189−-- to data types or values, to be used as a kind of index. These are used for

190−-- generating links in the HTML documentation, for example.

191−collectBookmarks :: InPackage P.Module -> [Bookmark]

192−collectBookmarks (Local m) = map Local (collectBookmarks' m)

193−collectBookmarks (FromDep pkg m) = map (FromDep pkg) (collectBookmarks' m)

194−

195−collectBookmarks' :: P.Module -> [(P.ModuleName, Text)]

196−collectBookmarks' m =

197− map (P.getModuleName m, )

198− (mapMaybe getDeclarationTitle (P.exportedDeclarations m))

src/Language/PureScript/Docs/ParseAndBookmark.hsdeleted−93

@@ -1,93 +0,0 @@

1−module Language.PureScript.Docs.ParseAndBookmark

2− ( parseAndBookmark

3− ) where

4−

5−import Protolude

6−import Prelude (id)

7−

8−import qualified Data.Map as M

9−

10−import Language.PureScript.Docs.Convert (collectBookmarks)

11−import Language.PureScript.Docs.Types

12−import qualified Language.PureScript as P

13−import System.IO.UTF8 (readUTF8FileT)

14−import Web.Bower.PackageMeta (PackageName)

15−

16−-- |

17−-- Given:

18−--

19−-- * A list of local source files

20−-- * A list of source files from external dependencies, together with their

21−-- package names

22−--

23−-- This function does the following:

24−--

25−-- * Parse all of the input and dependency source files

26−-- * Associate each dependency module with its package name, thereby

27−-- distinguishing these from local modules

28−-- * Collect a list of bookmarks from the whole set of source files

29−-- * Return the parsed modules and the bookmarks

30−parseAndBookmark ::

31− (MonadError P.MultipleErrors m, MonadIO m) =>

32− [FilePath]

33− -> [(PackageName, FilePath)]

34− -> m ([InPackage P.Module], [Bookmark])

35−parseAndBookmark inputFiles depsFiles = do

36− inputFiles' <- traverse (parseAs Local) inputFiles

37− depsFiles' <- traverse (\(pkgName, f) -> parseAs (FromDep pkgName) f) depsFiles

38−

39− addBookmarks <$> parseFiles (inputFiles' ++ depsFiles')

40−

41−parseFiles ::

42− (MonadError P.MultipleErrors m) =>

43− [(FileInfo, Text)]

44− -> m [(FileInfo, P.Module)]

45−parseFiles =

46− throwLeft . P.parseModulesFromFiles fileInfoToString

47−

48−addBookmarks ::

49− [(FileInfo, P.Module)]

50− -> ([InPackage P.Module], [Bookmark])

51−addBookmarks msInfo =

52− let

53− msDeps = getDepsModuleNames (map (\(fp, m) -> (,m) <$> fp) msInfo)

54− msPackages = map (addPackage msDeps . snd) msInfo

55− bookmarks = concatMap collectBookmarks msPackages

56− in

57− (msPackages, bookmarks)

58−

59−throwLeft :: (MonadError l m) => Either l r -> m r

60−throwLeft = either throwError return

61−

62−-- | Specifies whether a PureScript source file is considered as:

63−--

64−-- 1) with the `Local` constructor, a target source file, i.e., we want to see

65−-- its modules in the output

66−-- 2) with the `FromDep` constructor, a dependencies source file, i.e. we do

67−-- not want its modules in the output; it is there to enable desugaring, and

68−-- to ensure that links between modules are constructed correctly.

69−type FileInfo = InPackage FilePath

70−

71−fileInfoToString :: FileInfo -> FilePath

72−fileInfoToString (Local fn) = fn

73−fileInfoToString (FromDep _ fn) = fn

74−

75−parseFile :: FilePath -> IO (FilePath, Text)

76−parseFile input' = (,) input' <$> readUTF8FileT input'

77−

78−parseAs :: (MonadIO m) => (FilePath -> a) -> FilePath -> m (a, Text)

79−parseAs g = fmap (first g) . liftIO . parseFile

80−

81−getDepsModuleNames :: [InPackage (FilePath, P.Module)] -> M.Map P.ModuleName PackageName

82−getDepsModuleNames = foldl' go M.empty

83− where

84− go deps p = deps # case p of

85− Local _ -> id

86− FromDep pkgName (_, m) -> M.insert (P.getModuleName m) pkgName

87− (#) = flip ($)

88−

89−addPackage :: M.Map P.ModuleName PackageName -> P.Module -> InPackage P.Module

90−addPackage depsModules m =

91− case M.lookup (P.getModuleName m) depsModules of

92− Just pkgName -> FromDep pkgName m

93− Nothing -> Local m

src/Language/PureScript/Docs/ParseInPackage.hsnew file+73

@@ -0,0 +1,73 @@

1+module Language.PureScript.Docs.ParseInPackage

2+ ( parseFilesInPackages

3+ ) where

5+import Protolude

7+import qualified Data.Map as M

9+import Language.PureScript.Docs.Types

10+import qualified Language.PureScript as P

11+import System.IO.UTF8 (readUTF8FileT)

12+import Web.Bower.PackageMeta (PackageName)

13+

14+-- |

15+-- Given:

16+--

17+-- * A list of local source files

18+-- * A list of source files from external dependencies, together with their

19+-- package names

20+--

21+-- This function does the following:

22+--

23+-- * Parse all of the input and dependency source files

24+-- * Associate each dependency module with its package name, thereby

25+-- distinguishing these from local modules

26+-- * Return the parsed modules and a Map mapping module names to package

27+-- names for modules which come from dependencies. If a module does not

28+-- exist in the map, it can safely be assumed to be local.

29+parseFilesInPackages ::

30+ (MonadError P.MultipleErrors m, MonadIO m) =>

31+ [FilePath]

32+ -> [(PackageName, FilePath)]

33+ -> m ([P.Module], Map P.ModuleName PackageName)

34+parseFilesInPackages inputFiles depsFiles = do

35+ inputFiles' <- traverse (readFileAs . Local) inputFiles

36+ depsFiles' <- traverse (readFileAs . uncurry FromDep) depsFiles

37+

38+ modules <- parse (inputFiles' ++ depsFiles')

39+

40+ let mnMap = M.fromList (mapMaybe (\(inpkg, m) -> (P.getModuleName m,) <$> inPkgToMaybe inpkg) modules)

41+

42+ pure (map snd modules, mnMap)

43+

44+ where

45+ parse ::

46+ (MonadError P.MultipleErrors m) =>

47+ [(FileInfo, Text)]

48+ -> m [(FileInfo, P.Module)]

49+ parse =

50+ throwLeft . P.parseModulesFromFiles fileInfoToString

51+

52+ inPkgToMaybe = \case

53+ Local _ -> Nothing

54+ FromDep pkgName _ -> Just pkgName

55+

56+throwLeft :: (MonadError l m) => Either l r -> m r

57+throwLeft = either throwError return

58+

59+-- | Specifies whether a PureScript source file is considered as:

60+--

61+-- 1) with the `Local` constructor, a target source file, i.e., we want to see

62+-- its modules in the output

63+-- 2) with the `FromDep` constructor, a dependencies source file, i.e. we do

64+-- not want its modules in the output; it is there to enable desugaring, and

65+-- to ensure that links between modules are constructed correctly.

66+type FileInfo = InPackage FilePath

67+

68+fileInfoToString :: FileInfo -> FilePath

69+fileInfoToString (Local fn) = fn

70+fileInfoToString (FromDep _ fn) = fn

71+

72+readFileAs :: (MonadIO m) => FileInfo -> m (FileInfo, Text)

73+readFileAs fi = liftIO . fmap ((fi,)) $ readUTF8FileT (ignorePackage fi)

src/Language/PureScript/Docs/Types.hs+47−29

@@ -4,19 +4,14 @@ module Language.PureScript.Docs.Types

4 )

5 where

7−import Prelude.Compat

7+import Protolude hiding (to, from)

8+import Prelude (String, unlines)

9−import Control.Arrow (first, (***))

10+import Control.Arrow ((***))

10−import Control.Monad (when)

11−import Control.Monad.Error.Class (catchError)

13import Data.Aeson ((.=))

12import Data.Aeson ((.=))

14import Data.Aeson.BetterErrors

13import Data.Aeson.BetterErrors

15−import Data.ByteString.Lazy (ByteString)

14+import qualified Data.Map as Map

16−import Data.Either (isLeft, isRight)

17−import Data.Maybe (mapMaybe, fromMaybe, maybeToList)

18−import Data.Monoid ((<>))

19−import Data.Text (Text)

20import Data.Time.Clock (UTCTime)

15import Data.Time.Clock (UTCTime)

21import qualified Data.Time.Format as TimeFormat

16import qualified Data.Time.Format as TimeFormat

22import Data.Version

17import Data.Version

@@ -47,7 +42,7 @@ data Package a = Package

47 -- field. It should eventually be changed to just UTCTime.

42 -- field. It should eventually be changed to just UTCTime.

48 , pkgTagTime :: Maybe UTCTime

43 , pkgTagTime :: Maybe UTCTime

49 , pkgModules :: [Module]

44 , pkgModules :: [Module]

50− , pkgBookmarks :: [Bookmark]

45+ , pkgModuleMap :: Map P.ModuleName PackageName

51 , pkgResolvedDependencies :: [(PackageName, Version)]

46 , pkgResolvedDependencies :: [(PackageName, Version)]

52 , pkgGithub :: (GithubUser, GithubRepo)

47 , pkgGithub :: (GithubUser, GithubRepo)

53 , pkgUploader :: a

48 , pkgUploader :: a

@@ -70,7 +65,7 @@ verifyPackage verifiedUser Package{..} =

70 pkgVersionTag

65 pkgVersionTag

71 pkgTagTime

66 pkgTagTime

72 pkgModules

67 pkgModules

73− pkgBookmarks

68+ pkgModuleMap

74 pkgResolvedDependencies

69 pkgResolvedDependencies

75 pkgGithub

70 pkgGithub

76 verifiedUser

71 verifiedUser

@@ -308,8 +303,6 @@ data PackageError

308 | InvalidTime

303 | InvalidTime

309 deriving (Show, Eq, Ord)

304 deriving (Show, Eq, Ord)

310

305

311−type Bookmark = InPackage (P.ModuleName, Text)

312−

313data InPackage a

306data InPackage a

314 = Local a

307 = Local a

315 | FromDep PackageName a

308 | FromDep PackageName a

@@ -333,10 +326,10 @@ ignorePackage (FromDep _ x) = x

333----------------------

326----------------------

334-- Parsing

327-- Parsing

335

328

336−parseUploadedPackage :: Version -> ByteString -> Either (ParseError PackageError) UploadedPackage

329+parseUploadedPackage :: Version -> LByteString -> Either (ParseError PackageError) UploadedPackage

337parseUploadedPackage minVersion = parse $ asUploadedPackage minVersion

330parseUploadedPackage minVersion = parse $ asUploadedPackage minVersion

338

331

339−parseVerifiedPackage :: Version -> ByteString -> Either (ParseError PackageError) VerifiedPackage

332+parseVerifiedPackage :: Version -> LByteString -> Either (ParseError PackageError) VerifiedPackage

340parseVerifiedPackage minVersion = parse $ asVerifiedPackage minVersion

333parseVerifiedPackage minVersion = parse $ asVerifiedPackage minVersion

341

334

342asPackage :: Version -> (forall e. Parse e a) -> Parse PackageError (Package a)

335asPackage :: Version -> (forall e. Parse e a) -> Parse PackageError (Package a)

@@ -353,11 +346,15 @@ asPackage minimumVersion uploader = do

353 <*> key "versionTag" asText

346 <*> key "versionTag" asText

354 <*> keyMay "tagTime" (withString parseTimeEither)

347 <*> keyMay "tagTime" (withString parseTimeEither)

355 <*> key "modules" (eachInArray asModule)

348 <*> key "modules" (eachInArray asModule)

356− <*> key "bookmarks" asBookmarks .! ErrorInPackageMeta

349+ <*> moduleMap

357 <*> key "resolvedDependencies" asResolvedDependencies

350 <*> key "resolvedDependencies" asResolvedDependencies

358 <*> key "github" asGithub

351 <*> key "github" asGithub

359 <*> key "uploader" uploader

352 <*> key "uploader" uploader

360 <*> pure compilerVersion

353 <*> pure compilerVersion

354+ where

355+ moduleMap =

356+ key "moduleMap" asModuleMap

357+ `pOr` (key "bookmarks" bookmarksAsModuleMap .! ErrorInPackageMeta)

361

358

362parseTimeEither :: String -> Either PackageError UTCTime

359parseTimeEither :: String -> Either PackageError UTCTime

363parseTimeEither =

360parseTimeEither =

@@ -444,9 +441,10 @@ asReExport =

444 asReExportModuleName :: Parse PackageError (InPackage P.ModuleName)

441 asReExportModuleName :: Parse PackageError (InPackage P.ModuleName)

445 asReExportModuleName =

442 asReExportModuleName =

446 asInPackage fromAesonParser .! ErrorInPackageMeta

443 asInPackage fromAesonParser .! ErrorInPackageMeta

447− <|> fmap Local fromAesonParser

444+ `pOr` fmap Local fromAesonParser

448

445

446+pOr :: Parse e a -> Parse e a -> Parse e a

449− (<|>) p q = catchError p (const q)

447+p `pOr` q = catchError p (const q)

450

448

451asInPackage :: Parse BowerError a -> Parse BowerError (InPackage a)

449asInPackage :: Parse BowerError a -> Parse BowerError (InPackage a)

452asInPackage inner =

450asInPackage inner =

@@ -559,20 +557,38 @@ asQualifiedProperName = fromAesonParser

559asQualifiedIdent :: Parse e (P.Qualified P.Ident)

557asQualifiedIdent :: Parse e (P.Qualified P.Ident)

560asQualifiedIdent = fromAesonParser

558asQualifiedIdent = fromAesonParser

561

559

562−asBookmarks :: Parse BowerError [Bookmark]

560+asModuleMap :: Parse PackageError (Map P.ModuleName PackageName)

563−asBookmarks = eachInArray asBookmark

561+asModuleMap =

562+ Map.fromList <$>

563+ eachInObjectWithKey (Right . P.moduleNameFromString)

564+ (withText parsePackageName')

565+

566+-- This is here to preserve backwards compatibility with compilers which used

567+-- to generate a 'bookmarks' field in the JSON (i.e. up to 0.10.5). We should

568+-- remove this after the next breaking change to the JSON.

569+bookmarksAsModuleMap :: Parse BowerError (Map P.ModuleName PackageName)

570+bookmarksAsModuleMap =

571+ convert <$>

572+ eachInArray (asInPackage (nth 0 (P.moduleNameFromString <$> asText)))

573+

574+ where

575+ convert :: [InPackage P.ModuleName] -> Map P.ModuleName PackageName

576+ convert = Map.fromList . mapMaybe toTuple

564

577

565−asBookmark :: Parse BowerError Bookmark

578+ toTuple (Local _) = Nothing

566−asBookmark =

579+ toTuple (FromDep pkgName mn) = Just (mn, pkgName)

567− asInPackage ((,) <$> nth 0 (P.moduleNameFromString <$> asText)

568− <*> nth 1 asText)

569

580

570asResolvedDependencies :: Parse PackageError [(PackageName, Version)]

581asResolvedDependencies :: Parse PackageError [(PackageName, Version)]

571asResolvedDependencies =

582asResolvedDependencies =

583+ eachInObjectWithKey parsePackageName' asVersion

584+

585+parsePackageName' :: Text -> Either PackageError PackageName

586+parsePackageName' =

572− eachInObjectWithKey (mapLeft ErrorInPackageMeta . parsePackageName) asVersion

587+ mapLeft ErrorInPackageMeta . parsePackageName

573− where

588+

589+mapLeft :: (a -> a') -> Either a b -> Either a' b

574− mapLeft f (Left x) = Left (f x)

590+mapLeft f (Left x) = Left (f x)

575− mapLeft _ (Right x) = Right x

591+mapLeft _ (Right x) = Right x

576

592

577asGithub :: Parse e (GithubUser, GithubRepo)

593asGithub :: Parse e (GithubUser, GithubRepo)

578asGithub = (,) <$> nth 0 (GithubUser <$> asText)

594asGithub = (,) <$> nth 0 (GithubUser <$> asText)

@@ -593,7 +609,9 @@ instance A.ToJSON a => A.ToJSON (Package a) where

593 , "version" .= showVersion pkgVersion

609 , "version" .= showVersion pkgVersion

594 , "versionTag" .= pkgVersionTag

610 , "versionTag" .= pkgVersionTag

595 , "modules" .= pkgModules

611 , "modules" .= pkgModules

596− , "bookmarks" .= map (fmap (first P.runModuleName)) pkgBookmarks

612+ , "moduleMap" .= assocListToJSON P.runModuleName

613+ runPackageName

614+ (Map.toList pkgModuleMap)

597 , "resolvedDependencies" .= assocListToJSON runPackageName

615 , "resolvedDependencies" .= assocListToJSON runPackageName

598 (T.pack . showVersion)

616 (T.pack . showVersion)

599 pkgResolvedDependencies

617 pkgResolvedDependencies

src/Language/PureScript/Publish.hs+14−27

@@ -16,30 +16,23 @@ module Language.PureScript.Publish

16 , checkCleanWorkingTree

17 , getVersionFromGitTag

18 , getBowerRepositoryInfo

19− , getModulesAndBookmarks

19+ , getModules

20 , getResolvedDependencies

21 ) where

23−import Prelude ()

23+import Protolude hiding (stdin)

24−import Prelude.Compat hiding (userError)

26−import Control.Arrow ((***), first)

25+import Control.Arrow ((***))

27import Control.Category ((>>>))

26import Control.Category ((>>>))

28−import Control.Exception (catch, try)

29−import Control.Monad.Error.Class (MonadError(..))

30−import Control.Monad.Trans.Except

31import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)

27import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)

32−import Control.Monad.Writer.Strict

28+import Control.Monad.Writer.Strict (MonadWriter, WriterT, runWriterT, tell)

34import Data.Aeson.BetterErrors

30import Data.Aeson.BetterErrors

35import Data.Char (isSpace)

31import Data.Char (isSpace)

36−import Data.Foldable (traverse_)

32+import Data.String (String, lines)

37−import Data.Function (on)

38import Data.List (stripPrefix, (\\), nubBy)

33import Data.List (stripPrefix, (\\), nubBy)

39import Data.List.NonEmpty (NonEmpty(..))

34import Data.List.NonEmpty (NonEmpty(..))

40import Data.List.Split (splitOn)

35import Data.List.Split (splitOn)

41−import Data.Maybe

42−import Data.Text (Text)

43import qualified Data.Text as T

36import qualified Data.Text as T

44import qualified Data.Text.Lazy as TL

37import qualified Data.Text.Lazy as TL

45import qualified Data.Text.Lazy.Encoding as TL

38import qualified Data.Text.Lazy.Encoding as TL

@@ -47,10 +40,7 @@ import Data.Time.Clock (UTCTime)

47import Data.Version

40import Data.Version

48import qualified Data.SPDX as SPDX

41import qualified Data.SPDX as SPDX

50−import Safe (headMay)

51−

52import System.Directory (doesFileExist, findExecutable)

43import System.Directory (doesFileExist, findExecutable)

53−import System.Exit (exitFailure)

54import System.FilePath (pathSeparator)

44import System.FilePath (pathSeparator)

55import System.Process (readProcess)

45import System.Process (readProcess)

56import qualified System.FilePath.Glob as Glob

46import qualified System.FilePath.Glob as Glob

@@ -61,7 +51,7 @@ import qualified Web.Bower.PackageMeta as Bower

62import Language.PureScript.Publish.ErrorsWarnings

52import Language.PureScript.Publish.ErrorsWarnings

63import Language.PureScript.Publish.Utils

53import Language.PureScript.Publish.Utils

64−import qualified Language.PureScript as P (version)

54+import qualified Language.PureScript as P (version, ModuleName)

65import qualified Language.PureScript.Docs as D

55import qualified Language.PureScript.Docs as D

67data PublishOptions = PublishOptions

57data PublishOptions = PublishOptions

@@ -129,9 +119,6 @@ otherError = throwError . OtherError

129catchLeft :: Applicative f => Either a b -> (a -> f b) -> f b

119catchLeft :: Applicative f => Either a b -> (a -> f b) -> f b

130catchLeft a f = either f pure a

120catchLeft a f = either f pure a

131

121

132−unlessM :: Monad m => m Bool -> m () -> m ()

133−unlessM cond act = cond >>= flip unless act

134−

135preparePackage' :: PublishOptions -> PrepareM D.UploadedPackage

122preparePackage' :: PublishOptions -> PrepareM D.UploadedPackage

136preparePackage' opts = do

123preparePackage' opts = do

137 unlessM (liftIO (doesFileExist "bower.json")) (userError BowerJSONNotFound)

124 unlessM (liftIO (doesFileExist "bower.json")) (userError BowerJSONNotFound)

@@ -144,7 +131,7 @@ preparePackage' opts = do

144 (pkgVersionTag, pkgVersion) <- publishGetVersion opts

131 (pkgVersionTag, pkgVersion) <- publishGetVersion opts

145 pkgTagTime <- Just <$> publishGetTagTime opts pkgVersionTag

132 pkgTagTime <- Just <$> publishGetTagTime opts pkgVersionTag

146 pkgGithub <- getBowerRepositoryInfo pkgMeta

133 pkgGithub <- getBowerRepositoryInfo pkgMeta

147− (pkgBookmarks, pkgModules) <- getModulesAndBookmarks

134+ (pkgModules, pkgModuleMap) <- getModules

148

135

149 let declaredDeps = map fst (bowerDependencies pkgMeta ++

136 let declaredDeps = map fst (bowerDependencies pkgMeta ++

150 bowerDevDependencies pkgMeta)

137 bowerDevDependencies pkgMeta)

@@ -155,18 +142,18 @@ preparePackage' opts = do

155

142

156 return D.Package{..}

143 return D.Package{..}

157

144

158−getModulesAndBookmarks :: PrepareM ([D.Bookmark], [D.Module])

145+getModules :: PrepareM ([D.Module], Map P.ModuleName PackageName)

159−getModulesAndBookmarks = do

146+getModules = do

160 (inputFiles, depsFiles) <- liftIO getInputAndDepsFiles

147 (inputFiles, depsFiles) <- liftIO getInputAndDepsFiles

161− (modules', bookmarks) <- parseAndBookmark inputFiles depsFiles

148+ (modules', moduleMap) <- parseFilesInPackages inputFiles depsFiles

162

149

163− case runExcept (D.convertModulesInPackage modules') of

150+ case runExcept (D.convertModulesInPackage modules' moduleMap) of

164− Right modules -> return (bookmarks, modules)

151+ Right modules -> return (modules, moduleMap)

165 Left err -> userError (CompileError err)

152 Left err -> userError (CompileError err)

166

153

167 where

154 where

168− parseAndBookmark inputFiles depsFiles = do

155+ parseFilesInPackages inputFiles depsFiles = do

169− r <- liftIO . runExceptT $ D.parseAndBookmark inputFiles depsFiles

156+ r <- liftIO . runExceptT $ D.parseFilesInPackages inputFiles depsFiles

170 case r of

157 case r of

171 Right r' ->

158 Right r' ->

172 return r'

159 return r'