[CODE] refactored config.py

Author: Uwe Schmitt

Diff for: emzed/core/config.py

@@ -1,79 +1,105 @@
-import pdb
 #encoding: latin-1
 
-import guidata.dataset.datatypes as dt
-import guidata.dataset.dataitems as di
-import guidata.userconfig
+# keep namespace clean:
 
-is_expert = dt.ValueProp(False)
+import guidata.dataset.datatypes as _dt
+import guidata.dataset.dataitems as _di
 
-class UserConfig(dt.DataSet):
+_is_expert = _dt.ValueProp(False)
 
-    g1 = dt.BeginGroup("User Settings")
+class _UserConfig(object):
 
-    user_name = di.StringItem("Full Name", notempty=True)
-    user_email = di.StringItem("Email Adress", notempty=True)
-    user_url = di.StringItem("Website URL")
 
-    _g1 = dt.EndGroup("User Settings")
+    class Parameters(_dt.DataSet):
 
-    g2 = dt.BeginGroup("Webservice Settings")
+        g1 = _dt.BeginGroup("User Settings")
 
-    metlin_token  = di.StringItem("Metlin Token")
+        user_name = _di.StringItem("Full Name", notempty=True)
+        user_email = _di.StringItem("Email Adress", notempty=True)
+        user_url = _di.StringItem("Website URL")
 
-    _g2 = dt.EndGroup("Webservice Settings")
+        _g1 = _dt.EndGroup("User Settings")
 
-    g3 = dt.BeginGroup("Emzed Store User Account")
+        g2 = _dt.BeginGroup("Webservice Settings")
 
-    emzed_store_user = di.StringItem("User Name")
-    emzed_store_password = di.StringItem("User Password")
+        metlin_token  = _di.StringItem("Metlin Token")
 
-    _g3 = dt.EndGroup("Emzed Store Settings")
+        _g2 = _dt.EndGroup("Webservice Settings")
 
-    g4 = dt.BeginGroup("Emzed Store Expert Settings")
-    enable_expert_settings = di.BoolItem("Enable Settings").set_prop("display",
-            store=is_expert)
-    emzed_store_url = di.StringItem("Emzed Store URL").set_prop("display", active=is_expert)
-    emzed_store_index_url = di.StringItem("Emzed Store Index URL").set_prop("display", active=is_expert)
-    pypi_url = di.StringItem("PyPi URL").set_prop("display", active=is_expert)
+        g3 = _dt.BeginGroup("Emzed Store User Account")
 
-    _g4 = dt.EndGroup("Expert Settings")
+        emzed_store_user = _di.StringItem("User Name")
+        emzed_store_password = _di.StringItem("User Password")
 
-test_config = UserConfig()
+        _g3 = _dt.EndGroup("Emzed Store Settings")
 
-test_config.user_name = "Uwe Schmitt"
-test_config.user_email = "[email protected]"
-test_config.user_url = ""
+        g4 = _dt.BeginGroup("Emzed Store Expert Settings")
+        enable_expert_settings = _di.BoolItem("Enable Settings").set_prop("display",
+                store=_is_expert)
+        emzed_store_url = _di.StringItem("Emzed Store URL").set_prop("display", active=_is_expert)
+        emzed_store_index_url = _di.StringItem("Emzed Store Index URL").set_prop("display", active=_is_expert)
+        pypi_url = _di.StringItem("PyPi URL").set_prop("display", active=_is_expert)
 
-test_config.metlin_token = ""
+        _g4 = _dt.EndGroup("Expert Settings")
 
-test_config.emzed_store_user = "uschmitt"
-test_config.emzed_store_password = "pillepalle"
+    def __init__(self, *a, **kw):
+        self.parameters = _UserConfig.Parameters()
+        if "_no_load" not in kw:
+            loaded = self.load()
+            if not loaded:
+                self.set_defaults()
+        else:
+            self.set_defaults()
 
-test_config.emzed_store_url = "http://uweschmitt.info:3141/root/dev"
-test_config.emzed_store_index_url = "http://uweschmitt.info:3141/root/dev/+simple/"
-test_config.pypi_url = "http://testpypi.python.org/pypi"
+    def get(self, key):
+        val = getattr(self.parameters, key)
+        if isinstance(val, unicode):
+            val = val.encode("latin-1")
+        return val
 
-import os
-is_test = os.environ.get("IS_TEST")
-if is_test:
-    config = test_config
+    def set_(self, key, value):
+        return setattr(self.parameters, key, value)
 
