module Build where

import System.Build

import qualified System.Build.Java.Javac as J

import qualified System.Build.Java.Javadoc as D

import System.Cmd

import System.Directory

import System.Exit

import System.FilePath

import Control.Arrow

import Control.Monad

import Codec.Archive.Zip

src :: [FilePath]

src = ["src" </> "main", "src" </> "package-info"]

deps :: [FilePath]

deps = ["src" </> "deps-test"]

test :: [FilePath]

test = ["src" </> "test"]

build :: FilePath

build = "build"

javaco :: FilePath

javaco = build </> "classes" </> "javac"

depso :: FilePath

depso = build </> "classes" </> "deps"

testo :: FilePath

testo = build </> "classes" </> "test"

javadoco :: FilePath

javadoco = build </> "javadoc"

scaladoco :: FilePath

scaladoco = build </> "scaladoc"

jardir :: FilePath

jardir = build </> "jar"

releasedir :: FilePath

releasedir = build </> "release"

mavendir :: FilePath

mavendir = build </> "maven"

etcdir :: FilePath

etcdir = "etc"

resources :: FilePath

resources = "resources"

cp :: String

cp = "classpath" ~: [javaco, depso, testo, resources]

wt :: Version -> Maybe String

wt v = Just ("Functional Java " ++ v)

dt :: Version -> Maybe String

dt v = Just ("Functional Java " ++ v ++ " API Specification")

hd :: Maybe String

hd = Just "<div><p><em>Copyright 2008 - 2010 Tony Morris, Runar Bjarnason, Tom Adams, Brad Clow, Ricky Clarkson, Nick Partridge, Jason Zaugg</em></p>This software is released under an open source BSD licence.</div>"

ds :: String

ds = ".deps"

repo :: String

repo = "https://functionaljava.googlecode.com/svn/"

commitMessage :: String

commitMessage = "\"Automated build\""

resolve :: IO ()

resolve = do e <- doesDirectoryExist ds

unless e $ do mkdir ds

mapM_ (\d -> system ("wget -c --directory " ++ ds ++ ' ' : d)) k

where

k = map ("http://projects.tmorris.net/public/standards/artifacts/1.30/" ++) ["javadoc-style/javadoc-style.css", "scaladoc-style/script.js", "scaladoc-style/style.css"] ++ ["http://soft.tmorris.net/artifacts/package-list-j2se/1.5.0/package-list"]

type Version = String

readVersion :: IO Version

readVersion = readFile "version"

clean :: IO ()

clean = rmdir build

fullClean :: IO ()

fullClean = rmdir ds >> clean

javac' :: FilePath -> J.Javac

javac' d = J.javac {

J.directory = Just d,

J.deprecation = True,

J.etc = Just "-Xlint:unchecked",

J.source = Just "1.5",

J.target = Just "1.5"

}

j :: J.Javac

j = javac' javaco

javac :: IO ExitCode

javac = j ->- src

repl :: IO ExitCode

repl = javac >-- system ("scala -i initrepl " ++ cp)

javadoc' :: Version -> D.Javadoc

javadoc' v = D.javadoc {

D.directory = Just javadoco,

D.windowtitle = wt v,

D.doctitle = dt v,

D.header = hd,

D.stylesheetfile = Just (ds </> "javadoc-style.css"),

D.linkoffline = [("http://java.sun.com/j2se/1.5.0/docs/api", ds)],

D.linksource = True

}

javadoc :: Version -> IO ExitCode

javadoc v = resolve >> javadoc' v ->- src

nosvn :: FilePather Bool

nosvn = fileName /=? ".svn"

nosvnf :: FilterPredicate

nosvnf = constant nosvn ?&&? isFile

archive :: IO ()

archive = do javac

mkdir jardir

writeArchive ([javaco, resources] `zip` repeat ".")

nosvn

nosvnf

[OptVerbose]

(jardir </> "functionaljava.jar")

buildAll :: IO ExitCode

buildAll = do v <- readVersion

resolve

archive

javadoc v

maven :: IO ()

maven = do buildAll

mkdir mavendir

v <- readVersion

forM_ [("javadoc", [javadoco]), ("sources", src), ("tests", test)] (\(n, f) ->

writeHashArchive (map (flip (,) ".") f) nosvn nosvnf [OptVerbose] (mavendir </> "fj-" ++ v ++ '-' : n ++ ".jar"))

svn :: String -> IO ExitCode

svn k = print k >> system ("svn " ++ k)

svn' :: [String] -> IO ExitCode

