--- bindings/python/mongoose.py	2010-03-10 20:07:53.735407453 -0500
+++ bindings/python/mongoose.py	2010-03-10 20:09:08.935760549 -0500
@@ -110,7 +110,8 @@
 
 	def __init__(self, **kwargs):
 		dll_extension = os.name == 'nt' and 'dll' or 'so'
-		self.dll = ctypes.CDLL('_mongoose.%s' % dll_extension)
+		from distutils.sysconfig import get_python_lib
+		self.dll = ctypes.CDLL(get_python_lib(1) + '/_mongoose.%s' % dll_extension)
 		start = self.dll.mg_start
 		self.ctx = ctypes.c_voidp(self.dll.mg_start()).value
 		self.version = ctypes.c_char_p(self.dll.mg_version()).value

# sitearch for others (remove the unneeded one)
%{!?python_sitearch: %global python_sitearch %(%{__python} -c "from distutils.sysconfig import get_python_lib; print(get_python_lib(1))")}


Name:           mongoose
Version:        2.8
Release:        1%{?dist}
Summary:        Simple and easy to use web server

Group:          System Environment/Daemons
License:        MIT
URL:            http://code.google.com/p/mongoose/
Source0:        http://mongoose.googlecode.com/files/%{name}-%{version}.tgz
Patch0:         mongoose-site-location.patch
BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)


%description
Mongoose is an easy to use web server. It can be embedded into
existing application to provide a web interface to it.


%package python
Summary:       Python bindings for the mongoose web server
Requires:      mongoose


%description python
Mongoose is an easy to use web server. It can be embedded into
existing application to provide a web interface to it. This
package includes the bindings for the Python programming language.


%package devel
Summary:       Development files for the mongoose web server
BuildArch:     noarch


%description devel
Mongoose is an easy to use web server. It can be embedded into
existing application to provide a web interface to it. This
package includes the development files.


%prep
%setup -qn %{name}
%patch0


%build
make %{?_smp_mflags} linux


%install
rm -rf $RPM_BUILD_ROOT
# Install the base
mkdir -p $RPM_BUILD_ROOT/%{_bindir}
mkdir -p $RPM_BUILD_ROOT/%{_mandir}/man1/
cp %{name} $RPM_BUILD_ROOT/%{_bindir}
cp %{name}.1 $RPM_BUILD_ROOT/%{_mandir}/man1/

# Install the python bindings
mkdir -p $RPM_BUILD_ROOT/%{python_sitearch}
cp bindings/python/mongoose.py _%{name}.so $RPM_BUILD_ROOT/%{python_sitearch}

# Install the development files
mkdir -p $RPM_BUILD_ROOT/%{_includedir}/%{name}/
cp %{name}.h $RPM_BUILD_ROOT/%{_includedir}/%{name}/


%clean
rm -rf $RPM_BUILD_ROOT


%files
%defattr(-,root,root,-)
%{_bindir}/%{name}
%{_mandir}/man1/%{name}.1.gz


%files python
%defattr(-,root,root,-)
%{python_sitearch}/_%{name}.so
%{python_sitearch}/%{name}.py*


%files devel
%defattr(-,root,root,-)
%{_includedir}/%{name}/


%changelog
* Wed Mar 10 2010 Steve 'Ashcrow' Milner <me@stevemilner.org> 2.8-1
- Initial spec

# WHY DID I WRITE THIS?!

import os
import yaml

from multiprocessing import Process
from multiprocessing.managers import BaseManager