-def get(key):
-    return getattr(config, key)
+    def get_url(self, key):
+        return self.get(key).rstrip("/") + "/"
 
-def set_(key, value):
-    return setattr(config, key, value)
+    def store(self, path=None):
+        import guidata.userconfig
+        if path is None:
+            path = self.config_file_path()
+        cf = guidata.userconfig.UserConfig(dict())
+        self.parameters.write_config(cf, "emzed", "")
+        with open(path, "wt") as fp:
+            cf.write(fp)
 
-def get_url(key):
-    return get(key).rstrip("/") + "/"
+    def load(self, path=None):
+        import os
+        import guidata.userconfig
+        cf = guidata.userconfig.UserConfig(dict())
+        if path is None:
+            path = self.config_file_path()
+        if os.path.exists(path):
+            with open(path, "rt") as fp:
+                try:
+                    cf.readfp(fp)
+                    self.parameters.read_config(cf, "emzed", "")
+                    return True
+                except:
+                    pass
+        return False
 
-def store(fp):
-    cf = guidata.userconfig.UserConfig(dict())
-    config.write_config(cf, "emzed", "")
-    cf.write(fp)
+    def edit(self):
+        self.parameters.edit()
+        self.store()
 
-def load(fp):
-    cf = guidata.userconfig.UserConfig(dict())
-    cf.read(fp)
-    config.read_config(cf, "emzed", "")
+    def config_file_path(self):
+        import os
+        from emzed.core.platform_dependent import getEmzedFolder
+        return os.path.join(getEmzedFolder(), "config.ini")
+
+    def set_defaults(self):
+        self.parameters.emzed_store_url = "http://uweschmitt.info:3141/root/dev"
+        self.parameters.emzed_store_index_url = "http://uweschmitt.info:3141/root/dev/+simple/"
+        self.parameters.pypi_url = "http://testpypi.python.org/pypi"
+
+global_config = _UserConfig()

Diff for: emzed/core/packages.py

@@ -1,4 +1,3 @@
-import pdb
 # encoding:latin-1
 
 EMZED_PKG_MARKER_FILE = ".emzed_pkg_marker"
@@ -8,10 +7,9 @@
 import requests
 import subprocess
 import pkg_resources
-import urllib
 
 import helpers
-import config
+from config import global_config
 import licenses
 
 
