gitlab-pygments.rb 0.3.2

data/vendor/pygments-main/tests/examplefiles/ruby_func_def.rb

@@ -0,0 +1,11 @@
+class (get_foo("blub"))::Foo
+  def (foo("bar") + bar("baz")).something argh, aaahaa
+    42
+  end
+end
+
+class get_the_fuck("out")::Of::My
+  def parser_definition
+    ruby!
+  end
+end

data/vendor/pygments-main/tests/examplefiles/scilab.sci

@@ -0,0 +1,30 @@
+// Scilab ( http://www.scilab.org/ )
+// Copyright (C) INRIA - Serge STEER
+// 
+
+function I=sub2ind(dims,varargin)
+//sub2ind is used to determine the equivalent single index
+//corresponding to a given set of subscript values.
+ 
+//I = sub2ind(dims,i1,i2,..) returns the linear index equivalent to the
+//row,  column, ... subscripts in the arrays i1,i2,..  for an matrix of
+//size dims.
+ 
+//I = sub2ind(dims,Mi) returns the linear index
+//equivalent to the n subscripts in the columns of the matrix Mi for a matrix
+//of size dims.
+ 
+  d=[1;cumprod(matrix(dims(1:$-1),-1,1))]
+  for i=1:size(varargin)
+    if varargin(i)==[] then I=[],return,end
+  end
+
+  if size(varargin)==1 then //subindices are the columns of the argument
+    I=(varargin(1)-1)*d+1
+  else //subindices are given as separated arguments
+    I=1
+    for i=1:size(varargin)
+      I=I+(varargin(i)-1)*d(i)
+    end
+  end
+endfunction

data/vendor/pygments-main/tests/examplefiles/sibling.prolog

@@ -0,0 +1,19 @@
+/* Comments /* can nest */
+still a comment
+*/
+
+:- module(maplist, maplist/3)
+
+assert(world:done). % asserts
+
+sibling(X, Y)      :- parent_child(Z, X), parent_child(Z, Y).
+
+parent_child(X, Y) :- father_child(X, Y).
+parent_child(X, Y) :- mother_child(X, Y).
+
+mother_child(trude, sally).
+
+father_child(tom, sally).
+father_child(tom, erica).
+father_child(mike, tom).
+

data/vendor/pygments-main/tests/examplefiles/simple.md

