gitlab-pygments.rb 0.3.2

data/vendor/pygments-main/tests/examplefiles/test.cs

@@ -0,0 +1,374 @@
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// MIT X11 license, Copyright (c) 2005-2006 by:                               //
+//                                                                            //
+// Authors:                                                                   //
+//      Michael Dominic K. <michaldominik@gmail.com>                          //
+//                                                                            //
+// 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.                                     //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+namespace Diva.Core {
+        
+        using System;
+        using Widgets;
+        using System.Xml;
+        using Util;
+        using System.Collections.Generic;
+        using System.Collections;
+        using Basics;
+
+        public class OpenerTask : Task, IBoilProvider {
+
+                // Private structs ////////////////////////////////////////////
+                
+                struct ObjectInfo {
+
+                        public ObjectContainer Container;
+                        public int[] Depends;
+                        public string SystemType;
+                        public int RefId;
+                        
+                        /* CONSTRUCTOR */
+                        public ObjectInfo (ObjectContainer container)
+                        {
+                                Container = container;
+                                Depends = container.Depends.ToArray ();
+                                SystemType = container.SystemType;
+                                RefId = container.RefId;
+                        }
+                        
+                        public override string ToString ()
+                        {
+                                return String.Format ("Type: {0} Deps count: {1} Id: {2}",
+                                                      SystemType, Depends.Length, RefId);
+                        }
+                        
+                        public bool IsUnBoilable (IBoilProvider provider)
+                        {
+                                if (Depends.Length == 0)
+                                        return true;
+                                
+                                foreach (int id in Depends)
+                                        if (! (provider.Contains (id)))
+                                                return false;
+                                
+                                return true;
+                        }
+                        
+                }
+                                 
+                // Enums //////////////////////////////////////////////////////
+                
+                enum OpenerTaskStep { Init, Header, ProjectInfoRead, ObjectListRead,
+                                      ObjectListParse, ObjectListUnBoil, FindRoots,
+                                      Finished };
+                
+                // Fields /////////////////////////////////////////////////////
+                
+                string fileName;                         // Filename we're reading
+                XmlDocument xmlDocument;                 // Our document
+                //XmlNode projectInfoNode;               // <projectinfo> node
+                IEnumerator objectsEnumerator;           // Enumerator
+                List <ObjectInfo> objectsList;           // Objects list
+                ObjectListContainer objectListContainer;
+                OpenerTaskStep currentStep;              // Our current step
+                
+                Dictionary <int, object> idToObject;     // Id -> object
+                Dictionary <object, int> objectToId;     // Object -> Id
+
+                string projectName = String.Empty;
+                string projectDirectory = String.Empty;
+                TagList projectTagList;
+                StuffList projectStuffList;
+                TrackList projectTrackList;
+                ClipList projectClipList;
+                MediaItemList projectMediaItemList;
+                Commander projectCommander;
+                Gdv.Pipeline projectPipeline;
+                Gdv.ProjectFormat projectFormat;
+                
+                // Properties /////////////////////////////////////////////////
+                
+                public string ProjectName {
+                        get { return projectName; }
+                }
+                
+                public string ProjectDirectory {
+                        get { return projectDirectory; }
+                }
+                
+                public TagList ProjectTagList {
+                        get { return projectTagList; }
+                }
+                
+                public StuffList ProjectStuffList {
+                        get { return projectStuffList; }
+                }
+                
+                public TrackList ProjectTrackList {
+                        get { return projectTrackList; }
+                }
+
+                public ClipList ProjectClipList {
+                        get { return projectClipList; }
+                }
+                
+                public MediaItemList ProjectMediaItemList {
+                        get { return projectMediaItemList; }
+                }
+                
+                public Commander ProjectCommander {
+                        get { return projectCommander; }
+                }
+                
+                public Gdv.Pipeline ProjectPipeline {
+                        get { return projectPipeline; }
+                }
+
+                public Gdv.ProjectFormat ProjectFormat {
+                        get { return projectFormat; }
+                }
+
+                // Public methods /////////////////////////////////////////////
+                
+                /* CONSTRUCTOR */
+                public OpenerTask (string fileName)
+                {
+                        this.fileName = fileName;
+                        var verbatimString = @"c:\test\";
+
+                        var verbatimStringWithNewline = @"test \\ \n \t \r
+a
+b
+c";
+                        var verbatimStringWithEscapedQuotes = @"He said
+""she says \"" is not an escaped character in verbatimstrings""
+";
+
+                        int[] numbers = { 5,6,4,2,4,6,8,9,7,0 };
+                        var linqExample = from n in numbers
+                                          where n > 5
+                                          select n;
+
+                        var anotherlinqExample = from n in numbers
+                                                 orderby n descending
+                                                 select n;
+
+                        int[] someMoreNumbers = { 8,2,17,34,8,9,9,5,3,4,2,1,5 };
+                        var moreLinq = from n in numbers
+                                       join mn in moreNumbers on n equals mn + 2
+                                       select new {n, mn};
+                }
+                
+                public override void Reset ()
+                {
+                        objectToId = new Dictionary <object, int> ();
+                        idToObject = new Dictionary <int, object> ();
+                        
+                        xmlDocument = null;
+                        //projectInfoNode = null;
+                        
+                        currentStep = OpenerTaskStep.Init;
+                        
+                        base.Reset ();
+                }
+                
+                public int GetIdForObject (object o)
+                {
+                        return objectToId [o];
+                }
+                
+                public object GetObjectForId (int id)
+                {
+                        return idToObject [id];
+                }
+                
+                public bool Contains (int id)
+                {
+                        return idToObject.ContainsKey (id);
+                }
+                
+                // Private methods ////////////////////////////////////////////
+                
+                protected override TaskStatus ExecuteStep (int s)
+                {
+                        bool cont = true;
+                        
+                        // Main
+                        switch (currentStep) {
+                                        
+                                case OpenerTaskStep.Init:
+                                        objectsList = new List <ObjectInfo> ();
+                                        xmlDocument = new XmlDocument ();
+                                        xmlDocument.Load (fileName);
+                                        currentStep = OpenerTaskStep.Header;
+                                        break;
+                                        
+                                case OpenerTaskStep.Header:
+                                        //ReadHeader ();
+                                        currentStep = OpenerTaskStep.ProjectInfoRead;
+                                        break;
+
+                                case OpenerTaskStep.ProjectInfoRead:
+                                        foreach (XmlNode node in xmlDocument.DocumentElement.ChildNodes)
+                                                if (node.Name == "projectinfo") 
+                                                        ResolveProjectInfoNode (node);
+
+                                        // FIXME: Fail if not found/not resolved
+                                        currentStep = OpenerTaskStep.ObjectListRead;
+                                        break;
+                                        
+                                case OpenerTaskStep.ObjectListRead:
+                                        foreach (XmlNode node in xmlDocument.DocumentElement.ChildNodes)
+                                                if (node.Name == "objectlist") 
+                                                        objectListContainer = (ObjectListContainer)
+                                                                DataFactory.MakeDataElement  (node as XmlElement);
+                                                        
+                                        if (objectListContainer == null)
+                                                throw new Exception ("ObjectListContainer not found!");
+
+                                        currentStep = OpenerTaskStep.ObjectListParse;
+                                        break;
+
+                                case OpenerTaskStep.ObjectListParse:
+                                        bool flush = EnumerateSomeObjects ();
+                                        if (flush)
+                                                currentStep = OpenerTaskStep.ObjectListUnBoil;
+                                        break;
+
+                                case OpenerTaskStep.ObjectListUnBoil:
+                                        bool done = UnBoilSomeObjects ();
+                                        if (done)
+                                                currentStep = OpenerTaskStep.FindRoots;
+                                        break;
+                                        
+                                        
+                                case OpenerTaskStep.FindRoots:
+                                        projectTrackList = (TrackList) FindRoot ("tracklist");
+                                        projectTagList = (TagList) FindRoot ("taglist");
+                                        projectStuffList = (StuffList) FindRoot ("stufflist");
+                                        projectClipList = (ClipList) FindRoot ("cliplist");
+                                        projectMediaItemList = (MediaItemList) FindRoot ("mediaitemlist");
+                                        projectPipeline = (Gdv.Pipeline) FindRoot ("pipeline");
+                                        projectCommander = (Commander) FindRoot ("commander");
+                                        projectFormat = (Gdv.ProjectFormat) FindRoot ("projectformat");
+                                        
+                                        currentStep = OpenerTaskStep.Finished;
+                                        break;
+                                        
+                                case OpenerTaskStep.Finished:
+                                        cont = false;
+                                        break;
+                                        
+                                default:
+                                        break;
+                        }
+                                                
+                        // Post 
+                        if (cont) 
+                                return TaskStatus.Running;
+                        else
+                                return TaskStatus.Done;
+                }
+
+                /*
+                void ReadHeader ()
+                {
+                        // FIXME: Read all the attributes from the <divaproject> element
+                        }*/
+
+                void ResolveProjectInfoNode (XmlNode node)
+                {
+                        foreach (XmlNode childNode in node) {
+                                
+                                switch (childNode.Name) {
+                                        
+                                        case "name":
+                                                projectName = childNode.FirstChild.Value;
+                                                break;
+                                        
+                                        case "directory":
+                                                projectDirectory = childNode.FirstChild.Value;
+                                                break;
+
+                                                // FIXME: Duration etc.
+                                }
+                        }
+                }
+                
+                bool EnumerateSomeObjects ()
+                {
+                        if (objectsEnumerator == null)
+                                objectsEnumerator = objectListContainer.FindAllObjects ().GetEnumerator ();
+                        
+                        for (int i = 0; i < 10; i++) {
+                                if (objectsEnumerator.MoveNext () == false)
+                                        return true;
+
+                                ObjectContainer container = (ObjectContainer)
+                                        objectsEnumerator.Current;
+                                
+                                ObjectInfo newInfo = new ObjectInfo (container);
+                                objectsList.Add (newInfo);
+                        }
+                        
+                        return false;
+                }
+
+                ObjectInfo GetNextCandidate ()
+                {
+                        foreach (ObjectInfo objInfo in objectsList)
+                                if (objInfo.IsUnBoilable (this))
+                                        return objInfo;
+                        
+                        throw new Exception ("FIXME: No more unboilable objects found. Recursive?");
+                }
+                
+                bool UnBoilSomeObjects ()
+                {
+                        for (int i = 0; i < 5; i++) {
+                                // All unboiled
+                                if (objectsList.Count == 0)
+                                        return true;
+                                
+                                ObjectInfo objInfo = GetNextCandidate ();
+
+                                object o = BoilFactory.UnBoil (objInfo.Container, this);
+                                objectsList.Remove (objInfo);
+
+                                // Add
+                                idToObject [objInfo.RefId] = o;
+                                objectToId [o] = objInfo.RefId;
+
+                        }
+                        
+                        return false;
+                }
+
+                object FindRoot (string rootString)
+                {
+                        ObjectContainer container = objectListContainer.FindObjectContainer (rootString);
+                        return idToObject [container.RefId];
+                }
+                
+        }
+        
+}