svn' = svn . join

release :: IO ExitCode

release = let k = build </> "functionaljava"

updateVersion z = let (a, b) = second (show . (+1) . read . drop 1) (break (== '.') z)

in a ++ '.' : b

in do buildAll

mkdir k

forM_ ([(1, javadoco), (2, jardir), (1, etcdir)] ++ map ((,) 0) src) (\(l, d) -> copyl nosvn nosvnf l d k)

mkdir releasedir

writeHashArchive [(build, "functionaljava")] always always' [OptVerbose] (releasedir </> "functionaljava.zip")

v <- readVersion

svn' ["import ", build </> "functionaljava", " ", repo, "/artifacts/", v, " -m ", commitMessage]

svn' ["import ", releasedir, " ", repo, "/artifacts/", v, "/release", " -m ", commitMessage]

svn' ["copy ", repo, "trunk", " ", repo, "/tags/", v, " -m ", commitMessage]

length v `seq` writeFile "version" (updateVersion v)

svn ("commit version -m " ++ commitMessage)

$LastChangedDate: 2009-12-04 20:30:21 +1000 (Fri, 04 Dec 2009) $

$LastChangedRevision: 288 $

$LastChangedBy: tomjadams $

$URL: https://functionaljava.googlecode.com/svn/trunk/README $

Build Instructions

------------------

1a) Install The Haskell Platform http://hackage.haskell.org/platform/

1b) If The Haskell Platform is not available to you:

1b.1) Install GHC http://haskell.org/ghc

1b.2) Install cabal-install http://hackage.haskell.org/trac/hackage/wiki/CabalInstall

1b.3) Install The Haskell Platform with the command 'cabal install haskell-platform'

2) Cabal update with the command 'cabal update'

3) Install Lastik with the command 'cabal install Lastik'

http://hackage.haskell.org/package/Lastik

You are now ready to start playing with the build functionality.

To enter the GHC interpreter with the Build.hs source, type:

> ghci Build.hs

You will find yourself at a prompt

*Build>

This is a GHCi prompt and you have loaded the Functional Java build module.

The special GHCi commands are prefixed with a semi-colon (:).

GHCi also has tab-completion so you may type : then hit TAB and you will see all GHCi special commands.

You can view all of the available Functional Java build functions and their type with the :browse command. The output will be a list of function name followed by :: followed by the type. You read the word :: out aloud as "is of type" so for example src :: [FilePath] would be read as "src is of type list of FilePath". You can get its value by typing src and hitting enter.

*Build> src

["src/main","src/package-info"]

They are the Functional Java source directories. Functions that have the type "IO ()" or "IO ExitCode" will execute a command of some sort. You are probably most interested in these functions for doing compiling and so on. Tab-completion is also available for function names so don't forget to use it.

For example, suppose you want to compile and build a JAR file, then you would execute the "archive" function. At the *Build> prompt type "ar<TAB>". This will fill out the word "archive". Hit enter and the build of the JAR archive will commence. If the tab-completion is ambiguous, hit tab twice in quick succession to list your available options.

Want to know where the JAR file built to? There is a function called 'jardir' which is of the type FilePath. You'll have seen in your :browse. Just type jardir and hit ENTER.

*Build> jardir

"build/jar"

That's where your JAR file will be.

Want to compile all outstanding source files then start a Scala Read-Eval-Print-Loop with all the compiled classes on the classpath? That would be the 'repl' function. You get the drift.

There is the full power of the Haskell programming language and tools to supplement your experience. No more piss-farting about with Apache Ant or Maven or Buildr or any of that nonsense, yay!

But if you must have Maven...

To create a Maven release:

$ # Edit pom.xml in HEAD to point to correct version, 2.16 below.

$ svn co https://functionaljava.googlecode.com/svn/tags/2.16 functionaljava-2.16

$ cd functionaljava-2.16

$ export ANT_OPTS=-Xmx1024m

$ ant -Dbuild.number=2.16 -Dbuild.username=<SVN username> -Dbuild.password=<SVN password> maven-deploy

$ # Post to list.

archive.file=functionaljava.jar

release.file.dir.prefix=functionaljava

release.file.name.prefix=functionaljava

repository=https://functionaljava.googlecode.com/svn

build.username=tonymorris

scalacheck.version r332

ghc Build.hs -e 'archive'

ghci ./Build.hs

ghc Build.hs -e 'clean'

ghc Build.hs -e 'javac'

ghc Build.hs -e "javadoc \"$1\""