Major active repo refactoring

made pomu_active_repo cache its first retval (and unwrap() it
immediately)

this allows the code to assume it can always get the active repository

4 files changed, 42 insertions, 35 deletions

diff --git a/pomu/cli.py b/pomu/cli.py
index ab71861..cb7abde 100644
--- a/pomu/cli.py
+++ b/pomu/cli.py
@@ -7,7 +7,6 @@ from pomu.source import dispatcher
 from pomu.util.result import ResultException
 
 #TODO: global --repo option, (env var?)
-#TODO: write a neat decorator to pass the repo
 
 class GlobalVars():
     """Global state"""
@@ -15,6 +14,17 @@ class GlobalVars():
         self.no_portage = False
         self.repo_path = None
 
+g_params = GlobalVars()
+
+class needs_repo():
+    def __init__(self, func):
+        self.func = func
+
+    def __call__(self, *args):
+        if not hasattr(pomu.repo, 'active'):
+            pomu_active_repo(g_params.no_portage, g_params.repo_path)
+        self.func(*args)
+
 pass_globals = click.make_pass_decorator(GlobalVars, ensure=True)
 
 @click.group()
@@ -22,11 +32,10 @@ pass_globals = click.make_pass_decorator(GlobalVars, ensure=True)
         help='Do not setup the portage repo')
 @click.option('--repo-path',
         help='Path to the repo directory (used with --no-portage)')
-@pass_globals
-def main(globalvars, no_portage, repo_path):
+def main(no_portage, repo_path):
     """A utility to manage portage overlays"""
-    globalvars.no_portage = no_portage
-    globalvars.repo_path = repo_path
+    g_params.no_portage = no_portage
+    g_params.repo_path = repo_path
 
 @main.command()
 @click.option('--list-repos', is_flag=True,
@@ -36,24 +45,23 @@ def main(globalvars, no_portage, repo_path):
 @click.option('--repo-dir', envvar='POMU_REPO_DIR', default='/var/lib/pomu',
         help='Path for creating new repos')
 @click.argument('repo', required=False)
-@pass_globals
-def init(globalvars, list_repos, create, repo_dir, repo):
+def init(g_params, list_repos, create, repo_dir, repo):
     """Initialise pomu for a repository"""
     if list_repos:
         print('Available repos:')
         for prepo in portage_repos():
             print('\t', prepo, portage_repo_path(prepo))
         return
-    if globalvars.no_portage:
-        print(init_plain_repo(create, globalvars.repo_path).expect())
+    if g_params.no_portage:
+        print(init_plain_repo(create, g_params.repo_path).expect())
     else:
         print(init_portage_repo(create, repo, repo_dir).expect())
 
 @main.command()
-@pass_globals
-def status(globalvars):
+@needs_repo
+def status():
     """Display pomu status"""
-    repo = pomu_active_repo_(globalvars.no_portage, globalvars.repo_path).expect()
+    repo = pomu_active_repo()
     if repo.name:
         print('pomu is initialized for reporitory', repo.name, 'at', repo.root)
     else:
@@ -61,8 +69,8 @@ def status(globalvars):
 
 @main.command()
 @click.argument('package', required=True)
-@pass_globals
-def install(globalvars):
+@needs_repo
+def install():
     res = dispatcher.install_package(package).expect()
     print(res)
 
@@ -70,20 +78,20 @@ def install(globalvars):
 @click.option('--uri', is_flag=True,
         help='Specify the package to remove by uri, instead of its name')
 @click.argument('package', required=True)
-@pass_globals
-def uninstall(globalvars):
+@needs_repo
+def uninstall():
     if uri:
         res = dispatcher.uninstall_package(package).expect()
         print(res)
     else:
-        repo = pomu_active_repo_(globalvars.no_portage, globalvars.repo_path).expect()
+        repo = pomu_active_repo()
         res = repo.remove_package(package).expect()
         return res
 
 @main.command()
 @click.argument('package', required=True)
-@pass_globals
-def fetch(self):
+@needs_repo
+def fetch():
     pkg = dispatcher.get_package(package).expect()
     print('Fetched package', pkg.name, 'at', pkg.root)
 
diff --git a/pomu/repo/repo.py b/pomu/repo/repo.py
index 2d69a06..9f48c24 100644
--- a/pomu/repo/repo.py
+++ b/pomu/repo/repo.py
@@ -82,18 +82,9 @@ def pomu_status(repo_path):
     """Check if pomu is enabled for a repository at a given path"""
     return path.isdir(path.join(repo_path, 'metadata', 'pomu'))
 
-def pomu_active_portage_repo():
-    """Returns a portage repo, for which pomu is enabled"""
-    for repo in portage_repos():
-        if pomu_status(portage_repo_path(repo)):
-            return repo
-    return None
-
-def pomu_active_repo():
-    return pomu_active_portage_repo()
-
-#TODO: merge with pomu_active_repo, pass the result
-def pomu_active_repo_(no_portage=None, repo_path=None):
+@cached
+def pomu_active_repo(no_portage=None, repo_path=None):
+    """Returns a repo for which pomu is enabled"""
     if no_portage:
         if not repo_path:
             return Result.Err('repo-path required')
diff --git a/pomu/source/manager.py b/pomu/source/manager.py
index a887956..93fd1b4 100644
--- a/pomu/source/manager.py
+++ b/pomu/source/manager.py
@@ -79,10 +79,8 @@ class PackageDispatcher():
 
     def install_package(self, uri):
         pkg = self.get_package(uri).unwrap()
-        #TODO: write a helper function which expects pomu_active_repo
-        #alternatively, test for it before any command which requires a repo
-        return pomu_active_repo().unwrap().merge(pkg)
+        return pomu_active_repo().merge(pkg)
 
     def uninstall_package(self, uri):
         pkg = self.get_package(uri).unwrap()
-        return pomu_active_repo().unwrap().unmerge(pkg)
+        return pomu_active_repo().unmerge(pkg)
diff --git a/pomu/util/cache.py b/pomu/util/cache.py
new file mode 100644
index 0000000..b1d09b2
--- /dev/null
+++ b/pomu/util/cache.py
@@ -0,0 +1,10 @@
+"""
+Caches the return value of a function -> Result, regardless of input params
+"""
+class cached():
+    def __init__(self, fun):
+        self.fun = fun
+    def __call__(self, *args):
+        if not hasattr(self, 'retval'):
+            self.retval = self.fun(*args).unwrap()
+        return self.retval