@@ -0,0 +1,747 @@
+module simple;
+
+// Importing stuff.
+{
+	function loadMod(name, ns)
+	{
+		assert(name == "mod");
+		
+		ns.x = "I'm x";
+	
+		ns.foo = function foo()
+		{
+			writefln("foo");
+		};
+	
+		ns.bar = function bar(x)
+		{
+			return x[0];
+		};
+	
+		ns.baz = function baz()
+		{
+			writefln(x);
+		};
+		
+		foreach(k, v; ns)
+			if(isFunction(v))
+				v.environment(ns);
+	}
+	
+	setModuleLoader("mod", loadMod);
+	
+	import mod : foo, bar;
+	foo();
+	writefln(bar([5]));
+	mod.baz();
+
+	writefln();
+}
+
+// Super calls.
+{
+	class Base
+	{
+		function fork()
+		{
+			writefln("Base fork.");
+		}
+	}
+
+	class Derived : Base
+	{
+		function fork()
+		{
+			writefln("Derived fork!");
+			super.fork();
+		}
+	}
+	
+	local d = Derived();
+	d.fork();
+	
+	writefln();
+}
+
+// Coroutines and coroutine iteration.
+{
+	local countDown = coroutine function countDown(x)
+	{
+		yield();
+		
+		while(x > 0)
+		{
+			yield(x);
+			x--;
+		}
+	};
+	
+	foreach(v; countDown, 5)
+		writefln(v);
+		
+	writefln();
+	
+	local forEach = coroutine function forEach(t)
+	{
+		yield();
+	
+		foreach(k, v; t)
+			yield(k, v);
+	};
+	
+	foreach(_, k, v; forEach, {hi = 1, bye = 2})
+		writefln("key: ", k, ", value: ", v);
+	
+	writefln();
+}
+
+// Testing tailcalls.
+{
+	function recurse(x)
+	{
+		writefln("recurse: ", x);
+	
+		if(x == 0)
+			return toString(x);
+		else
+			return recurse(x - 1);
+	}
+	
+	writefln(recurse(5));
+	writefln();
+	
+	class A
+	{
+		function f(x)
+		{
+			writefln("A.f: ", x);
+
+			if(x == 0)
+				return toString(x);
+			else
+				return this.f(x - 1); // call it as this.f to force a 'method' instruction to be generated
+		}
+	}
+	
+	local a = A();
+	writefln(a.f(5));
+	writefln();
+}
+
+{
+	// A function which lets us define properties for a class.
+	// The varargs should be a bunch of tables, each with a 'name' field, and 'getter' and/or 'setter' fields.
+	function mixinProperties(classType, vararg)
+	{
+		classType.mProps = { };
+	
+		classType.opIndex = function opIndex(key)
+		{
+			local prop = mProps[key];
+	
+			if(prop is null)
+				throw format(classType, ".opIndex() - Property '%s' does not exist", key);
+	
+			local getter = prop.getter;
+	
+			if(getter is null)
+				throw format(classType, ".opIndex() - Property '%s' has no getter", key);
+	
+			return getter(with this);
+		};
+	
+		classType.opIndexAssign = function opIndexAssign(key, value)
+		{
+			local prop = mProps[key];
+	
+			if(prop is null)
+				throw format(classType, ".opIndexAssign() - Property '%s' does not exist", key);
+	
+			local setter = prop.setter;
+	
+			if(setter is null)
+				throw format(classType, ".opIndexAssign() - Property '%s' has no setter", key);
+	
+			setter(with this, value);
+		};
+	
+		foreach(i, prop; [vararg])
+		{
+			if(!isTable(prop))
+				throw format("mixinProperties() - property ", i, " is not a table");
+	
+			if(prop.name is null)
+				throw format("mixinProperties() - property ", i, " has no name");
+	
+			if(prop.setter is null && prop.getter is null)
+				throw format("mixinProperties() - property '%s' has no getter or setter", prop.name);
+	
+			classType.mProps[prop.name] = prop;
+		}
+	}
+	
+	// Create a class to test out.
+	class PropTest
+	{
+		mX = 0;
+		mY = 0;
+		mName = "";
+		
+		function constructor(name)
+		{
+			mName = name;
+		}
+	
+		function toString()
+		{
+			return format("name = '", mName, "' x = ", mX, " y = ", mY);
+		}
+	}
+	
+	// Mix in the properties.
+	mixinProperties
+	(
+		PropTest,
+	
+		{
+			name = "x",
+			
+			function setter(value)
+			{
+				mX = value;
+			}
+	
+			function getter()
+			{
+				return mX;
+			}
+		},
+	
+		{
+			name = "y",
+	
+			function setter(value)
+			{
+				mY = value;
+			}
+	
+			function getter()
+			{
+				return mY;
+			}
+		},
+	
+		{
+			name = "name",
+	
+			function getter()
+			{
+				return mName;
+			}
+		}
+	);
+	
+	// Create an instance and try it out.
+	local p = PropTest("hello");
+	
+	writefln(p);
+	p.x = 46;
+	p.y = 123;
+	p.x = p.x + p.y;
+	writefln(p);
+	
+	// Try to access a nonexistent property.
+	try
+		p.name = "crap";
+	catch(e)
+	{
+		writefln("caught: ", e);
+		writefln(getTraceback());
+	}
+	
+	writefln();
+}
+
+// Some container classes.
+{
+	class PQ
+	{
+		mData;
+		mLength = 0;
+	
+		function constructor()
+		{
+			mData = array.new(15);
+		}
+	
+		function insert(data)
+		{
+			resizeArray();
+			mData[mLength] = data;
+	
+			local index = mLength;
+			local parentIndex = (index - 1) / 2;
+	
+			while(index > 0 && mData[parentIndex] > mData[index])
+			{
+				local temp = mData[parentIndex];
+				mData[parentIndex] = mData[index];
+				mData[index] = temp;
+	
+				index = parentIndex;
+				parentIndex = (index - 1) / 2;
+			}
+			
+			mLength += 1;
+		}
+	
+		function remove()
+		{
+			if(mLength == 0)
+				throw "PQ.remove() - No items to remove";
+	
+			local data = mData[0];
+			mLength -= 1;
+			mData[0] = mData[mLength];
+			
+			local index = 0;
+			local left = 1;
+			local right = 2;
+	
+			while(index < mLength)
+			{
+				local smaller;
+				
+				if(left >= mLength)
+				{
+					if(right >= mLength)
+						break;
+					else
+						smaller = right;
+				}
+				else
+				{
+					if(right >= mLength)
+						smaller = left;
+					else
+					{
+						if(mData[left] < mData[right])
+							smaller = left;
+						else
+							smaller = right;
+					}
+				}
+	
+				if(mData[index] > mData[smaller])
+				{
+					local temp = mData[index];
+					mData[index] = mData[smaller];
+					mData[smaller] = temp;
+					
+					index = smaller;
+					left = (index * 2) + 1;
+					right = left + 1;
+				}
+				else
+					break;
+			}
+			
+			return data;
+		}
+		
+		function resizeArray()
+		{
+			if(mLength >= #mData)
+				mData.length((#mData + 1) * 2 - 1);
+		}
+		
+		function hasData()
+		{
+			return mLength != 0;
+		}
+	}
+	
+	class Stack
+	{
+		mHead = null;
+	
+		function push(data)
+		{
+			local t = { data = data, next = mHead };
+			mHead = t;
+		}
+		
+		function pop()
+		{
+			if(mHead is null)
+				throw "Stack.pop() - No items to pop";
+	
+			local item = mHead;
+			mHead = mHead.next;
+			
+			return item.data;
+		}
+	
+		function hasData()
+		{
+			return mHead !is null;
+		}
+	}
+	
+	class Queue
+	{
+		mHead = null;
+		mTail = null;
+	
+		function push(data)
+		{
+			local t = { data = data, next = null };
+	
+			if(mTail is null)
+			{
+				mHead = t;
+				mTail = t;
+			}
+			else
+			{
+				mTail.next = t;
+				mTail = t;
+			}
+		}
+		
+		function pop()
+		{
+			if(mTail is null)
+				throw "Queue.pop() - No items to pop";
+				
+			local item = mHead;
+			mHead = mHead.next;
+			
+			if(mHead is null)
+				mTail = null;
+				
+			return item.data;
+		}
+		
+		function hasData()
+		{
+			return mHead !is null;
+		}
+	}
+	
+	writefln("Priority queue (heap)");
+	
+	local prioQ = PQ();
+	
+	for(i : 0 .. 10)
+		prioQ.insert(math.rand(0, 20));
+	
+	while(prioQ.hasData())
+		writefln(prioQ.remove());
+		
+	writefln();
+	writefln("Stack");
+	
+	local stack = Stack();
+	
+	for(i : 0 .. 5)
+		stack.push(i + 1);
+	
+	while(stack.hasData())
+		writefln(stack.pop());
+	
+	writefln();
+	writefln("Queue");
+	
+	local queue = Queue();
+	
+	for(i : 0 .. 5)
+		queue.push(i + 1);
+	
+	while(queue.hasData())
+		writefln(queue.pop());
+	
+	writefln();
+}
+
+// opApply tests.
+{
+	class Test
+	{
+		mData = [4, 5, 6];
+	
+		function opApply(extra)
+		{
+			if(isString(extra) && extra == "reverse")
+			{
+				local function iterator_reverse(index)
+				{
+					index--;
+					
+					if(index < 0)
+						return;
+						
+					return index, mData[index];
+				}
+	
+				return iterator_reverse, this, #mData;
+			}
+			else
+			{
+				local function iterator(index)
+				{
+					index++;
+	
+					if(index >= #mData)
+						return;
+		
+					return index, mData[index];
+				}
+	
+				return iterator, this, -1;
+			}
+		}
+	}
+	
+	local test = Test();
+	
+	foreach(k, v; test)
+		writefln("test[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; test, "reverse")
+		writefln("test[", k, "] = ", v);
+		
+	writefln();
+	
+	test =
+	{
+		fork = 5,
+		knife = 10,
+		spoon = "hi"
+	};
+	
+	foreach(k, v; test)
+		writefln("test[", k, "] = ", v);
+	
+	test = [5, 10, "hi"];
+	
+	writefln();
+	
+	foreach(k, v; test)
+		writefln("test[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; test, "reverse")
+		writefln("test[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; "hello")
+		writefln("str[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; "hello", "reverse")
+		writefln("str[", k, "] = ", v);
+	
+	writefln();
+}
+
+// Testing upvalues in for loops.
+{
+	local arr = array.new(10);
+	
+	for(i : 0 .. 10)
+		arr[i] = function() { return i; };
+	
+	writefln("This should be the values 0 through 9:");
+	
+	foreach(func; arr)
+		writefln(func());
+	
+	writefln();
+}
+
+// Testing nested functions.
+{
+	function outer()
+	{
+		local x = 3;
+	
+		function inner()
+		{
+			x++;
+			writefln("inner x: ", x);
+		}
+	
+		writefln("outer x: ", x);
+		inner();
+		writefln("outer x: ", x);
+	
+		return inner;
+	}
+	
+	local func = outer();
+	func();
+	
+	writefln();
+}
+
+// Testing Exceptions.
+{
+	function thrower(x)
+	{
+		if(x >= 3)
+			throw "Sorry, x is too big for me!";
+	}
+	
+	function tryCatch(iterations)
+	{
+		try
+		{
+			for(i : 0 .. iterations)
+			{
+				writefln("tryCatch: ", i);
+				thrower(i);
+			}
+		}
+		catch(e)
+		{
+			writefln("tryCatch caught: ", e);
+			throw e;
+		}
+		finally
+			writefln("tryCatch finally");
+	}
+	
+	try
+	{
+		tryCatch(2);
+		tryCatch(5);
+	}
+	catch(e)
+		writefln("caught: ", e);
+	
+	writefln();
+}
+
+// Testing arrays.
+{
+	local array = [7, 9, 2, 3, 6];
+	
+	array.sort();
+	
+	foreach(i, v; array)
+		writefln("arr[", i, "] = ", v);
+	
+	array ~= ["foo", "far"];
+	
+	writefln();
+	
+	foreach(i, v; array)
+		writefln("arr[", i, "] = ", v);
+	
+	writefln();
+}
+
+// Testing vararg functions.
+{
+	function vargs(vararg)
+	{
+		local args = [vararg];
+	
+		writefln("num varargs: ", #args);
+	
+		foreach(i, v; args)
+			writefln("args[", i, "] = ", v);
+	}
+	
+	vargs();
+	
+	writefln();
+	
+	vargs(2, 3, 5, "foo", "bar");
+	
+	writefln();
+}
+
+// Testing switches.
+{
+	foreach(v; ["hi", "bye", "foo"])
+	{
+		switch(v)
+		{
+			case "hi":
+				writefln("switched to hi");
+				break;
+				
+			case "bye":
+				writefln("switched to bye");
+				break;
+				
+			default:
+				writefln("switched to something else");
+				break;
+		}
+	}
+	
+	writefln();
+	
+	foreach(v; [null, false, 1, 2.3, 'x', "hi"])
+	{
+		switch(v)
+		{
+			case null: writefln("null"); break;
+			case false: writefln("false"); break;
+			case 1: writefln("1"); break;
+			case 2.3: writefln("2.3"); break;
+			case 'x': writefln("x"); break;
+			case "hi": writefln("hi"); break;
+		}
+	}
+	
+	writefln();
+	
+	class A
+	{
+		mValue;
+		
+		this(value)
+		{
+			mValue = value;
+		}
+	
+		function opCmp(other)
+		{
+			assert(other as A);
+			return mValue <=> other.mValue;
+		}
+	}
+	
+	local a1 = A(1);
+	local a2 = A(2);
+	local a3 = A(3);
+	
+	for(s : 1 .. 4)
+	{
+		local ss = A(s);
+	
+		switch(ss)
+		{
+			case a1:
+				writefln(1);
+				break;
+	
+			case a2:
+				writefln(2);
+				break;
+	
+			case a3:
+				writefln(3);
+				break;
+		}
+	}
+}