class WriteableDict(dict):
    """
    A dictionary which can write to disk.
    """

    def __init__(self, fs_loc, *args, **kwargs):
        """
        Create the instance.

        :Parameters:
           - `fs_loc`: location on disk to write to
           - `args`: all other non-keyword arguments
           - `kwargs`: all other keyword arguments
        """
        dict.__init__(self, *args, **kwargs)
        self.__fs_loc = fs_loc
        self.__saving = None

    def __save_to_disk(self):
        """
        Save to disk.
        """
        # If we are trying to save while anothe save is happening
        # kill the previous save as it's already out of date
        try:
            if self.__saving.is_alive():
                self.__saving.terminate()
            self.__saving.join()
        except:
            pass

        def save(write, data):
            with open(write, 'w') as fs_file:
                fs_file.write(yaml.dump(data.copy()))
            self.__saving = False

        self.__saving = Process(target=save, args=(self.__fs_loc, self))
        self.__saving.daemon = True
        self.__saving.start()

    def update(self, *args, **kwargs):
        """
        Write enabled update.

        :Parameters:
           - `args`: all other non-keyword arguments
           - `kwargs`: all other keyword arguments
        """
        dict.update(self, *args, **kwargs)
        self.__save_to_disk()

    def pop(self, *args, **kwargs):
        """
        Write enabled pop.

        :Parameters:
           - `args`: all other non-keyword arguments
           - `kwargs`: all other keyword arguments
        """
        dict.pop(self, *args, **kwargs)
        self.__save_to_disk()

    def popitem(self, *args, **kwargs):
        """
        Write enabled popitem.

        :Parameters:
           - `args`: all other non-keyword arguments
           - `kwargs`: all other keyword arguments
        """
        dict.popitem(self, *args, **kwargs)
        self.__save_to_disk()

    def clear(self, *args, **kwargs):
        """
        Write enabled clear.

        :Parameters:
           - `args`: all other non-keyword arguments
           - `kwargs`: all other keyword arguments
        """
        dict.clear(self, *args, **kwargs)
        self.__save_to_disk()


class DataBroker(object):

    __data = {}

    def __init__(self, data_loc, auth):
        """
        Creates an instance of the broker and loads any initial data found.

        :Parameters:
           - `data_loc`: directory on disk that houses any .data files to load
           - `auth`: auth information to use
        """
        self.__auth = auth
        self.__data_loc = data_loc
        for loc in filter(lambda s: s.endswith('.data'), os.listdir(data_loc)):
            full_path = os.path.sep.join([data_loc, loc])
            name = os.path.basename(loc).replace('.data', '')
            with open(full_path, 'r') as f_loc:
                self.__data[name] = WriteableDict(
                    full_path, yaml.load(f_loc.read()))

    def __authenticate(self, user, passwd):
        """
        Poor mans authentication.

        :Parameters:
           - `user`: username
           - `pasword`: ... password
        """
        if user in self.__auth.keys():
            if self.__auth[user][0] == passwd:
                return True
        return False

    def get_data(self, user, passwd, name):
        """
        Hands over access to the dictionary.

        :Parameters:
           - `user`: username
           - `password`: password
           - `name`: name of the dictionary to access
        """
        if self.__authenticate(user, passwd):
            if name in self.__auth[user][1]:
                if name not in self.__data.keys():
                    self.__data[name] = WriteableDict(self.__data_loc + name + ".data")
                return self.__data[name]
        raise Exception


class DataManager(BaseManager):
    """
    Data Manager.
    """

    def __init__(self, *args, **kwargs):
        """
        Creates an instance of the manager.

        :Parameters:
           - `args`: all other non-keyword arguments
           - `kwargs`: all other keyword arguments
        """
        BaseManager.__init__(self, *args, **kwargs)
        self.register('get_data',
            callable=lambda u, p, s: broker.get_data(u, p, s))


if __name__ == '__main__':
    # Auth information user: (password (dicts, that, they, can, access))
    auth = {'test': ('testing', ('something', ))}
    # Setup the broker and manager
    broker = DataBroker('/tmp/', auth)
    manager = DataManager(address=('', 50000), authkey='abracadabra')
    # and serve until a ctrl+c
    server = manager.get_server()
    try:
        server.serve_forever()
    except KeyboardInterrupt, ki:
        server.shutdown()

diff --git a/jython/src/shell/jython b/jython/src/shell/jython
index ff8df4a..41f145b 100755
--- a/jython/src/shell/jython
+++ b/jython/src/shell/jython
@@ -12,9 +12,25 @@
 #
 # -----------------------------------------------------------------------------

-cygwin=false
+# ----- Allow for script debug mode -------------------------------------------
+# Someone may want to know what this script is doing :-) ... allow --verbose/-v
+# Note that this is done way before other options so the user can see the
+# results from the start.
+JYTHON_SHELL_DEBUG=false
+function toggle_debug {
+    ARGS=$1
+    if [[ "$ARGS" =~ "--verbose" ]]; then
+        if [ $JYTHON_SHELL_DEBUG == false ]; then
+            set -x && JYTHON_SHELL_DEBUG=true
+        else
+            set +x && JYTHON_SHELL_DEBUG=false
+        fi
+    fi
+}
+toggle_debug $@

 # ----- Identify OS we are running under --------------------------------------
