gitlab-pygments.rb 0.3.2

data/vendor/pygments-main/tests/examplefiles/AcidStateAdvanced.hs

@@ -0,0 +1,209 @@
+{-# LANGUAGE DeriveDataTypeable, FlexibleContexts, GeneralizedNewtypeDeriving
+  , MultiParamTypeClasses, OverloadedStrings, ScopedTypeVariables, TemplateHaskell
+  , TypeFamilies, FlexibleInstances #-}
+module Main where
+import Control.Applicative  (Applicative, Alternative, (<$>))
+import Control.Exception.Lifted    (bracket)
+import Control.Monad.Trans.Control (MonadBaseControl)
+import Control.Monad        (MonadPlus, mplus)
+import Control.Monad.Reader (MonadReader, ReaderT(..), ask)
+import Control.Monad.Trans  (MonadIO(..))
+import Data.Acid            ( AcidState(..), EventState(..), EventResult(..)
+                            , Query(..), QueryEvent(..), Update(..), UpdateEvent(..)
+                            , IsAcidic(..), makeAcidic, openLocalState
+                            )
+import Data.Acid.Local      ( createCheckpointAndClose
+                            , openLocalStateFrom
+                            )
+import Data.Acid.Advanced   (query', update')
+import Data.Maybe           (fromMaybe)
+import Data.SafeCopy        (SafeCopy, base, deriveSafeCopy)
+import Data.Data            (Data, Typeable)
+import Data.Lens            ((%=), (!=))
+import Data.Lens.Template   (makeLens)
+import Data.Text.Lazy       (Text)
+import Happstack.Server     ( Happstack, HasRqData, Method(GET, POST), Request(rqMethod)
+                            , Response
+                            , ServerPartT(..), WebMonad, FilterMonad, ServerMonad
+                            , askRq, decodeBody, dir, defaultBodyPolicy, lookText
+                            , mapServerPartT, nullConf, nullDir, ok, simpleHTTP
+                            , toResponse
+                            )
+import Prelude hiding       (head, id)
+import System.FilePath      ((</>))
+import Text.Blaze           ((!))
+import Text.Blaze.Html4.Strict (body, head, html, input, form, label, p, title, toHtml)
+import Text.Blaze.Html4.Strict.Attributes (action, enctype, for, id, method, name, type_, value)
+class HasAcidState m st where
+   getAcidState :: m (AcidState st)
+query :: forall event m. 
+         ( Functor m
+         , MonadIO m
+         , QueryEvent event
+         , HasAcidState m (EventState event)
+         ) => 
+         event
+      -> m (EventResult event)
+query event =
+    do as <- getAcidState
+       query' (as :: AcidState (EventState event)) event
+update :: forall event m. 
+          ( Functor m
+          , MonadIO m
+          , UpdateEvent event
+          , HasAcidState m (EventState event)
+          ) => 
+          event 
+       -> m (EventResult event)
+update event =
+    do as <- getAcidState
+       update' (as :: AcidState (EventState event)) event
+-- | bracket the opening and close of the `AcidState` handle. 
+
+-- automatically creates a checkpoint on close
+withLocalState :: (MonadBaseControl IO m, MonadIO m, IsAcidic st, Typeable st) => 
+                  Maybe FilePath           -- ^ path to state directory
+                 -> st                     -- ^ initial state value
+                 -> (AcidState st -> m a) -- ^ function which uses the `AcidState` handle
+                 -> m a
+withLocalState mPath initialState =
+    bracket (liftIO $ (maybe openLocalState openLocalStateFrom mPath) initialState)
+            (liftIO . createCheckpointAndClose)
+-- State that stores a hit count
+
+data CountState = CountState { _count :: Integer }
+                deriving (Eq, Ord, Data, Typeable, Show)
+
+$(deriveSafeCopy 0 'base ''CountState)
+$(makeLens ''CountState)
+
+initialCountState :: CountState
+initialCountState = CountState { _count = 0 }
+
+incCount :: Update CountState Integer
+incCount = count %= succ
+
+$(makeAcidic ''CountState ['incCount])
+-- State that stores a greeting
+data GreetingState = GreetingState {  _greeting :: Text }
+                deriving (Eq, Ord, Data, Typeable, Show)
+
+$(deriveSafeCopy 0 'base ''GreetingState)
+$(makeLens ''GreetingState)
+
+initialGreetingState :: GreetingState
+initialGreetingState = GreetingState { _greeting = "Hello" }
+
+getGreeting :: Query GreetingState Text
+getGreeting = _greeting <$> ask
+
+setGreeting :: Text -> Update GreetingState Text
+setGreeting txt = greeting != txt
+
+$(makeAcidic ''GreetingState ['getGreeting, 'setGreeting])
+data Acid = Acid { acidCountState    :: AcidState CountState
+                 , acidGreetingState :: AcidState GreetingState
+                 }
+
+withAcid :: Maybe FilePath -> (Acid -> IO a) -> IO a
+withAcid mBasePath action =
+    let basePath = fromMaybe "_state" mBasePath
+    in withLocalState (Just $ basePath </> "count")    initialCountState    $ \c ->
+       withLocalState (Just $ basePath </> "greeting") initialGreetingState $ \g ->
+           action (Acid c g)
+newtype App a = App { unApp :: ServerPartT (ReaderT Acid IO) a }
+    deriving ( Functor, Alternative, Applicative, Monad, MonadPlus, MonadIO
+               , HasRqData, ServerMonad ,WebMonad Response, FilterMonad Response
+               , Happstack, MonadReader Acid)
+
+runApp :: Acid -> App a -> ServerPartT IO a
+runApp acid (App sp) = mapServerPartT (flip runReaderT acid) sp
+instance HasAcidState App CountState where
+    getAcidState = acidCountState    <$> ask 
+
+instance HasAcidState App GreetingState where
+    getAcidState = acidGreetingState <$> ask
+page :: App Response
+page =
+    do nullDir
+       g <- greet
+       c <- update IncCount -- ^ a CountState event
+       ok $ toResponse $
+          html $ do
+            head $ do
+              title "acid-state demo"
+            body $ do
+              form ! action "/" ! method "POST" ! enctype "multipart/form-data" $ do
+                label "new message: " ! for "msg"
+                input ! type_ "text" ! id "msg" ! name "greeting"
+                input ! type_ "submit" ! value "update message"
+              p $ toHtml g
+              p $ do "This page has been loaded " 
+                     toHtml c
+                     " time(s)."
+    where
+    greet =
+        do m <- rqMethod <$> askRq
+           case m of
+             POST -> 
+                 do decodeBody (defaultBodyPolicy "/tmp/" 0 1000 1000)
+                    newGreeting <- lookText "greeting"
+                    update (SetGreeting newGreeting)   -- ^ a GreetingState event
+                    return newGreeting
+             GET  -> 
+                 do query GetGreeting                  -- ^ a GreetingState event
+main :: IO ()
+main =
+    withAcid Nothing $ \acid ->
+        simpleHTTP nullConf $ runApp acid page
+newtype FooState = FooState { foo :: Text }
+    deriving (Eq, Ord, Data, Typeable, SafeCopy)
+
+initialFooState :: FooState
+initialFooState = FooState { foo = "foo" }
+
+askFoo :: Query FooState Text
+askFoo = foo <$> ask
+
+$(makeAcidic ''FooState ['askFoo])
+fooPlugin :: (Happstack m, HasAcidState m FooState) => m Response
+fooPlugin =
+    dir "foo" $ do
+       txt <- query AskFoo
+       ok $ toResponse txt
+data Acid' = Acid' { acidCountState'    :: AcidState CountState
+                   , acidGreetingState' :: AcidState GreetingState
+                   , acidFooState'      :: AcidState FooState
+                   }
+withAcid' :: Maybe FilePath -> (Acid' -> IO a) -> IO a
+withAcid' mBasePath action =
+    let basePath = fromMaybe "_state" mBasePath
+    in withLocalState (Just $ basePath </> "count")    initialCountState    $ \c ->
+       withLocalState (Just $ basePath </> "greeting") initialGreetingState $ \g ->
+       withLocalState (Just $ basePath </> "foo")      initialFooState      $ \f ->
+           action (Acid' c g f)
+newtype App' a = App' { unApp' :: ServerPartT (ReaderT Acid' IO) a }
+    deriving ( Functor, Alternative, Applicative, Monad, MonadPlus, MonadIO
+               , HasRqData, ServerMonad ,WebMonad Response, FilterMonad Response
+               , Happstack, MonadReader Acid')
+
+instance HasAcidState App' FooState where
+    getAcidState = acidFooState' <$> ask
+fooAppPlugin :: App' Response
+fooAppPlugin = fooPlugin
+fooReaderPlugin :: ReaderT (AcidState FooState) (ServerPartT IO) Response
+fooReaderPlugin = fooPlugin
+instance HasAcidState (ReaderT (AcidState FooState) (ServerPartT IO)) FooState where
+    getAcidState = ask
+withFooPlugin :: (MonadIO m, MonadBaseControl IO m) => 
+                 FilePath                          -- ^ path to state directory
+              -> (ServerPartT IO Response -> m a)  -- ^ function that uses fooPlugin
+              -> m a
+withFooPlugin basePath f =
+       do withLocalState (Just $ basePath </> "foo") initialFooState $ \fooState -> 
+              f $ runReaderT fooReaderPlugin fooState
+main' :: IO ()
+main' = 
+    withFooPlugin "_state" $ \fooPlugin' ->
+        withAcid Nothing $ \acid ->
+            simpleHTTP nullConf $ fooPlugin' `mplus` runApp acid page

data/vendor/pygments-main/tests/examplefiles/AlternatingGroup.mu

@@ -0,0 +1,102 @@
+/*++ $Id: AlternatingGroup.mu,v 1.4 2003/09/08 15:00:47 nthiery Exp $
+
+Dom::AlternatingGroup(n) -- the Alternating Group of {1..n}
+
+n	   - integer >= 1
+
+Elements are represented as in Dom::PermutationGroup(n)
+
+Author:	     Nicolas M. Thi�ry <nthiery@users.sourceforge.net>
+License:     LGPL
+Created:     August 8th, 1999
+Last update: $Date: 2003/09/08 15:00:47 $
+++*/
+
+domain Dom::AlternatingGroup(n: Type::PosInt)
+    inherits Dom::PermutationGroup(n,toBeDefined);
+    category Cat::PermutationGroup;
+    axiom Ax::canonicalRep;
+
+/*--
+    size
+
+    Size of the group.
+--*/
+
+    size := fact(n)/2;
+
+/*--
+    generators
+
+    A list of generators of the group
+
+    The first 3-cycle (1,2,3), and a maximal even cycle (1,...,n) or
+    (2,...,n) depending on the parity of n
+
+--*/
+
+    generators :=
+    if	 n<=2	     then generators:=[dom([[1]])];
+    elif n=3	     then generators:=[dom([[1,2,3]])];
+    elif n mod 2=0   then generators:=[dom([[1,2,3]]), dom([[$2..n]])];
+    else		  generators:=[dom([[1,2,3]]), dom([[$1..n]])];
+    end_if;
+    
+/*--
+    allElements
+
+    List of all the elements of the group
+--*/
+
+    allElements :=
+    proc()
+	option remember;
+	local p;
+    begin
+	[new(dom,p) $ p in select(combinat::permutations(n),
+				  p->bool(combinat::permutations::sign(p)=1))];
+    end_proc;
+
+/*--
+    cycleTypes:
+
+    Count the elements of the group by cycle type.
+    (Cf Cat::PermutationGroupModule).
+
+    Same algorithm as for Dom::SymmetricGroup, but only even permutations
+    are considered. This is done by disregarding partitions p such
+    that n-length(p) is odd.
+--*/
+
+    cycleTypes :=
+    proc()
+	option remember;
+	local t, p, gen;
+    begin
+	userinfo(3, "cycleTypes: starting computation");
+	t:=table();
+
+	gen := combinat::partitions::generator(n);
+	while (p:=gen()) <> FAIL do
+	    userinfo(5, "working on partition", p);
+	    if(n-nops(p) mod 2=0) then
+		// Compute the size of the conjugacy class of Sn indexed by p
+		// and the cycle type of a permutation in this conjugacy class
+                t[combinat::partitions::toExp(p,n)]
+                  := combinat::partitions::conjugacyClassSize(p);
+	    end_if;
+        end_while;
+	t;
+    end_proc;
+
+begin
+    if testargs() then
+	if args(0) <> 1 then error("wrong no of args"); end_if;
+	if not testtype(n,DOM_INT) then
+	    error("argument must be integer")
+	end_if;
+	if n < 1 then
+	    error("argument must be positive")
+	end_if;
+    end_if;
+end_domain:

data/vendor/pygments-main/tests/examplefiles/CPDictionary.j

@@ -0,0 +1,611 @@
+/*
+ * CPDictionary.j
+ * Foundation
+ *
+ * Created by Francisco Tolmasky.
+ * Copyright 2008, 280 North, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+//@import "CPRange.j"
+@import "CPObject.j"
+@import "CPEnumerator.j"
+@import "CPException.j"
+
+/* @ignore */
+@implementation _CPDictionaryValueEnumerator : CPEnumerator
+{
+    CPEnumerator    _keyEnumerator;
+    CPDictionary    _dictionary;
+}
+
+- (id)initWithDictionary:(CPDictionary)aDictionary
+{
+    self = [super init];
+    
+    if (self)
+    {
+        _keyEnumerator = [aDictionary keyEnumerator];
+        _dictionary = aDictionary;
+    }
+    
+    return self;
+}
+
+- (id)nextObject
+{
+    var key = [_keyEnumerator nextObject];
+    
+    if (!key)
+        return nil;
+
+    return [_dictionary objectForKey:key];
+}
+
+@end
+
+/*! 
+    @class CPDictionary
+    @ingroup foundation
+    @brief A mutable key-value pair collection.
+
+    A dictionary is the standard way of passing around key-value pairs in
+    the Cappuccino framework. It is similar to the
+    <a href="http://java.sun.com/javase/6/docs/api/index.html">Java map interface</a>,
+    except all keys are CPStrings and values can be any
+    Cappuccino or JavaScript object.
+
+    If you are familiar with dictionaries in Cocoa, you'll notice that
+    there is no CPMutableDictionary class. The regular CPDictionary
+    has \c -setObject:forKey: and \c -removeObjectForKey: methods.
+    In Cappuccino there is no distinction between immutable and mutable classes.
+    They are all mutable.
+*/
+@implementation CPDictionary : CPObject
+{
+}
+
+/*
+    @ignore
+*/
++ (id)alloc
+{
+    return new objj_dictionary();
+}
+
+/*!
+    Returns a new empty CPDictionary.
+*/
++ (id)dictionary
+{
+    return [[self alloc] init];
+}
+
+/*!
+    Returns a new dictionary, initialized with the contents of \c aDictionary.
+    @param aDictionary the dictionary to copy key-value pairs from
+    @return the new CPDictionary
+*/
++ (id)dictionaryWithDictionary:(CPDictionary)aDictionary
+{
+    return [[self alloc] initWithDictionary:aDictionary];
+}
+
+/*!
+    Creates a new dictionary with single key-value pair.
+    @param anObject the object for the paring
+    @param aKey the key for the pairing
+    @return the new CPDictionary
+*/
++ (id)dictionaryWithObject:(id)anObject forKey:(id)aKey
+{
+    return [[self alloc] initWithObjects:[anObject] forKeys:[aKey]];
+}
+
+/*!
+    Creates a dictionary with multiple key-value pairs.
+    @param objects the objects to place in the dictionary
+    @param keys the keys for each of the objects
+    @throws CPInvalidArgumentException if the number of objects and keys is different
+    @return the new CPDictionary
+*/
++ (id)dictionaryWithObjects:(CPArray)objects forKeys:(CPArray)keys
+{
+    return [[self alloc] initWithObjects:objects forKeys:keys];
+}
+
+/*!
+    Creates a dictionary with multiple key-value pairs.
+    @param JavaScript object
+    @return the new CPDictionary
+*/
++ (id)dictionaryWithJSObject:(JSObject)object
+{
+    return [self dictionaryWithJSObject:object recursively:NO];
+}
+
+/*!
+    Creates a dictionary with multiple key-value pairs, recursively.
+    @param JavaScript object
+    @return the new CPDictionary
+*/
++ (id)dictionaryWithJSObject:(JSObject)object recursively:(BOOL)recursively
+{
+    var dictionary = [[self alloc] init];
+        
+    for (var key in object)
+    {
+        var value = object[key];
+    
+        if (recursively && value.constructor === Object)
+            value = [CPDictionary dictionaryWithJSObject:value recursively:YES];
+    
+        [dictionary setObject:value forKey:key];
+    }
+    
+    return dictionary;
+}
+
+/*!
+    Creates and returns a dictionary constructed by a given pairs of keys and values.
+    @param firstObject first object value
+    @param ... key for the first object and ongoing value-key pairs for more objects.
+    @throws CPInvalidArgumentException if the number of objects and keys is different
+    @return the new CPDictionary
+    
+    Assuming that there's no object retaining in Cappuccino, you can create
+    dictionaries same way as with alloc and initWithObjectsAndKeys:
+    var dict = [CPDictionary dictionaryWithObjectsAndKeys:
+    @"value1", @"key1",
+    @"value2", @"key2"];
+    
+    Note, that there's no final nil like in Objective-C/Cocoa.
+    
+    @see [CPDictionary initWithObjectsAndKeys:]
+*/
++ (id)dictionaryWithObjectsAndKeys:(id)firstObject, ...
+{
+    arguments[0] = [self alloc];
+    arguments[1] = @selector(initWithObjectsAndKeys:);
+    
+    return objj_msgSend.apply(this, arguments);
+}
+
+/*!
+    Initializes the dictionary with the contents of another dictionary.
+    @param aDictionary the dictionary to copy key-value pairs from
+    @return the initialized dictionary
+*/
+- (id)initWithDictionary:(CPDictionary)aDictionary
+{
+    var key = "",
+        dictionary = [[CPDictionary alloc] init];
+    
+    for (key in aDictionary._buckets)
+        [dictionary setObject:[aDictionary objectForKey:key] forKey:key];
+        
+    return dictionary;
+}
+
+/*!
+    Initializes the dictionary from the arrays of keys and objects.
+    @param objects the objects to put in the dictionary
+    @param keyArray the keys for the objects to put in the dictionary
+    @throws CPInvalidArgumentException if the number of objects and keys is different
+    @return the initialized dictionary
+*/
+- (id)initWithObjects:(CPArray)objects forKeys:(CPArray)keyArray
+{
+    self = [super init];
+
+    if ([objects count] != [keyArray count])
+        [CPException raise:CPInvalidArgumentException reason:"Counts are different.("+[objects count]+"!="+[keyArray count]+")"];
+
+    if (self)
+    {
+        var i = [keyArray count];
+        
+        while (i--)
+            [self setObject:objects[i] forKey:keyArray[i]];
+    }
+    
+    return self;
+}
+
+/*!
+    Creates and returns a dictionary constructed by a given pairs of keys and values.
+    @param firstObject first object value
+    @param ... key for the first object and ongoing value-key pairs for more objects.
+    @throws CPInvalidArgumentException if the number of objects and keys is different
+    @return the new CPDictionary
+    
+    You can create dictionaries this way:
+    var dict = [[CPDictionary alloc] initWithObjectsAndKeys:
+    @"value1", @"key1",
+    @"value2", @"key2"];
+    
+    Note, that there's no final nil like in Objective-C/Cocoa.
+*/
+- (id)initWithObjectsAndKeys:(id)firstObject, ...
+{
+    var argCount = arguments.length;
+    
+    if (argCount % 2 !== 0)
+        [CPException raise:CPInvalidArgumentException reason:"Key-value count is mismatched. (" + argCount + " arguments passed)"];
+
+    self = [super init];
+    
+    if (self)
+    {
+        // The arguments array contains self and _cmd, so the first object is at position 2.
+        var index = 2;
+        
+        for(; index < argCount; index += 2)
+        {
+            var value = arguments[index];
+
+            if (value === nil)
+                break;
+
+            [self setObject:value forKey:arguments[index + 1]];
+        }
+    }
+
+    return self;
+}
+
+/*!
+    return a copy of the receiver (does not deep copy the objects contained in the dictionary).
+*/
+- (CPDictionary)copy
+{
+    return [CPDictionary dictionaryWithDictionary:self];
+}
+
+/*!
+    Returns the number of entries in the dictionary
+*/
+- (int)count
+{
+    return count;
+}
+
+/*!
+    Returns an array of keys for all the entries in the dictionary.
+*/
+- (CPArray)allKeys
+{
+    return _keys;
+}
+
+/*!
+    Returns an array of values for all the entries in the dictionary.
+*/
+- (CPArray)allValues
+{
+    var index = _keys.length,
+        values = [];
+        
+    while (index--)
+        values.push(dictionary_getValue(self, [_keys[index]]));
+
+    return values;
+}
+
+/*!
+    Returns an enumerator that enumerates over all the dictionary's keys.
+*/
+- (CPEnumerator)keyEnumerator
+{
+    return [_keys objectEnumerator];
+}
+
+/*!
+    Returns an enumerator that enumerates over all the dictionary's values.
+*/
+- (CPEnumerator)objectEnumerator
+{
+    return [[_CPDictionaryValueEnumerator alloc] initWithDictionary:self];
+}
+
+/*!
+    Compare the receiver to this dictionary, and return whether or not they are equal. 
+*/
+- (BOOL)isEqualToDictionary:(CPDictionary)aDictionary
+{
+    if (count !== [aDictionary count])
+        return NO;
+
+    var index = count;
+    while (index--)
+    {
+        var currentKey = _keys[index],
+            lhsObject = _buckets[currentKey],
+            rhsObject = aDictionary._buckets[currentKey];
+
+        if (lhsObject === rhsObject)
+            continue;
+            
+        if (lhsObject.isa && rhsObject.isa && [lhsObject respondsToSelector:@selector(isEqual:)] && [lhsObject isEqual:rhsObject])
+            continue;
+        
+        return NO;
+    }
+
+    return YES;
+}
+
+/*
+    Instance.isEqualToDictionary(aDictionary)
+    {
+        if(this.count()!=aDictionary.count()) return NO;
+        
+        var i= this._keys.count();
+        while(i--) if(this.objectForKey(this._keys[i])!=aDictionary.objectForKey(this._keys[i])) return NO;
+        
+        return YES;
+    }
+    
+    Instance.allKeys()
+    {
+        return this._keys;
+    }
+    
+    Instance.allKeysForObject(anObject)
+    {
+        var i= 0,
+            keys= CPArray.array(),
+            count= this.count();
+        
+        while((i= this._objects.indexOfObjectInRage(0, count-i))!=CPNotFound) keys.addObject(this._keys[i]);
+        
+        return keys;
+    }
+    
+    Instance.allValues()
+    {
+        return this._objects;
+    }
+    
+    Instance.keyEnumerator()
+    {
+        return this._keys.objectEnumerator();
+    }
+    
+    Instance.keysSortedByValueUsingSelector(aSelector)
+    {
+        var dictionary= this,
+            objectSelector= function(rhs)
+            {
+                return aSelector.apply(dictionary.objectForKey(this), [dictionary.objectForKey(rhs)]);
+            };
+        
+        return this._keys.sortedArrayUsingSelector(objectSelector);
+    }
+    
+    Instance.objectEnumerator()
+    {
+        return this._objects.objectEnumerator();
+    }
+*/
+/*!
+    Returns the object for the entry with key \c aKey.
+    @param aKey the key for the object's entry
+    @return the object for the entry
+*/
+- (id)objectForKey:(CPString)aKey
+{
+    var object = _buckets[aKey];
+    
+    return (object === undefined) ? nil : object;
+}
+/*
+    Instance.objectsForKeys(keys, aNotFoundMarker)
+    {
+        var i= keys.length,
+            objects= CPArray.array();
+        
+        while(i--)
+        {
+            var object= this.objectForKey(keys[i]);
+            objects.addObject(object==nil?aNotFoundMarker:object);
+        }
+        
+        return objects;
+    }
+    
+    Instance.valueForKey(aKey)
+    {
+        if(aKey.length && aKey[0]=="@") return this.objectForKey(aKey.substr(1));
+        
+        return base.valueForKey(aKey);
+    }
+    
+    //
+    
+    Instance.addEntriesFromDictionary(aDictionary)
+    {
+        var key,
+            keyEnumerator= aDictionary.keyEnumerator();
+
+        while(key= keyEnumerator.nextObject()) this.setObjectForKey(aDictionary.objectForKey(key), key);
+    }
+*/
+/*!
+    Removes all the entries from the dictionary.
+*/
+- (void)removeAllObjects
+{
+    _keys = [];
+    count = 0;
+    _buckets = {};
+}
+
+/*!
+    Removes the entry for the specified key.
+    @param aKey the key of the entry to be removed
+*/
+- (void)removeObjectForKey:(id)aKey
+{
+    dictionary_removeValue(self, aKey);
+}
+
+/*!
+    Removes each entry in allKeys from the receiver.
+    @param allKeys an array of keys that will be removed from the dictionary
+*/
+- (void)removeObjectsForKeys:(CPArray)allKeys
+{
+    var index = allKeys.length;
+
+    while (index--)
+        dictionary_removeValue(self, allKeys[index]);
+}
+
+/*
+    Instance.removeObjectForKey(aKey)
+    {
+        var entry= this._dictionary[aKey];
+        
+        if(entry)
+        {
+            var range= CPMakeRange(entry.index, 1);
+            
+            this._keys.removeObjectsInRange(range);
+            this._objects.removeObjectsInRange(range);
+        
+            delete this._dictionary[aKey];
+        }
+    }
+    
+    Instance.setDictionary(aDictionary)
+    {
+        this._keys= CPArray.arrayWithArray(aDictionary.allKeys());
+        this._objects= CPArray.arrayWithArray(aDictionary.allValues());
+        
+        this._dictionary= { };
+        
+        var i= this._keys.count();
+        while(i--) this._dictionary[this._keys[i]]= { object: this._objects[i], index: i };
+    }
+*/
+/*!
+    Adds an entry into the dictionary.
+    @param anObject the object for the entry
+    @param aKey the entry's key
+*/
+- (void)setObject:(id)anObject forKey:(id)aKey
+{
+    dictionary_setValue(self, aKey, anObject);
+}
+/*
+    Instance.setValueForKey(aValue, aKey)
+    {
+        if(!aValue) this.removeObjectForKey(aKey);
+        else this.setObjectForKey(aValue, aKey);
+    }
+    
+    Instance.copy()
+    {
+        return CPDictionary.alloc().dictionaryWithDictionary(this);
+    }
+*/
+
+/*!
+    Take all the key/value pairs in aDictionary and apply them to this dictionary.
+*/
+- (void)addEntriesFromDictionary:(CPDictionary)aDictionary
+{
+    if (!aDictionary)
+        return;
+        
+    var keys = [aDictionary allKeys],
+        index = [keys count];
+    
+    while (index--)
+    {
+        var key = keys[index];
+
+        [self setObject:[aDictionary objectForKey:key] forKey:key];
+    }
+}
+
+/*!
+    Returns a human readable description of the dictionary.
+*/
+- (CPString)description
+{
+    var description = @"CPDictionary {\n";
+    
+    var i = _keys.length;
+    
+    while (i--)
+    {
+        description += _keys[i] + ":";
+
+        var object = _buckets[_keys[i]];
+
+        if (object && object.isa)
+            description += [object description];
+        else
+            description += object;
+
+        description += "\n";
+    }
+
+    description += "}";
+
+    return description;
+}
+
+@end
+
+@implementation CPDictionary (CPCoding)
+
+/*
+    Initializes the dictionary by unarchiving the data from a coder.
+    @param aCoder the coder from which the data will be unarchived.
+    @return the initialized dictionary
+*/
+- (id)initWithCoder:(CPCoder)aCoder
+{
+    return [aCoder _decodeDictionaryOfObjectsForKey:@"CP.objects"];
+}
+
+/*!
+    Archives the dictionary to a provided coder.
+    @param aCoder the coder to which the dictionary data will be archived.
+*/
+- (void)encodeWithCoder:(CPCoder)aCoder
+{
+    [aCoder _encodeDictionaryOfObjects:self forKey:@"CP.objects"];
+}
+
+@end
+
+/*!
+    @class CPMutableDictionary
+    @ingroup compatability
+
+    This class is just an empty subclass of CPDictionary.
+    CPDictionary already implements mutable methods and
+    this class only exists for source compatability.
+*/
+@implementation CPMutableDictionary : CPDictionary
+
+@end
+
+objj_dictionary.prototype.isa = CPDictionary;