Fixes up HaskellPort to work with the new refactoring.

Also adds some close code for ports
Also mistakenly stuck some code in HaskellPort that really belongs to the build system

1 files changed, 57 insertions, 32 deletions

diff --git a/modules/haskellport.py b/modules/haskellport.py
index eff0d70..b585788 100644
--- a/modules/haskellport.py
+++ b/modules/haskellport.py
@@ -15,28 +15,50 @@
 #
 # Authors: Yaakov M. Nemoy <ynemoy@redhat.com>
 #
+from __future__ import with_statement
 
-from modules.dirfactory import DirFactory
+from os import getcwd
+
+from base.base import log
+from base.exceptions import ExecutionException
+from base.dirfactory import DirFactory
+from base.util import pwd
+
+from modules.darcs import Darcs
+from modules.hackage import Hackage
 from modules.port import Port
+from modules.sourceball import SourceBall
 
 class HaskellPort(Port):
-    def __init__(self, package):
+    def __init__(self, package=None):
+        super(HaskellPort, self).__init__()
+        if not package:
+            package = getcwd()
         self.pkg = DirFactory(package)
+        self.hackage = Hackage()
 
-    def copy_in(self, tarball):
+    def add_sourceball(self, sourceball):
         '''copies a tarball into the package
         
         tarball is a path to some tarball
         '''
-        self.package.add_sourceball(tarball)
+        with pwd(self.pkg.dir):
+            pkg_src = SourceBall('', sourceball)
+            name = pkg_src.name
+            self.pkg.add_source(name)
+        return self.close_later(pkg_src)
     
-    def darcs_get(self, url, tgt):
+    def add_darcs(self, url, tgt, *args):
         '''creates a darcs variant of a cabal package using darcs source
 
         url is a url to some darcs repo
         tgt is the local name of the darcs repo
         '''
-        self.package.checkout(tgt, url)
+        with pwd(self.pkg.dir):
+            pkg_src = Darcs(tgt, url, *args)
+            name = pkg_src.name
+            self.pkg.add_source(name)
+        return self.close_later(pkg_src)
 
     def install_tag(self, tag):
         '''assuming a package that supports tagging, install a specific tag
@@ -47,50 +69,53 @@ class HaskellPort(Port):
             with self.package.tag(tag):
                 self.install()
 
-    def install_source(self, target='home', *args):
-        '''perform configure, build, and install steps in one
-        '''
-        with self.pkg_src.src(*args):
-            self.configure(target, orig)
-            self.build(orig)
-            self.install(orig)
-
-    def install_sourceball(self, tarball, target='home'):
+    def install_sourceball(self, tarball, target='home', *args):
         '''given a tarball, copy it in and install it
         '''
-        self.copy_in(tarball)
-        self.install_source(target, '')
-
-    def install_latest(self, pkg, target='home'):
-        '''get and install the latest version of a package from hackage'''
-        self.get_latest(pkg)
-        self.install_source(target, '')
+        pkg_src = self.add_sourceball(tarball)
+        Cabal(pkg_src).install_source(target, *args)
 
-    def get_from_hackage(self, pkg, ver):
+    def add_from_hackage(self, pkg, ver):
         '''get a specific package from hackage
         
         pkg is the name of the package desired
         ver is the version wanted
         '''
-        sb_file = self.hackage_url(pkg, ver)
-        self.copy_in(sb_file)
+        sb_loc = self.hackage.url(pkg, ver)
+        return self.add_sourceball(sb_loc)
 
-    def get_latest(self, pkg):
+    def add_latest(self, pkg):
         '''get the latest version of a package from hackage
         
         pkg is the package desired
         '''
-        ver = self.latest_version(pkg)
-        self.get_from_hackage(pkg, ver)
+        ver = self.hackage.latest_version(pkg)
+        return self.add_from_hackage(pkg, ver)
 
-    def install_from_hackage(self, pkg, ver, target='home'):
+    def install_from_hackage(self, pkg, ver, target='home', *args):
         '''get and install a specific package from hackage
         
         pkg is the desired package
         ver is the version wanted
         target is the location to install to, either 'home' or 'root'
         '''
-        self.get_from_hackage(pkg, ver)
-        self.install_source(target, '')
+        sb_loc = self.hackage.url(pkg, ver)
+        self.install_sourceball(sb_loc, target, *args)
+
+    def install_latest(self, pkg, target='home', *args):
+        '''get and install the latest version of a package from hackage'''
+        ver = self.hackage.latest_version(pkg)
+        self.install_from_hackage(pkg, ver, target, *args)
+
+    def add_upstream(self, pkg, tgt=None, *args):
+        if not tgt:
+            tgt = pkg
+        return self.add_darcs(self.hackage.darcs_url(pkg), tgt, *args)
+
+    def install_upstream(self, pkg, tgt=None, target='home', *args):
+        pkg_src = self.add_upstream(pkg, tgt, *args)
+        Cabal(pkg_src).install_source(target)
 
-    pass
+    def close(self):
+        super(HaskellPort, self).close()
+        self.pkg.close()