+cygwin=false
 case "`uname`" in
   CYGWIN*) cygwin=true;;
   Darwin) darwin=true;;
@@ -267,6 +283,7 @@ elif [ -n "$help_requested" ] ; then
   echo "--print  : print the Java command instead of executing it" >&2
   echo "--profile: run with the Java Interactive Profiler (http://jiprof.sf.net)" >&2
   echo "--boot   : put jython on the boot classpath (disables the bytecode verifier)" >&2
+  echo "--verbose: shows all information on this shell script as it executes" >&2
   echo "--       : pass remaining arguments through to Jython" >&2
   echo "Jython launcher environment variables:" >&2
   echo "JAVA_HOME  : Java installation directory" >&2
@@ -277,5 +294,6 @@ fi
 if $cygwin; then
   stty icanon echo > /dev/null 2>&1
 fi
-
+# Turn off script debug just incase
+toggle_debug $@
 exit $JYTHON_STATUS

import os
import re
import subprocess


class SCM(object):
    """
    Parent class for all SCM's.
    """

    def __init__(self, bin=None):
        """
        Creates the instance.

        :Parameters:
           - `bin`: if a binary is required it's location is here.
        """
        self.__bin = bin

    def _execute(self, command):
        """
        Helps execute shell commands.

        :Parameters:
           - `command`: the command to execute.
        """
        process = subprocess.Popen(command, shell=True,
            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
            stderr=subprocess.PIPE, close_fds=True)
        return process.stdout, process.stderr

    def _branch_parser(self, data):
        """
        Parses the branch return results. Defaults to a pass through.

        :Parameters:
           - `data`: the data to parse.
        """
        return data

    def get_branches(self, repo_path):
        """
        Get a list of branches.

        :Parameters:
           - `repo_path`: path on the file system to the repository.
        """
        raise NotImplementedError("_get_branches must be implemented")

    # read-only properties
    bin = property(lambda s: s.__bin)


class Git(SCM):
    """
    The Git SCM.
    """

    def _branch_parser(self, data):
        """
        Parses the branch return results. Defaults to a pass through.

        :Parameters:
           - `data`: the data to parse.
        """
        return re.findall("\* ([^ ]*)\n", data)

    def get_branches(self, repo_path):
        """
        Get a list of branches.

        :Parameters:
           - `repo_path`: path on the file system to the repository.
        """
        out, err = self._execute("%s branch" % self.bin)
        error_info = err.read()
        if error_info:
            raise Exception(error_info)
        return self._branch_parser(out.read())


class Mercurial(SCM):
    """
    The Mercurial (hg) SCM.
    """

    def get_branches(self, repo_path):
        """
        Get a list of branches.

        :Parameters:
           - `repo_path`: path on the file system to the repository.
        """
        from mercurial import ui, hg
        a = hg.repository(ui.ui(), path=repo_path)
        return a.branchmap().keys()


class Repository(object):
    """
    An SCM agnostic repository class.
    """

    def __init__(self, name, location, clone_url, repo_class,
        repo_args=[], repo_kwargs={}):
        """
        Creates an instance of the repostory representation.

        :Parameters:
           - `name`: a nice name for the repository.
           - `location`: location on the filesystem of the repository.
           - `clone_url`: how to clone the repository.
           - `repo_class`: the class to use when getting data from the repo.
           - `repo_args`: non-keyword args to pass through to the repo class.
           - `repo_kwargs`: keword args to pass through to the repo class.
        """
        self.__name = name
        self.__location = location
        self.__repo_class = repo_class
        self.__obj = self.__repo_class(*repo_args, **repo_kwargs)

    def __repr__(self):
        """
        String representation of this instance.
        """
        return "<Repository %s: type='%s',class='%s'>" % (
            self.name, self.location, self.__repo_class.__name__)

    def _get_branches(self):
        """
        Gets all branches in this instance of a repository.
        """
        os.chdir(self.__location)
        return self.__obj.get_branches(self.__location)

    # read-only properties
    name = property(lambda s: s.__name)
    location = property(lambda s: s.__location)
    repo_class = property(lambda s: s.__repo_class)
    branches = property(lambda s: s._get_branches())


# Examples
g = Repository('pyclean', '/home/steve/Tech/pyclean/', 'http://stevemilner.org', Git, ['/usr/bin/git'])
print g.branches
m = Repository('winlibre', '/tmp/winlibre/', 'http://stevemilner.org', Mercurial)
print m.branches