@@ -155,12 +153,12 @@ def hello():
     """ % pkg_name)
 
     with open(os.path.join(pkg_folder, "setup.py"), "w") as fp:
-        user = config.get("emzed_store_user")
-        password = config.get("emzed_store_password")
-        repository = config.get_url("emzed_store_url")
-        author = config.get("user_name")
-        author_email = config.get("user_email")
-        author_url = config.get("user_url")
+        user = global_config.get("emzed_store_user")
+        password = global_config.get("emzed_store_password")
+        repository = global_config.get_url("emzed_store_url")
+        author = global_config.get("user_name")
+        author_email = global_config.get("user_email")
+        author_url = global_config.get("user_url")
         fp.write(SETUP_PY_TEMPLATE % locals())
 
     with open(os.path.join(pkg_folder, "LICENSE"), "w") as fp:
@@ -190,9 +188,9 @@ def create_package_scaffold(folder, pkg_name, version=(0,0,1)):
     _create_pkg_folder(folder, pkg_name, version)
 
 def delete_from_emzed_store(pkg_name):
-    user = config.get("emzed_store_user")
-    password = config.get("emzed_store_password")
-    url = config.get_url("emzed_store_url") + pkg_name
+    user = global_config.get("emzed_store_user")
+    password = global_config.get("emzed_store_password")
+    url = global_config.get_url("emzed_store_url") + pkg_name
     response = requests.delete(url, auth=(user, password))
     response.raise_for_status()
 
@@ -217,7 +215,7 @@ def install_from_emzed_store(pkg_name, version=None):
     if version:
         assert isinstance(version, tuple)
         assert len(version) == 3
-    index_url = config.get_url("emzed_store_index_url")
+    index_url = global_config.get_url("emzed_store_index_url")
     pkg_query = pkg_name
     if version:
         pkg_query += "==%s.%s.%s" % version
@@ -246,7 +244,7 @@ def installed_emzed_packages():
     return [ (p, p in extensions, p in apps) for p in packages]
 
 def list_packages_from_emzed_store():
-    url = config.get_url("emzed_store_url")
+    url = global_config.get_url("emzed_store_url")
     response = helpers.get_json(url)
     response.raise_for_status()
     packages = [ name.encode("latin-1") for name in response.json()["result"]]

Diff for: emzed/core/platform_dependent.py

@@ -0,0 +1,53 @@
+import os, sys
+import functools
+
+
+def userShellFolderKey():
+    import _winreg
+    key =_winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
+                        "Software\\Microsoft\\Windows\\CurrentVersion"
+                        "\\Explorer\\User Shell Folders")
+    return key
+
+def _query(key, subKey):
+    import _winreg
+    val, _ = _winreg.QueryValueEx(key, subKey)
+    return _winreg.ExpandEnvironmentStrings(val)
+
+def linuxdefault(path):
+    def wrapper(fun, path=path):
+        @functools.wraps(fun)
+        def new_fun():
+            if sys.platform == "win32":
+                return fun()
+            else:
+                return path
+        return new_fun
+    return wrapper
+
+
+@linuxdefault(os.environ.get("HOME"))
+def getDocumentFolder():
+    key = userShellFolderKey()
+    return _query(key, "Personal")
+
+@linuxdefault(os.environ.get("HOME"))
+def getAppDataFolder():
+    key = userShellFolderKey()
+    return _query(key, "AppData")
+
+@linuxdefault(os.environ.get("HOME"))
+def getLocalAppDataFolder():
+    key = userShellFolderKey()
+    return _query(key, "Local AppData")
+
+def getEmzedFolder():
+    if sys.platform == "win32":
+        return os.path.join(getAppDataFolder(), "emzed")
+    else:
+        return os.path.join(getAppDataFolder(), ".emzed")
+
+
+def getDataHome():
+    dataHome = os.path.join(getDocumentFolder(), "emzed_files")
+    return dataHome

Diff for: emzed/core/updaters.py

@@ -1,10 +1,10 @@
 # encoding:latin-1
 
-import config
+from config import global_config
 import requests
 
 def get_latest_emzed_version_from_pypi():
-    url = config.get_url("pypi_url")
+    url = global_config.get_url("pypi_url")
     response = requests.get(url + "emzed/json")
     response.raise_for_status()
     version_str = response.json()["info"]["version"]

Diff for: run_coverage_test.sh

@@ -0,0 +1 @@
+py.test --cov-report term-missing --cov emzed tests/

Diff for: tests/test_config.py

@@ -1,32 +1,23 @@
 #encoding: latin-1
 
 import unittest
+import emzed.core.config
+import tempfile, os.path
 
-import emzed.core.config as config
 
 class ConfigTests(unittest.TestCase):
 
-    def test_config(self):
+    def setUp(self):
+        self.path = os.path.join(tempfile.mkdtemp(), "test_config.ini")
 
-        return
+    def test_global_config(self):
+
+        config = emzed.core.config.global_config
 
-        self.assertEqual(config.get("user_name"), "Uwe Schmitt")
         config.set_("user_name", "Hans Dampf")
         self.assertEqual(config.get("user_name"), "Hans Dampf")
-
-        import cStringIO
-        fp = cStringIO.StringIO()
-        config.store(fp)
-        fp.seek(0)
+        config.store(self.path)
 
         config.set_("user_name", "Udo Juergens")
-        config.load(fp)
-
-        config.set_("user_name", "Hans Dampf")
-
-
-
-
-
-
-
+        assert config.load(self.path)
+        self.assertEqual(config.get("user_name"), "Hans Dampf")

Diff for: tests/test_package_store.py

@@ -4,6 +4,22 @@
 
 class PackageStoreTests(unittest.TestCase):
 
+    def setUp(self):
+        from emzed.core.config import global_config
+
+        global_config.parameters.user_name = "Uwe Schmitt"
+        global_config.parameters.user_email = "[email protected]"
+        global_config.parameters.user_url = ""
+
+        global_config.parameters.metlin_token = ""
+
+        global_config.parameters.emzed_store_user = "uschmitt"
+        global_config.parameters.emzed_store_password = "pillepalle"
+
+        # for testing implicit unicode conversions:
+        global_config.store()
+        global_config.load()
+
     def test_project_scaffold(self):
         import tempfile
         import os.path
@@ -100,5 +116,6 @@ def test_minimal_package(self):
 
 
     def test_delete_nonexisting(self):
+        import emzed.core.packages
         with self.assertRaises(Exception):
             emzed.core.packages.delete_from_emzed_store("abc123")