|
sourcecode:
|
module ERD2Curry
( main, startWithERD, EROptions(..), defaultEROptions
, erd2CDBI, erd2curryWithDBandERD )
where
import Control.Monad ( when, unless )
import Data.List ( isSuffixOf )
import System.Environment ( getArgs, setEnv )
import AbstractCurry.Files ( readCurry )
import AbstractCurry.Select ( imports )
import AbstractCurry.Pretty
import AbstractCurry.Transform ( renameCurryModule )
import Database.ERD
import Data.Time
import System.Directory ( doesFileExist, getModificationTime )
import System.Process ( exitWith, system )
import XML ( readXmlFile )
import Database.ERD.FromXML
import Database.ERD.Goodies
import Database.ERD.ToCDBI ( writeCDBI )
import Database.ERD.ToKeyDB
import Database.ERD.Transformation
import Database.ERD.View ( viewERD )
import ERToolsPackageConfig ( packagePath, packageVersion, packageLoadPath )
systemBanner :: String
systemBanner =
let bannerText = "ERD->Curry Compiler (Version " ++ packageVersion ++
" of 14/12/23)"
bannerLine = take (length bannerText) (repeat '-')
in bannerLine ++ "\n" ++ bannerText ++ "\n" ++ bannerLine
data EROptions = EROptions
{ optERProg :: String -- Curry program containing ERD
, optFromXml :: Bool -- read ERD from XML file?
, optVisualize :: Bool -- visualize ERD?
, optStorage :: Storage -- storage of data
, optToERDT :: Bool -- only transform into ERDT term file
, optCDBI :: Bool -- generate Curry for Database.CDBI libraries
, optModule :: String -- name of generated Curry module
, optFile :: String -- file to store generated Curry module
}
defaultEROptions :: EROptions
defaultEROptions = EROptions
{ optERProg = ""
, optFromXml = False
, optVisualize = False
, optStorage = SQLite ""
, optToERDT = False
, optCDBI = False
, optModule = ""
, optFile = ""
}
--- Main function for saved state. The argument is the directory containing
--- these sources.
main :: IO ()
main = do
putStrLn systemBanner
args <- getArgs
configs <- parseArgs defaultEROptions args
startERD2Curry configs
parseArgs :: EROptions -> [String] -> IO (Maybe EROptions)
parseArgs _ [] = return Nothing
parseArgs opts (arg:args) = case arg of
"-h" -> putStrLn helpText >> exitWith 0
"-?" -> putStrLn helpText >> exitWith 0
"--help" -> putStrLn helpText >> exitWith 0
"-x" -> parseArgs opts { optFromXml = True } args
"-l" -> parseArgs (setSQLite (optStorage opts)) args
"-d" -> parseArgs opts { optStorage = DB } args
"--db" -> if null args
then return Nothing
else parseArgs (setFilePath (head args) (optStorage opts))
(tail args)
"-t" -> parseArgs opts { optToERDT = True } args
"-v" -> parseArgs opts { optVisualize = True } args
"--cdbi" -> parseArgs opts { optCDBI = True } args
"--module" -> if null args
then return Nothing
else parseArgs opts { optModule = head args } (tail args)
"--outfile"-> if null args
then return Nothing
else parseArgs opts { optFile = head args } (tail args)
f -> return $ if null args then Just opts { optERProg = f }
else Nothing
where
setFilePath path (Files _) = opts { optStorage = Files path }
setFilePath path (SQLite _) = opts { optStorage = SQLite path }
setFilePath _ DB = opts { optStorage = DB }
setSQLite (Files p) = opts { optStorage = SQLite p }
setSQLite (SQLite p) = opts { optStorage = SQLite p }
setSQLite DB = opts { optStorage = SQLite "" }
storagePath :: Storage -> String
storagePath (Files p) = p
storagePath (SQLite p) = p
storagePath DB = ""
helpText :: String
helpText = unlines
[ ""
, "Usage:"
, ""
, " erd2curry <options> <prog>"
, ""
, "with options:"
, ""
, "-l : generate interface to SQLite3 database (default)"
, "-d : generate interface to SQL database (experimental)"
, "-x : generate from ERD xmi document instead of ERD Curry program"
, "-t : only transform ERD into ERDT term file"
, "-v : only show visualization of ERD with dotty"
, "--db <dbfile>: file of the SQLite3 database"
, "--cdbi : generate Curry module for Database.CDBI modules"
, "--module <m> : name of generated Curry module (default: <ERD name>)"
, "--outfile <f>: file to store the generated module (default: <ERD name>.curry)"
, "<prog> : name of Curry program file containing ERD definition"
]
--- Runs ERD2Curry with a given database and ERD program.
erd2curryWithDBandERD :: String -> String -> IO ()
erd2curryWithDBandERD dbname erfile =
startERD2Curry
(Just defaultEROptions
{ optStorage = SQLite dbname, optERProg = erfile })
--- Translate an ERD into a Curry program using the API provided by the
--- Curry package `cdbi`. The parameters are the name of the database,
--- the name of the Curry program containing the ERD (only used in
--- a comment of the generated program), and the ERD definition.
--- The generated Curry module has the name of the ERD and
--- is put into the current directory.
erd2CDBI :: String -> String -> ERD -> IO ()
erd2CDBI dbname erdfile erd =
startWithERD
(defaultEROptions { optStorage = SQLite dbname, optCDBI = True })
erdfile
erd
startERD2Curry :: Maybe EROptions -> IO ()
startERD2Curry Nothing = do
putStrLn $ "ERROR: Illegal arguments\n\n" ++ helpText
exitWith 1
startERD2Curry (Just opts) = do
-- set CURRYPATH in order to compile ERD model (which requires Database.ERD)
unless (null packageLoadPath) $ setEnv "CURRYPATH" packageLoadPath
-- the directory containing the sources of this tool:
let orgfile = optERProg opts
if optFromXml opts
then do (_,erd) <- transformXmlFile orgfile
startWithERD opts orgfile erd
else do
unless (".curry" `isSuffixOf` orgfile ||
".lcurry" `isSuffixOf` orgfile) $ do
putStrLn $ "ERROR: '" ++ orgfile ++ "' is not a Curry program file!"
exitWith 1
if optVisualize opts
then readERDFromProgram orgfile >>= viewERD
else readERDFromProgram orgfile >>= startWithERD opts orgfile
--- Main function to invoke the ERD->Curry translator.
--- The parameters are the tool options,
--- the name of the Curry program containing the ERD (only used in
--- a comment of the generated program), and the ERD definition.
--- If not changed by specific options, the generated Curry module
--- has the name of the ERD and is put into the current directory.
startWithERD :: EROptions -> String -> ERD -> IO ()
startWithERD opts srcfile erd = do
let erdname = erdName erd
transerdfile = erdname ++ "_ERDT.term"
curryfile = if null (optFile opts) then erdname ++ ".curry"
else optFile opts
transerd = transform erd
opt = ( if optStorage opts == SQLite ""
then SQLite (erdname ++ ".db")
else optStorage opts
, WithConsistencyTest )
erdprog = let prog = erd2code opt (transform erd)
in if null (optModule opts)
then prog
else renameCurryModule (optModule opts) prog
writeFile transerdfile $
"{- ERD specification transformed from " ++ srcfile ++ " -}\n\n " ++
showERD 2 transerd ++ "\n"
putStrLn $ "Transformed ERD term written into file '" ++ transerdfile ++ "'."
when (optCDBI opts) $
writeCDBI srcfile curryfile
(if null (optModule opts) then erdname else optModule opts)
transerd (storagePath (fst opt))
unless (optToERDT opts || optCDBI opts) $ do
moveOldVersion curryfile
impprogs <- mapM readCurry (imports erdprog)
writeFile curryfile $
prettyCurryProg
(setOnDemandQualification (erdprog:impprogs) defaultOptions)
erdprog
putStrLn $ unlines
[ "Database operations generated into file '" ++ curryfile ++ "'"
, "with " ++ showOption opt ++ "."
, "NOTE: To compile this module, use packages " ++
"'keydb', 'ertools' and 'time'." ]
where
showOption (Files f,_) = "database files stored in directory '"++f++"'"
showOption (SQLite f,_) =
"SQLite3 database stored in file '" ++ f ++ "'"
showOption (DB,_) = "SQL database interface"
--- Moves a file (if it exists) to one with extension ".versYYMMDDhhmmss".
moveOldVersion :: String -> IO ()
moveOldVersion fname = do
exists <- doesFileExist fname
if exists
then do
mtime <- getModificationTime fname
cmtime <- toCalendarTime mtime
let fnamevers = fname ++ ".vers" ++ calTime2Digits cmtime
system $ "mv "++fname++" "++fnamevers
putStrLn $ "Old contents of file \""++fname++"\" saved into file \""++
fnamevers++"\"."
else return ()
where
calTime2Digits (CalendarTime y mo d h mi s _) =
toD (y `mod` 100) ++ toD mo ++ toD d ++ toD h ++ toD mi ++ toD s
toD i = if i<10 then '0':show i else show i
--- Read an ERD specification from an XML file in Umbrello format.
transformXmlFile :: String -> IO (String,ERD)
transformXmlFile xmlfile = do
putStrLn $ "Reading XML file " ++ xmlfile ++ "..."
xml <- readXmlFile xmlfile
let erd = convert xml
let erdfile = erdName erd ++ "_ERD.term"
writeFile erdfile
("{- ERD specification read from "++xmlfile++" -}\n\n " ++
showERD 2 erd ++ "\n")
putStrLn $ "ERD term written into file \""++erdfile++"\"."
return (erdfile,erd)
{-
-- Uni.xmi -> ERD term:
(ERD "Uni"
[(Entity "Student" [(Attribute "MatNum" (IntDom Nothing) PKey False),
(Attribute "Name" (StringDom Nothing) NoKey False),
(Attribute "Firstname" (StringDom Nothing) NoKey False),
(Attribute "Email" (UserDefined "MyModule.Email" Nothing) NoKey True)]),
(Entity "Lecture" [(Attribute "Id" (IntDom Nothing) PKey False),
(Attribute "Title" (StringDom Nothing) Unique False),
(Attribute "Hours" (IntDom (Just 4)) NoKey False)]),
(Entity "Lecturer" [(Attribute "Id" (IntDom Nothing) PKey False),
(Attribute "Name" (StringDom Nothing) NoKey False),
(Attribute "Firstname" (StringDom Nothing) NoKey False)]),
(Entity "Group" [(Attribute "Time" (StringDom Nothing) NoKey False)])]
[(Relationship "Teaching" [(REnd "Lecturer" "taught_by" (Exactly 1)),
(REnd "Lecture" "teaches" (Between 0 Infinite))]),
(Relationship "Participation" [(REnd "Student" "participated_by" (Between 0 Infinite)),
(REnd "Lecture" "participates" (Between 0 Infinite))]),
(Relationship "Membership" [(REnd "Student" "consists_of" (Exactly 3)),
(REnd "Group" "member_of" (Between 0 Infinite))])])
-- Transformation of ERD term:
(ERD "Uni"
[(Entity "Membership"
[(Attribute "Student_Membership_Key" (KeyDom "Student") PKey False),
(Attribute "Group_Membership_Key" (KeyDom "Group") PKey False)]),
(Entity "Participation"
[(Attribute "Student_Participation_Key" (KeyDom "Student") PKey False),
(Attribute "Lecture_Participation_Key" (KeyDom "Lecture") PKey False)]),
(Entity "Student"
[(Attribute "Key" (IntDom Nothing) PKey False),
(Attribute "MatNum" (IntDom Nothing) Unique False),
(Attribute "Name" (StringDom Nothing) NoKey False),
(Attribute "Firstname" (StringDom Nothing) NoKey False),
(Attribute "Email" (UserDefined "MyModule.Email" Nothing) NoKey True)]),
(Entity "Lecture"
[(Attribute "Key" (IntDom Nothing) PKey False),
(Attribute "Lecturer_Teaching_Key" (KeyDom "Lecturer") NoKey False),
(Attribute "Id" (IntDom Nothing) Unique False),
(Attribute "Title" (StringDom Nothing) Unique False),
(Attribute "Hours" (IntDom (Just 4)) NoKey False)]),
(Entity "Lecturer"
[(Attribute "Key" (IntDom Nothing) PKey False),
(Attribute "Id" (IntDom Nothing) Unique False),
(Attribute "Name" (StringDom Nothing) NoKey False),
(Attribute "Firstname" (StringDom Nothing) NoKey False)]),
(Entity "Group"
[(Attribute "Key" (IntDom Nothing) PKey False),
(Attribute "Time" (StringDom Nothing) NoKey False)])]
[(Relationship [] [(REnd "Student" [] (Exactly 1)),
(REnd "Membership" "member_of" (Between 0 Infinite))]),
(Relationship [] [(REnd "Group" [] (Exactly 1)),
(REnd "Membership" "consists_of" (Exactly 3))]),
(Relationship [] [(REnd "Student" [] (Exactly 1)),
(REnd "Participation" "participates" (Between 0 Infinite))]),
(Relationship [] [(REnd "Lecture" [] (Exactly 1)),
(REnd "Participation" "participated_by" (Between 0 Infinite))]),
(Relationship "Teaching" [(REnd "Lecturer" "taught_by" (Exactly 1)),
(REnd "Lecture" "teaches" (Between 0 Infinite))])])
-}
|