data/vendor/pygments-main/tests/examplefiles/test.css

@@ -0,0 +1,54 @@
+body {
+    font-size: 12pt;
+    background: #fff url(temp.png) top left no-repeat;
+}
+
+* html body {
+    font-size: 14pt;
+}
+
+#nav .new {
+    display: block;
+    -webkit-border-radius: 5px;
+    -moz-border-radius: 5px;
+    -ms-border-radius: 5px;
+    -o-border-radius: 5px;
+    border-radius: 5px;
+}
+
+ul#nav li.new {
+    font-weight: bold;
+}
+
+:link {
+    color: #f00;
+}
+
+:link:hover {
+    color: #0f0;
+}
+
+@media screen {
+  body {
+    background: #ccc;
+  }
+}
+
+@namespace "http://www.w3.org/1999/xhtml";
+
+@import url("mystyle.css");
+
+@charset "ISO-8859-1";
+
+@font-face { font-family: "Example Font"; src: url("http://www.example.com/fonts/example"); }
+
+@media screen { body { font-size: 16px } } @media print { body { font-size: 12pt } }
+
+
+@page { body { margin: 1in 1.5in; } }
+
+@page linke-seite:left { body { margin:20mm; margin-right:25mm; } }
+
+@-moz-document url-prefix(http://pygments.org) {  a {font-style: normal !important;} }
+
+

data/vendor/pygments-main/tests/examplefiles/test.d

@@ -0,0 +1,135 @@
+// Created by Lionello Lunesu and placed in the public domain.
+// This file has been modified from its original version.
+// It has been formatted to fit your screen.
+module phoneno;     // optional
+import std.stdio;   // writefln     
+import std.ctype;   // isdigit     
+import std.stream;  // BufferedFile
+
+// Just for readability (imagine char[][][char[]])    
+alias char[] string;
+alias string[] stringarray;
+
+/// Strips non-digit characters from the string (COW)
+string stripNonDigit( in string line ) 
+{
+    string ret;
+    foreach(uint i, c; line) {
+        // Error: std.ctype.isdigit at C:\dmd\src\phobos\std\ctype.d(37) 
+        // conflicts with std.stream.isdigit at C:\dmd\src\phobos\std\stream.d(2924)
+        if (!std.ctype.isdigit(c)) {
+            if (!ret)
+                ret = line[0..i];    
+        }    
+        else if (ret)
+            ret ~= c;    
+    }    
+    return ret?ret:line;
+}
+
+unittest {
+    assert( stripNonDigit("asdf") == ""  );
+    assert( stripNonDigit("\'13-=2 4kop") ==  "1324"  );
+}
+
+/// Converts a word into a number, ignoring all non alpha characters  
+string wordToNum( in string word )
+{
+// translation table for the task at hand
+const char[256] TRANSLATE =    
+    "                                "  // 0   
+    "                0123456789      "  // 32     
+    " 57630499617851881234762239     "  // 64   
+    " 57630499617851881234762239     "
+    "                                "
+    "                                "
+    "                                "    
+    "                                ";
+    string ret;
+    foreach(c; cast(ubyte[])word)
+        if (TRANSLATE[c] != ' ')
+            ret ~= TRANSLATE[c];
+    return ret;
+}
+
+unittest {
+ // Test wordToNum using the table from the task description.
+ assert( "01112223334455666777888999" ==
+   wordToNum("E | J N Q | R W X | D S Y | F T | A M | C I V | B K U | L O P | G H Z"));
+ assert( "01112223334455666777888999" == 
+   wordToNum("e | j n q | r w x | d s y | f t | a m | c i v | b k u | l o p | g h z"));
+ assert( "0123456789" == 
+   wordToNum("0 |   1   |   2   |   3   |  4  |  5  |   6   |   7   |   8   |   9"));
+}
+
+void main( string[] args )
+{
+    // This associative array maps a number to an array of words.    
+    stringarray[string]    num2words;
+
+    foreach(string word; new BufferedFile("dictionary.txt" ) )
+        num2words[ wordToNum(word) ] ~= word.dup;        // must dup
+
+    /// Finds all alternatives for the given number
+    /// (should have been stripped from non-digit characters)
+    stringarray _FindWords( string numbers, bool digitok )
+    in {
+        assert(numbers.length >  0);    
+    }    
+    out(result) {
+        foreach (a; result)
+            assert( wordToNum(a) == numbers );
+    }    
+    body {
+        stringarray ret;
+        bool foundword = false;
+        for (uint t=1; t<=numbers.length; ++t) {
+            auto alternatives = numbers[0..t] in num2words;
+            if (!alternatives)
+                continue;
+            foundword = true;
+            if (numbers.length >  t) {
+                // Combine all current alternatives with all alternatives     
+                // of the rest (next piece can start with a digit)              
+                foreach (a2; _FindWords( numbers[t..$], true     ) )
+                    foreach(a1; *alternatives)
+                       ret ~= a1 ~ " " ~ a2;
+            }
+            else    
+                ret ~= *alternatives;    // append these alternatives
+        }
+        // Try to keep 1 digit, only if we're allowed and no other
+        // alternatives were found
+        // Testing "ret.length" makes more sense than testing "foundword",
+        // but the other implementations seem to do just this.
+        if (digitok && !foundword) { //ret.length == 0  
+            if(numbers.length >  1) {
+                // Combine 1 digit with all altenatives from the rest    
+                // (next piece can not start with a digit)          
+                foreach (a; _FindWords( numbers[1..$], false ) )
+                    ret ~= numbers[0..1] ~ " " ~ a;
+            }    
+            else    
+                ret ~= numbers[0..1];    // just append this digit             
+        }    
+        return ret;
+    }
+
+    /// (This function was inlined in the original program) 
+    /// Finds all alternatives for the given phone number 
+    /// Returns: array of strings 
+    stringarray FindWords( string phone_number )
+    {
+        if (!phone_number.length)
+            return null;
+        // Strip the non-digit characters from the phone number, and
+        // pass it to the recursive function (leading digit is allowed)
+        return _FindWords( stripNonDigit(phone_number), true );    
+    }    
+    
+    // Read the phone numbers     
+    foreach(string phone; new BufferedFile("input.txt"   ) )
+        foreach(alternative; FindWords( phone ) )
+            writefln(phone, ": ", alternative );
+}
+