Lots of stuff

src/com/dmdirc/util/ConfigFile.java

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Reads and writes a standard DMDirc config file.
+ *
+ * @author chris
+ */
+public class ConfigFile extends TextFile {
+
+    /** A list of domains in this config file. */
+    private final List<String> domains = new ArrayList<String>();
+
+    /** The values associated with each flat domain. */
+    private final MapList<String, String> flatdomains = new MapList<String, String>();
+
+    /** The key/value sets associated with each key domain. */
+    private final Map<String, Map<String, String>> keydomains
+            = new HashMap<String, Map<String, String>>();
+    
+    /** Whether or not we should automatically create domains. */
+    private boolean automake;
+
+    /**
+     * Creates a new read-only Config File from the specified input stream.
+     * 
+     * @param is The input stream to read
+     */
+    public ConfigFile(final InputStream is) {
+        super(is, Charset.forName("UTF-8"));
+    }
+
+    /**
+     * Creates a new Config File from the specified file.
+     * 
+     * @param file The file to read/write
+     */
+    public ConfigFile(final File file) {
+        super(file, Charset.forName("UTF-8"));
+    }
+
+    /**
+     * Creates a new Config File from the specified file.
+     * 
+     * @param filename The name of the file to read/write
+     */
+    public ConfigFile(final String filename) {
+        this(new File(filename));
+    }
+
+    /**
+     * Sets the "automake" value of this config file. If automake is set to
+     * true, any calls to getKeyDomain will automatically create the domain
+     * if it did not previously exist.
+     * 
+     * @param automake The new value of the automake setting of this file
+     */
+    public void setAutomake(final boolean automake) {
+        this.automake = automake;
+    }
+
+    /**
+     * Reads the data from the file.
+     * 
+     * @throws FileNotFoundException if the file is not found
+     * @throws IOException if an i/o exception occured when reading
+     * @throws InvalidConfigFileException if the config file isn't valid
+     */
+    public void read() throws FileNotFoundException, IOException, InvalidConfigFileException {
+        String domain = null;
+        boolean keydomain = false;
+        int offset;
+        
+        keydomains.clear();
+        flatdomains.clear();
+        domains.clear();
+        
+        readLines();
+
+        for (String line : getLines()) {
+            String tline = line;
+            
+            while (!tline.isEmpty() && (tline.charAt(0) == '\t' || 
+                    tline.charAt(0) == ' ')) {
+                tline = tline.substring(1);
+            }
+
+            if (tline.indexOf('#') == 0 || tline.isEmpty()) {
+                continue;
+            } else if (
+                    (tline.endsWith(":") && !tline.endsWith("\\:"))
+                    && findEquals(tline) == -1) {
+                domain = unescape(tline.substring(0, tline.length() - 1));
+
+                domains.add(domain);
+
+                keydomain = keydomains.containsKey(domain)
+                        || flatdomains.containsValue("keysections", domain);
+                
+                if (keydomain && !keydomains.containsKey(domain)) {
+                    keydomains.put(domain, new HashMap<String, String>());
+                } else if (!keydomain && !flatdomains.containsKey(domain)) {
+                    flatdomains.add(domain);
+                }
+            } else if (domain != null && keydomain
+                    && (offset = findEquals(tline)) != -1) {
+                final String key = unescape(tline.substring(0, offset));
+                final String value = unescape(tline.substring(offset + 1));
+
+                keydomains.get(domain).put(key, value);
+            } else if (domain != null && !keydomain) {
+                flatdomains.add(domain, unescape(tline));
+            } else {
+                throw new InvalidConfigFileException("Unknown or unexpected" +
+                        " line encountered: " + tline);
+            }
+        }
+    }
+
+    /**
+     * Writes the contents of this ConfigFile to disk.
+     * 
+     * @throws IOException if the write operation fails
+     */
+    public void write() throws IOException {
+        if (!isWritable()) {
+            throw new UnsupportedOperationException("Cannot write to a file "
+                    + "that isn't writable");
+        }
+        
+        final List<String> lines = new ArrayList<String>();
+
+        lines.add("# This is a DMDirc configuration file.");
+        lines.add("# Written on: " + new GregorianCalendar().getTime().toString());
+
+        writeMeta(lines);
+
+        for (String domain : domains) {
+            if ("keysections".equals(domain)) {
+                continue;
+            }
+
+            lines.add("");
+
+            lines.add(escape(domain) + ':');
+
+            if (flatdomains.containsKey(domain)) {
+                for (String entry : flatdomains.get(domain)) {
+                    lines.add("  " + escape(entry));
+                }
+            } else {
+                for (Map.Entry<String, String> entry : keydomains.get(domain).entrySet()) {
+                    lines.add("  " + escape(entry.getKey()) + "="
+                            + escape(entry.getValue()));
+                }
+            }
+        }
+
+        writeLines(lines);
+    }
+    
+    /**
+     * Appends the meta-data (keysections) to the specified list of lines.
+     * 
+     * @param lines The set of lines to be appended to
+     */
+    private void writeMeta(final List<String> lines) {
+        lines.add("");
+        lines.add("# This section indicates which sections below take key/value");
+        lines.add("# pairs, rather than a simple list. It should be placed above");
+        lines.add("# any sections that take key/values.");
+        lines.add("keysections:");
+
+        for (String domain : domains) {
+            if ("keysections".equals(domain)) {
+                continue;
+            } else if (keydomains.containsKey(domain)) {
+                lines.add("  " + domain);
+            }
+        }
+    }
+    
+    /**
+     * Retrieves all the key domains for this config file.
+     * 
+     * @return This config file's key domains
+     */
+    public Map<String, Map<String, String>> getKeyDomains() {
+        return keydomains;
+    }
+    
+    /**
+     * Retrieves the key/values of the specified key domain.
+     * 
+     * @param domain The domain to be retrieved
+     * @return A map of keys to values in the specified domain
+     */
+    public Map<String, String> getKeyDomain(final String domain) {
+        if (automake && !isKeyDomain(domain)) {
+            domains.add(domain);
+            keydomains.put(domain, new HashMap<String, String>());
+        }
+        
+        return keydomains.get(domain);
+    }
+    
+    /**
+     * Retrieves the content of the specified flat domain.
+     * 
+     * @param domain The domain to be retrieved
+     * @return A list of lines in the specified domain
+     */
+    public List<String> getFlatDomain(final String domain) {
+        return flatdomains.get(domain);
+    }
+    
+    /**
+     * Determines if this config file has the specified domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known, false otherwise
+     */
+    public boolean hasDomain(final String domain) {
+        return keydomains.containsKey(domain) || flatdomains.containsKey(domain);
+    }
+
+    /**
+     * Determines if this config file has the specified domain, and the domain
+     * is a key domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known and keyed, false otherwise
+     */
+    public boolean isKeyDomain(final String domain) {
+        return keydomains.containsKey(domain);
+    }
+
+    /**
+     * Determines if this config file has the specified domain, and the domain
+     * is a flat domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known and flat, false otherwise
+     */
+    public boolean isFlatDomain(final String domain) {
+        return flatdomains.containsKey(domain);
+    }
+    
+    /**
+     * Adds a new flat domain to this config file.
+     * 
+     * @param name The name of the domain to be added
+     * @param data The content of the domain
+     */
+    public void addDomain(final String name, final List<String> data) {
+        domains.add(name);
+        flatdomains.add(name, data);
+    }
+
+    /**
+     * Adds a new key domain to this config file.
+     * 
+     * @param name The name of the domain to be added
+     * @param data The content of the domain
+     */    
+    public void addDomain(final String name, final Map<String, String> data) {
+        domains.add(name);
+        keydomains.put(name, data);
+    }
+    
+    /**
+     * Unescapes any escaped characters in the specified input string.
+     * 
+     * @param input The string to unescape
+     * @return The string with all escape chars (\) resolved
+     */
+    protected static String unescape(final String input) {
+        boolean escaped = false;
+        final StringBuilder temp = new StringBuilder();
+
+        for (int i = 0; i < input.length(); i++) {
+            final char ch = input.charAt(i);
+
+            if (escaped) {
+                if (ch == 'n') {
+                    temp.append('\n');
+                } else if (ch == 'r') {
+                    temp.append('\r');
+                } else {
+                    temp.append(ch);
+                }
+                
+                escaped = false;
+            } else if (ch == '\\') {
+                escaped = true;
+            } else {
+                temp.append(ch);
+            }
+        }
+        
+        return temp.toString();
+    }
+    
+    /**
+     * Escapes the specified input string by prefixing all occurances of
+     * \, \n, \r, =, # and : with backslashes.
+     * 
+     * @param input The string to be escaped
+     * @return A backslash-armoured version of the string
+     */
+    protected static String escape(final String input) {
+        return input.replaceAll("\\\\", "\\\\\\\\").replaceAll("\n", "\\\\n")
+                .replaceAll("\r", "\\\\r").replaceAll("=", "\\\\=")
+                .replaceAll(":", "\\\\:").replaceAll("#", "\\\\#");
+    }
+    
+    /**
+     * Finds the first non-escaped instance of '=' in the specified string.
+     * 
+     * @param input The string to be searched
+     * @return The offset of the first non-escaped instance of '=', or -1.
+     */
+    protected static int findEquals(final String input) {
+        boolean escaped = false;
+        
+        for (int i = 0; i < input.length(); i++) {
+            if (escaped) {
+                escaped = false;
+            } else if (input.charAt(i) == '\\') {
+                escaped = true;
+            } else if (input.charAt(i) == '=') {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+}

src/com/dmdirc/util/InvalidConfigFileException.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+/**
+ * Thrown to indicate that a config file is invalid.
+ * @author chris
+ */
+public class InvalidConfigFileException extends Exception {
+    
+    /**
+     * A version number for this class. It should be changed whenever the class
+     * structure is changed (or anything else that would prevent serialized
+     * objects being unserialized with the new class).
+     */    
+    private static final long serialVersionUID = 1;
+
+    /**
+     * Creates a new InvalidConfigFileException.
+     * 
+     * @param string A description of the exception that occured.
+     */
+    public InvalidConfigFileException(String string) {
+        super(string);
+    }
+
+}

src/com/dmdirc/util/MapList.java

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Wraps a Map<S, List<T>> with various convenience methods for
+ * accessing the data. Implements a Map-like interface for easier transition.
+ * 
+ * @param <S> the type of keys maintained by this map
+ * @param <T> the type of mapped values
+ * @author chris
+ */
+public class MapList<S,T> {
+    
+    /** Our internal map. */
+    protected final Map<S, List<T>> map;
+
+    /**
+     * Creates a new, empty MapList.
+     */
+    public MapList() {
+        map = new HashMap<S, List<T>>();
+    }
+
+    /**
+     * Creates a new MapList with the values from the specified list.
+     * 
+     * @param list The MapList whose values should be used
+     */
+    public MapList(final MapList<S,T> list) {
+        map = list.getMap();
+    }
+
+    /**
+     * Determines if this MapList is empty. An empty MapList is one that either
+     * contains no keys, or contains only keys which have no associated values.
+     * 
+     * @return True if this MapList is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        for (List<T> list : map.values()) {
+            if (!list.isEmpty()) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+
+    /**
+     * Determines if this MapList contains the specified key.
+     * 
+     * @param key The key to look for
+     * @return True if this MapList contains the specified key, false otherwise
+     */
+    public boolean containsKey(final S key) {
+        return map.containsKey(key);
+    }
+
+    /**
+     * Determines if this MapList contains the specified value as a child of
+     * the specified key.
+     * 
+     * @param key The key to search under
+     * @param value The value to look for
+     * @return True if this MapList contains the specified key/value pair, 
+     * false otherwise
+     */
+    public boolean containsValue(final S key, final T value) {
+        return map.containsKey(key) && map.get(key).contains(value);
+    }
+
+    /**
+     * Retrieves the list of values associated with the specified key.
+     * 
+     * @param key The key whose values are being retrieved
+     * @return The values belonging to the specified key
+     */
+    public List<T> get(final S key) {
+        return map.get(key);
+    }
+    
+    /**
+     * Retrieves the value at the specified offset of the specified key.
+     * 
+     * @param key The key whose values are being retrieved
+     * @param index The index of the value to retrieve
+     * @return The specified value of the key
+     */    
+    public T get(final S key, final int index) {
+        return map.get(key).get(index);
+    }    
+    
+    /**
+     * Retrieves the list of values associated with the specified key, creating
+     * the key if neccessary.
+     * 
+     * @param key The key to retrieve
+     * @return A list of the specified key's values
+     */
+    public List<T> safeGet(final S key) {
+        if (!map.containsKey(key)) {
+            map.put(key, new ArrayList<T>());
+        }
+        
+        return map.get(key);
+    }
+    
+    /**
+     * Adds the specified key to the MapList.
+     * 
+     * @param key The key to be added
+     */
+    public void add(final S key) {
+        safeGet(key);
+    }    
+
+    /**
+     * Adds the specified value as a child of the specified key. If the key
+     * didn't previous exist, it is created.
+     * 
+     * @param key The key to which the value is being added
+     * @param value The value to be added
+     */
+    public void add(final S key, final T value) {
+        safeGet(key).add(value);
+    }
+
+    /**
+     * Adds the specified set of values to the specified key. If the key
+     * didn't previous exist, it is created.
+     * 
+     * @param key The key to which the value is being added
+     * @param values The values to be added
+     */    
+    public void add(final S key, final Collection<T> values) {
+        safeGet(key).addAll(values);
+    }    
+
+    /**
+     * Removes the specified key and all of its values.
+     * 
+     * @param key The key to remove
+     */    
+    public void remove(final S key) {
+        map.remove(key);
+    }
+    
+    /**
+     * Removes the specified value from all keys.
+     * 
+     * @param value The value to remove
+     */
+    public void removeFromAll(final T value) {
+        for (List<T> list : map.values()) {
+            list.remove(value);
+        }
+    }
+
+    /**
+     * Removes the specified value from the specified key.
+     * 
+     * @param key The key whose value is being removed
+     * @param value The value to be removed
+     */
+    public void remove(final S key, final T value) {
+        if (map.containsKey(key)) {
+            map.get(key).remove(value);
+        }
+    }    
+
+    /**
+     * Entirely clears this MapList.
+     */
+    public void clear() {
+        map.clear();
+    }
+    
+    /**
+     * Clears all values of the specified key.
+     * 
+     * @param key The key to be cleared
+     */
+    public void clear(final S key) {
+        safeGet(key).clear();
+    }    
+
+    /**
+     * Returns the set of all keys belonging to this MapList.
+     * 
+     * @return This MapList's keyset
+     */
+    public Set<S> keySet() {
+        return map.keySet();
+    }
+
+    /**
+     * Returns a collection of all values belonging to the specified key.
+     * 
+     * @param key The key whose values are being sought
+     * @return A collection of values belonging to the key
+     */
+    public Collection<T> values(final S key) {
+        return map.get(key);
+    }
+    
+    /**
+     * Retrieves the entry set for this MapList.
+     * 
+     * @return This MapList's entry set
+     */
+    public Set<Map.Entry<S, List<T>>> entrySet() {
+        return map.entrySet();
+    }
+    
+    /**
+     * Retrieves the map behind this maplist.
+     * 
+     * @return This MapList's map.
+     */
+    public Map<S, List<T>> getMap() {
+        return new HashMap<S, List<T>>(map);
+    }
+
+}

src/com/dmdirc/util/TextFile.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Allows reading and writing to a plain text file via a list of lines.
+ * 
+ * @author chris
+ */
+public class TextFile {
+    
+    /** The file we're dealing with. */
+    private File file;
+    
+    /** The input stream we're dealing with. */
+    private InputStream is;
+    
+    /** The lines we've read from the file. */
+    private List<String> lines;
+
+    /** The charset to use to read the file. */
+    private final Charset charset;
+    
+    /**
+     * Creates a new instance of TextFile for the specified file, and uses the
+     * default charset.
+     * 
+     * @param filename The file to be read/written
+     */
+    public TextFile(final String filename) {
+        this(new File(filename));
+    }
+
+    /**
+     * Creates a new instance of TextFile for the specified File, and uses the
+     * default charset.
+     * 
+     * @param file The file to read
+     */
+    public TextFile(final File file) {
+        this(file, Charset.defaultCharset());
+    }
+    
+    /**
+     * Creates a new instance of TextFile for an input stream, and uses the
+     * default charset.
+     * 
+     * @param is The input stream to read from
+     */
+    public TextFile(final InputStream is) {
+        this(is, Charset.defaultCharset());
+    }
+
+    /**
+     * Creates a new instance of TextFile for the specified File, which is to
+     * be read using the specified charset.
+     *
+     * @param file The file to read
+     * @param charset The charset to read the file in
+     * @since 0.6.3
+     */
+    public TextFile(final File file, final Charset charset) {
+        this.file = file;
+        this.charset = charset;
+    }
+
+    /**
+     * Creates a new instance of TextFile for an input stream, which is to
+     * be read using the specified charset.
+     *
+     * @param is The input stream to read from
+     * @param charset The charset to read the file in
+     * @since 0.6.3
+     */
+    public TextFile(final InputStream is, final Charset charset) {
+        this.is = is;
+        this.charset = charset;
+    }
+    
+    /**
+     * Retrieves the contents of the file as a list of lines. If getLines() or
+     * readLines() has previously been called, a cached version is returned.
+     * 
+     * @return A list of lines in the file
+     * @throws IOException if an I/O exception occurs
+     */
+    public List<String> getLines() throws IOException {
+        if (lines == null) {
+            readLines();
+        }
+        
+        return lines;
+    }
+    
+    /**
+     * Reads the contents of the file into this TextFile's line cache.
+     * 
+     * @throws IOException If an I/O exception occurs
+     */
+    public void readLines() throws IOException {
+        final BufferedReader reader = new BufferedReader(
+                new InputStreamReader(file == null ? is : new FileInputStream(file),
+                charset));
+        lines = new ArrayList<String>();
+        
+        String line;
+        
+        while ((line = reader.readLine()) != null) {
+            lines.add(line);
+        }
+        
+        reader.close();
+    }
+    
+    /**
+     * Determines if this file is writable or not.
+     * 
+     * @return True if the file is writable, false otherwise
+     */
+    public boolean isWritable() {
+        return file != null;
+    }
+    
+    /**
+     * Writes the specified list of lines to the file.
+     * 
+     * @param lines The lines to be written
+     * @throws IOException if an I/O exception occurs
+     */
+    public void writeLines(final List<String> lines) throws IOException {
+        if (file == null) {
+            throw new UnsupportedOperationException("Cannot write to TextFile "
+                    + "opened with an InputStream");
+        }
+        
+        final BufferedWriter writer = new BufferedWriter(new FileWriter(file));
+        
+        for (String line : lines) {
+            writer.write(line);
+            writer.newLine();
+        }
+        
+        writer.close();
+    }
+
+    /**
+     * Retrieves the File for this TextFile, if there is one.
+     * 
+     * @return This TextFile's file, or null
+     */
+    public File getFile() {
+        return file;
+    }
+    
+    /**
+     * Deletes the file associated with this textfile, if there is one.
+     */
+    public void delete() {
+        if (file == null) {
+            throw new UnsupportedOperationException("Cannot delete TextFile "
+                    + "opened with an InputStream");
+        }
+        
+        file.delete();
+    }
+
+}

src/com/md87/charliebravo/CharlieBravo.java

@@ -19,7 +19,8 @@ import com.dmdirc.parser.irc.callbacks.interfaces.IPost005;
  */
 public class CharlieBravo implements Runnable, IPost005, IDebugInfo, IDataIn, IDataOut {
 
-    protected final InputHandler handler = new InputHandler();
+    protected final Config config = new Config();
+    protected final InputHandler handler = new InputHandler(config);
     
     public void run() {
         while (true) {
@@ -41,6 +42,7 @@ public class CharlieBravo implements Runnable, IPost005, IDebugInfo, IDataIn, ID
 
     public void onPost005(final IRCParser tParser) {
         tParser.joinChannel("#MD87");
+        tParser.joinChannel("#MDbot");
     }
 
     public void onDebugInfo(final IRCParser tParser, final int nLevel, final String sData) {

src/com/md87/charliebravo/Config.java

@@ -0,0 +1,92 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo;
+
+import com.dmdirc.util.ConfigFile;
+import com.dmdirc.util.InvalidConfigFileException;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author chris
+ */
+public class Config implements Runnable {
+    
+    private static final String FS = System.getProperty("file.separator");
+
+    private static final String FILE = System.getProperty("user.home") + FS + ".charliebravo";
+
+    private static final List<String> SETTINGS = Arrays.asList(new String[] {
+        "eve.apikey:String", "eve.userid:int", "eve.charid:int",
+        "admin.level:int",
+        "internal.lastseen:int", "internal.lastuser:String"
+    });
+
+    protected final ConfigFile configfile;
+
+    public Config() {
+        final File file = new File(FILE);
+
+        configfile = new ConfigFile(file);
+        configfile.setAutomake(true);
+
+        try {
+            if (file.exists()) {
+                configfile.read();
+            }
+        } catch (IOException ex) {
+            // Ignore
+        } catch (InvalidConfigFileException ex) {
+            // Ignore
+        }
+
+        Runtime.getRuntime().addShutdownHook(new Thread(this));
+    }
+
+    public boolean isLegalSetting(final String key) {
+        return getType(key) != null;
+    }
+
+    public String getType(final String key) {
+        for (String setting : SETTINGS) {
+            if (setting.startsWith(key + ":")) {
+                return setting.substring(setting.indexOf(':') + 1);
+            }
+        }
+
+        return null;
+    }
+
+    public boolean hasOption(final String user, final String key) {
+        return configfile.isKeyDomain(user) && configfile.getKeyDomain(user).containsKey(key);
+    }
+
+    public String getOption(final String user, final String key) {
+        return configfile.getKeyDomain(user).get(key);
+    }
+
+    public String setOption(final String user, final String key, final Object obj) {
+        final String value = String.valueOf(obj);
+        
+        if (getType(key).equals("int") && !value.matches("^[0-9]+$")) {
+            throw new IllegalArgumentException("That setting must be an integer");
+        }
+
+        return configfile.getKeyDomain(user).put(key, value);
+    }
+
+    public void run() {
+        try {
+            configfile.write();
+        } catch (IOException ex) {
+            // Uh oh
+        }
+    }
+
+}

src/com/md87/charliebravo/Formatter.java

@@ -0,0 +1,63 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo;
+
+/**
+ *
+ * @author chris
+ */
+public class Formatter {
+
+    /**
+     * Tests for and adds one component of the duration format.
+     *
+     * @param builder The string builder to append text to
+     * @param current The number of seconds in the duration
+     * @param duration The number of seconds in this component
+     * @param name The name of this component
+     * @return The number of seconds used by this component
+     */
+    private static int doDuration(final StringBuilder builder, final int current,
+            final int duration, final String name) {
+        int res = 0;
+
+        if (current >= duration) {
+            final int units = current / duration;
+            res = units * duration;
+
+            if (builder.length() > 0) {
+                builder.append(", ");
+            }
+
+            builder.append(units);
+            builder.append(' ');
+            builder.append(name + (units != 1 ? 's' : ""));
+        }
+
+        return res;
+    }
+
+    /**
+     * Formats the specified number of seconds as a string containing the
+     * number of days, hours, minutes and seconds.
+     *
+     * @param duration The duration in seconds to be formatted
+     * @return A textual version of the duration
+     */
+    public static String formatDuration(final int duration) {
+        final StringBuilder buff = new StringBuilder();
+
+        int seconds = duration;
+
+        seconds -= doDuration(buff, seconds, 60*60*24, "day");
+        seconds -= doDuration(buff, seconds, 60*60, "hour");
+        seconds -= doDuration(buff, seconds, 60, "minute");
+        seconds -= doDuration(buff, seconds, 1, "second");
+
+        return buff.toString();
+    }
+
+}

src/com/md87/charliebravo/InputHandler.java

@@ -14,9 +14,14 @@ import com.dmdirc.parser.irc.callbacks.interfaces.IPrivateMessage;
 import com.md87.charliebravo.commands.AuthenticateCommand;
 import com.md87.charliebravo.commands.CalcCommand;
 import com.md87.charliebravo.commands.FollowupsCommand;
+import com.md87.charliebravo.commands.GitCommand;
 import com.md87.charliebravo.commands.GoogleCommand;
 import com.md87.charliebravo.commands.HelpCommand;
+import com.md87.charliebravo.commands.IssueCommand;
 import com.md87.charliebravo.commands.QuitCommand;
+import com.md87.charliebravo.commands.SetCommand;
+import com.md87.charliebravo.commands.TranslateCommand;
+import com.md87.charliebravo.commands.WhoisCommand;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -30,16 +35,29 @@ public class InputHandler implements IChannelMessage, IPrivateMessage {
 
     protected IRCParser parser;
 
+    protected final Config config;
+
     protected final List<Command> commands = new ArrayList<Command>();
     protected final Map<String, Response> responses = new HashMap<String, Response>();
 
-    public InputHandler() {
+    public InputHandler(final Config config) {
+        this.config = config;
+        
         commands.add(new GoogleCommand());
         commands.add(new QuitCommand());
         commands.add(new HelpCommand());
         commands.add(new FollowupsCommand());
         commands.add(new AuthenticateCommand());
         commands.add(new CalcCommand());
+        commands.add(new WhoisCommand());
+        commands.add(new TranslateCommand());
+        commands.add(new IssueCommand());
+        commands.add(new GitCommand());
+        commands.add(new SetCommand());
+    }
+
+    public Config getConfig() {
+        return config;
     }
 
     public List<Command> getCommands() {

src/com/md87/charliebravo/commands/AuthenticateCommand.java

@@ -32,6 +32,10 @@ public class AuthenticateCommand implements Command {
                 final String openid = result.get(1).trim();
                 handler.getParser().getClientInfoOrFake(response.getSource())
                         .getMap().put("OpenID", openid);
+                handler.getConfig().setOption(openid, "internal.lastseen",
+                        System.currentTimeMillis());
+                handler.getConfig().setOption(openid, "internal.lastuser",
+                        handler.getParser().getClientInfoOrFake(response.getSource()).toString());
                 response.sendMessage("You are now authenticated as " + openid, true);
             }
         }

src/com/md87/charliebravo/commands/GitCommand.java

@@ -0,0 +1,124 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo.commands;
+
+import com.dmdirc.util.Downloader;
+import com.md87.charliebravo.Command;
+import com.md87.charliebravo.Followup;
+import com.md87.charliebravo.InputHandler;
+import com.md87.charliebravo.Response;
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ * @author chris
+ */
+public class GitCommand implements Command {
+
+    public void execute(InputHandler handler, Response response, String line) throws Exception {
+        if (line.isEmpty()) {
+            response.sendMessage("You need to specify a revision", true);
+        } else {
+            final List<String> result = Downloader.getPage(
+                    "http://git.dmdirc.com/cgit.cgi/client/commit/?id="
+                    + URLEncoder.encode(line, Charset.defaultCharset().name()));
+            final StringBuilder builder = new StringBuilder();
+
+            for (String resline : result) {
+                builder.append(resline);
+            }
+
+            if (builder.indexOf("<div class=\"error\">Bad object id:") > -1) {
+                response.sendMessage("That commit was not found", true);
+            } else {
+                Matcher matcher = Pattern.compile("<th>author</th>"
+                        + "<td>(.*?) &lt;(.*?)&gt;</td><td class='right'>(.*?)</td>")
+                        .matcher(builder);
+                matcher.find();
+                final String authorName = matcher.group(1);
+                final String authorEmail = matcher.group(2);
+                final String commitDate = matcher.group(3);
+
+                matcher = Pattern.compile("<th>commit</th><td colspan='2' class='sha1'>"
+                        + "<a href='/cgit.cgi/client/commit/\\?id=(.*?)'>").matcher(builder);
+                matcher.find();
+                final String commitHash = matcher.group(1);
+
+                matcher = Pattern.compile("<div class='commit-subject'>(.*?)</div>")
+                        .matcher(builder);
+                matcher.find();
+                final String commitSubject = matcher.group(1);
+                
+                matcher = Pattern.compile("<div class='diffstat-summary'>(.*?)</div>")
+                        .matcher(builder);
+                matcher.find();
+                final String commitDiff = matcher.group(1);
+
+                response.sendMessage("commit " + commitHash + " was made by "
+                        + authorName + " with message '" + commitSubject + "'");
+                response.addFollowup(new DiffFollowup(commitDiff, commitHash));
+                response.addFollowup(new DetailsFollowup(authorName, authorEmail,
+                        commitHash, commitDate));
+            }
+            
+        }
+
+    }
+
+    protected static class DiffFollowup implements Followup {
+
+        private final String data;
+        private final String hash;
+
+        public DiffFollowup(String data, String hash) {
+            this.data = data;
+            this.hash = hash;
+        }
+
+        public boolean matches(String line) {
+            return line.equalsIgnoreCase("diff");
+        }
+
+        public void execute(InputHandler handler, Response response, String line) throws Exception {
+            response.setInheritFollows(true);
+            response.sendMessage("there were " + data.replaceAll("^(.*), (.*?)$", "$1 and $2")
+                    + " in commit "
+                    + hash + ". See http://git.dmdirc.com/cgit.cgi/client/diff/?id=" + hash);
+        }
+
+    }
+
+    protected static class DetailsFollowup implements Followup {
+
+        private final String authorName, authorEmail, hash, time;
+
+        public DetailsFollowup(String authorName, String authorEmail, String hash, String time) {
+            this.authorName = authorName;
+            this.authorEmail = authorEmail;
+            this.hash = hash;
+            this.time = time;
+        }
+
+        public boolean matches(String line) {
+            return line.equalsIgnoreCase("details");
+        }
+
+        public void execute(InputHandler handler, Response response, String line) throws Exception {
+            response.setInheritFollows(true);
+            response.sendMessage("commit " + hash + " was made on " + time + " by "
+                    + authorName + " <" + authorEmail + ">. " +
+                    "See http://git.dmdirc.com/cgit.cgi/client/commit/?id=" + hash);
+        }
+
+    }
+
+}

src/com/md87/charliebravo/commands/IssueCommand.java

@@ -0,0 +1,86 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo.commands;
+
+import com.dmdirc.util.Downloader;
+import com.md87.charliebravo.Command;
+import com.md87.charliebravo.Followup;
+import com.md87.charliebravo.InputHandler;
+import com.md87.charliebravo.Response;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ * @author chris
+ */
+public class IssueCommand implements Command {
+
+    public void execute(InputHandler handler, Response response, String line) throws Exception {
+        if (line.isEmpty() || !line.matches("^[0-9]+$")) {
+            response.sendMessage("You need to specify an issue number", true);
+        } else {
+            final List<String> result = Downloader.getPage("http://bugs.dmdirc.com/view.php?id="
+                    + line);
+            final StringBuilder builder = new StringBuilder();
+
+            for (String resline : result) {
+                builder.append(resline);
+            }
+
+            if (builder.indexOf("APPLICATION ERROR #1100") > -1) {
+                response.sendMessage("That issue was not found", true);
+            } else if (builder.indexOf("<p>Access Denied.</p>") > -1) {
+                response.sendMessage("that issue is private. Please see "
+                        + "http://bugs.dmdirc.com/view/" + line);
+            } else {
+                final Map<String, String> data = new HashMap<String, String>();
+
+                final Pattern pattern = Pattern.compile(
+                        "<td class=\"category\".*?>\\s*(.*?)\\s*"
+                        + "</td>\\s*(?:<!--.*?-->\\s*)?<td.*?>\\s*(.*?)\\s*</td>",
+                        Pattern.CASE_INSENSITIVE + Pattern.DOTALL);
+                final Matcher matcher = pattern.matcher(builder);
+
+                while (matcher.find()) {
+                    data.put(matcher.group(1).toLowerCase(), matcher.group(2));
+                }
+
+                response.sendMessage("issue " + data.get("id") + " is \""
+                        + data.get("summary").substring(9) + "\". Current "
+                        + "status is " + data.get("status") + " ("
+                        + data.get("resolution") + ")");
+                response.addFollowup(new IssueFollowup(data));
+            }
+            
+        }
+
+    }
+
+    protected static class IssueFollowup implements Followup {
+
+        private final Map<String, String> data;
+
+        public IssueFollowup(Map<String, String> data) {
+            this.data = data;
+        }
+
+        public boolean matches(String line) {
+            return data.containsKey(line.toLowerCase());
+        }
+
+        public void execute(InputHandler handler, Response response, String line) throws Exception {
+            response.setInheritFollows(true);
+            response.sendMessage("the " + line.toLowerCase() + " of issue "
+                    + data.get("id") + " is: " + data.get(line.toLowerCase()));
+        }
+
+    }
+
+}

src/com/md87/charliebravo/commands/SetCommand.java

@@ -0,0 +1,40 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo.commands;
+
+import com.md87.charliebravo.Command;
+import com.md87.charliebravo.InputHandler;
+import com.md87.charliebravo.Response;
+
+/**
+ *
+ * @author chris
+ */
+public class SetCommand implements Command {
+
+    public void execute(InputHandler handler, Response response, String line) throws Exception {
+        final String openID = (String) handler.getParser().getClientInfoOrFake(response.getSource())
+                .getMap().get("OpenID");
+
+        final String[] parts = line.split("\\s+", 2);
+
+        if (openID == null) {
+            response.sendMessage("You must be authorised to use this command", true);
+        } else if (parts.length < 2) {
+            response.sendMessage("You must specify a setting name and value", true);
+        } else if (!handler.getConfig().isLegalSetting(parts[0])) {
+            response.sendMessage("That isn't a legal setting", true);
+        } else if (parts[0].startsWith("admin.")
+                && (!handler.getConfig().hasOption(openID, "admin.level")
+                || Integer.parseInt(handler.getConfig().getOption(openID, "admin.level")) < 100)) {
+            response.sendMessage("You do not have sufficient access", true);
+        } else {
+            handler.getConfig().setOption(openID, parts[0], parts[1]);
+            response.sendMessage("OK", true);
+        }
+    }
+
+}

src/com/md87/charliebravo/commands/TranslateCommand.java

@@ -0,0 +1,188 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo.commands;
+
+import com.md87.charliebravo.Command;
+import com.md87.charliebravo.Followup;
+import com.md87.charliebravo.InputHandler;
+import com.md87.charliebravo.Response;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ *
+ * @author chris
+ */
+public class TranslateCommand implements Command {
+
+    protected static final String[][] LANGUAGES = {
+        {"AFRIKAANS", "af"},
+        {"ALBANIAN", "sq"},
+        {"AMHARIC", "am"},
+        {"ARABIC", "ar"},
+        {"ARMENIAN", "hy"},
+        {"AZERBAIJANI", "az"},
+        {"BASQUE", "eu"},
+        {"BELARUSIAN", "be"},
+        {"BENGALI", "bn"},
+        {"BIHARI", "bh"},
+        {"BULGARIAN", "bg"},
+        {"BURMESE", "my"},
+        {"CATALAN", "ca"},
+        {"CHEROKEE", "chr"},
+        {"CHINESE", "zh"},
+        {"CHINESE (SIMPLIFIED)", "zh-CN"},
+        {"CHINESE (TRADITIONAL)", "zh-TW"},
+        {"SIMPLIFIED CHINESE", "zh-CN"},
+        {"TRADITIONAL CHINESE", "zh-TW"},
+        {"CROATIAN", "hr"},
+        {"CZECH", "cs"},
+        {"DANISH", "da"},
+        {"DHIVEHI", "dv"},
+        {"DUTCH", "nl"},
+        {"ENGLISH", "en"},
+        {"ESPERANTO", "eo"},
+        {"ESTONIAN", "et"},
+        {"FILIPINO", "tl"},
+        {"FINNISH", "fi"},
+        {"FRENCH", "fr"},
+        {"GALICIAN", "gl"},
+        {"GEORGIAN", "ka"},
+        {"GERMAN", "de"},
+        {"GREEK", "el"},
+        {"GUARANI", "gn"},
+        {"GUJARATI", "gu"},
+        {"HEBREW", "iw"},
+        {"HINDI", "hi"},
+        {"HUNGARIAN", "hu"},
+        {"ICELANDIC", "is"},
+        {"INDONESIAN", "id"},
+        {"INUKTITUT", "iu"},
+        {"ITALIAN", "it"},
+        {"JAPANESE", "ja"},
+        {"KANNADA", "kn"},
+        {"KAZAKH", "kk"},
+        {"KHMER", "km"},
+        {"KOREAN", "ko"},
+        {"KURDISH", "ku"},
+        {"KYRGYZ", "ky"},
+        {"LAOTHIAN", "lo"},
+        {"LATVIAN", "lv"},
+        {"LITHUANIAN", "lt"},
+        {"MACEDONIAN", "mk"},
+        {"MALAY", "ms"},
+        {"MALAYALAM", "ml"},
+        {"MALTESE", "mt"},
+        {"MARATHI", "mr"},
+        {"MONGOLIAN", "mn"},
+        {"NEPALI", "ne"},
+        {"NORWEGIAN", "no"},
+        {"ORIYA", "or"},
+        {"PASHTO", "ps"},
+        {"PERSIAN", "fa"},
+        {"POLISH", "pl"},
+        {"PORTUGUESE", "pt-PT"},
+        {"PUNJABI", "pa"},
+        {"ROMANIAN", "ro"},
+        {"RUSSIAN", "ru"},
+        {"SANSKRIT", "sa"},
+        {"SERBIAN", "sr"},
+        {"SINDHI", "sd"},
+        {"SINHALESE", "si"},
+        {"SLOVAK", "sk"},
+        {"SLOVENIAN", "sl"},
+        {"SPANISH", "es"},
+        {"SWAHILI", "sw"},
+        {"SWEDISH", "sv"},
+        {"TAJIK", "tg"},
+        {"TAMIL", "ta"},
+        {"TAGALOG", "tl"},
+        {"TELUGU", "te"},
+        {"THAI", "th"},
+        {"TIBETAN", "bo"},
+        {"TURKISH", "tr"},
+        {"UKRAINIAN", "uk"},
+        {"URDU", "ur"},
+        {"UZBEK", "uz"},
+        {"UIGHUR", "ug"},
+        {"VIETNAMESE", "vi"},
+    };
+
+    public void execute(final InputHandler handler, Response response, String line) throws MalformedURLException, IOException, JSONException {
+        String target = "en";
+        String text = line;
+        int offset;
+
+        if ((offset = text.lastIndexOf(" into ")) > -1) {
+            final String lang = text.substring(offset + 6);
+
+            for (String[] pair : LANGUAGES) {
+                if (pair[0].equalsIgnoreCase(lang)) {
+                    target = pair[1];
+                    text = text.substring(0, offset);
+                }
+            }
+        }
+
+        URL url = new URL("http://ajax.googleapis.com/ajax/services/language/translate?v=1.0&langpair=%7C" + target + "&q=" +
+                URLEncoder.encode(text, Charset.defaultCharset().name()));
+        URLConnection connection = url.openConnection();
+        connection.addRequestProperty("Referer", "http://chris.smith.name/");
+
+        String input;
+        StringBuilder builder = new StringBuilder();
+        BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+        while((input = reader.readLine()) != null) {
+            builder.append(input);
+        }
+
+        JSONObject json = new JSONObject(builder.toString());
+        if (json.getInt("responseStatus") != 200) {
+            throw new IOException(json.getString("responseDetails"));
+        }
+
+        response.sendMessage("that translates to \""
+                + json.getJSONObject("responseData").getString("translatedText") + "\"");
+        response.addFollowup(new LanguageFollowup(json.getJSONObject("responseData")));
+    }
+
+    protected static class LanguageFollowup implements Followup {
+
+        private final JSONObject result;
+
+        public LanguageFollowup(JSONObject result) {
+            this.result = result;
+        }
+
+        public boolean matches(String line) {
+            return line.equals("language");
+        }
+
+        public void execute(final InputHandler handler, Response response, String line) throws Exception {
+            final String target = result.getString("detectedSourceLanguage");
+            for (String[] pair : LANGUAGES) {
+                if (pair[1].equalsIgnoreCase(target)) {
+                    response.sendMessage("the language was detected as "
+                            + pair[0].charAt(0) + pair[0].substring(1).toLowerCase());
+                    return;
+                }
+            }
+            
+            response.sendMessage("the language was detected as '"
+                    + target + "', but I don't know what that is");
+        }
+
+    }
+
+}

src/com/md87/charliebravo/commands/WhoisCommand.java

@@ -0,0 +1,67 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.md87.charliebravo.commands;
+
+import com.dmdirc.parser.irc.ClientInfo;
+import com.md87.charliebravo.Command;
+import com.md87.charliebravo.Formatter;
+import com.md87.charliebravo.InputHandler;
+import com.md87.charliebravo.Response;
+
+/**
+ *
+ * @author chris
+ */
+public class WhoisCommand implements Command {
+
+    @SuppressWarnings("unchecked")
+    public void execute(InputHandler handler, Response response, String line) throws Exception {
+        if (line.isEmpty()) {
+            response.sendRawMessage("Who would you like to whois, " + response.getSource() + "?");
+        } else {
+            final ClientInfo ci = handler.getParser().getClientInfo(line);
+
+            if (ci == null) {
+                if (handler.getConfig().hasOption(line, "internal.lastseen")) {
+                    final StringBuilder extra = new StringBuilder();
+
+                    if (handler.getConfig().hasOption(line, "admin.level")) {
+                        extra.append(", and has access level ");
+                        extra.append(handler.getConfig().getOption(line, "admin.level"));
+                    }
+
+                    response.sendMessage(line + " last authenticated with me "
+                            + Formatter.formatDuration((int)
+                            (System.currentTimeMillis() -
+                            Long.valueOf(handler.getConfig().getOption(line, "internal.lastseen")))
+                            / 1000)
+                            + " ago" + extra);
+                } else {
+                    response.sendMessage("I am not aware of anyone by that name", true);
+                }
+            } else {
+                final String openid = (String) ci.getMap().get("OpenID");
+
+                if (openid == null) {
+                    response.sendMessage(ci.getNickname() + " has not authenticated with me", true);
+                } else {
+                    final StringBuilder extra = new StringBuilder();
+
+                    if (handler.getConfig().hasOption(openid, "admin.level")) {
+                        extra.append(", and has access level ");
+                        extra.append(handler.getConfig().getOption(openid, "admin.level"));
+                    }
+
+                    response.sendMessage((ci.getNickname().equals(response.getSource()) ?
+                            "you are " : ci.getNickname() + " is")
+                            + " authenticated as " + openid + extra);
+                }
+            }
+        }
+
+    }
+
+}