pygments.rb 0.5.4 → 0.6.0

data/vendor/pygments-main/tests/examplefiles/example.java

@@ -0,0 +1,16 @@
+class _PostUnico$deClassá
+{void fo$o() {}
+
+  void PostUnicodeFunctioná() {
+  láb$el:
+    break láb$el;
+  
+  }
+}
+
+class áPreUnicode$Class
+{
+  public int $foo;
+  public int á$foo;
+  _PostUnico$deClassá áPreUnicodeFunction() { return null; }
+}

data/vendor/pygments-main/tests/examplefiles/example.kal

@@ -0,0 +1,75 @@
+#!/usr/bin/env kal
+
+# This demo executes GET requests in parallel and in series
+# using `for` loops and `wait for` statements.
+
+# Notice how the serial GET requests always return in order
+# and take longer in total. Parallel requests come back in
+# order of receipt.
+
+http = require 'http'
+
+urls = ['http://www.google.com'
+        'http://www.apple.com'
+        'http://www.microsoft.com'
+        'http://www.nodejs.org'
+        'http://www.yahoo.com']
+
+# This function does a GET request for each URL in series
+# It will wait for a response from each request before moving on
+# to the next request. Notice the output will be in the same order as the
+# urls variable every time regardless of response time.
+# It is a task rather than a function because it is called asynchronously
+# This allows us to use `return` to implicitly call back
+task series_demo()
+  # The `series` keyword is optional here (for loops are serial by default)
+  total_time = 0
+
+  for series url in urls
+    timer = new Date
+
+    # we use the `safe` keyword because get is a "nonstandard" task
+    # that does not call back with an error argument
+    safe wait for response from http.get url
+
+    delay = new Date() - timer
+    total_time += delay
+
+    print "GET #{url} - #{response.statusCode} - #{response.connection.bytesRead} bytes - #{delay} ms"
+
+  # because we are in a task rather than a function, this actually exectutes a callback
+  return total_time
+
+# This function does a GET request for each URL in parallel
+# It will NOT wait for a response from each request before moving on
+# to the next request. Notice the output will be determined by the order in which
+# the requests complete!
+task parallel_demo()
+  total_time = 0
+
+  # The `parallel` keyword is only meaningful here because the loop contains
+  # a `wait for` statement (meaning callbacks are used)
+  for parallel url in urls
+    timer = new Date
+
+    # we use the `safe` keyword because get is a "nonstandard" task
+    # that does not call back with an error argument
+    safe wait for response from http.get url
+
+    delay = new Date() - timer
+    total_time += delay
+
+    print "GET #{url} - #{response.statusCode} - #{response.connection.bytesRead} bytes - #{delay}ms"
+
+  # because we are in a task rather than a function, this actually exectutes a callback
+  return total_time
+
+print 'Series Requests...'
+wait for time1 from series_demo()
+print "Total duration #{time1}ms"
+
+print ''
+
+print 'Parallel Requests...'
+wait for time2 from parallel_demo()
+print "Total duration #{time2}ms"

data/vendor/pygments-main/tests/examplefiles/example.liquid

@@ -0,0 +1,42 @@
+# This is an example file. Process it with `./pygmentize -O full -f html -o /liquid-example.html example.liquid`.
+
+{% raw %}
+some {{raw}} liquid syntax
+
+{% raw %}
+{% endraw %}
+
+Just regular text - what happens?
+
+{% comment %}My lovely {{comment}} {% comment %}{% endcomment %}
+
+{% custom_tag params: true %}
+{% custom_block my="abc" c = false %}
+	Just usual {{liquid}}.
+{% endcustom_block %}
+
+{% another_tag "my string param" %}
+
+{{ variable | upcase }}
+{{ var.field | textilize | markdownify }}
+{{ var.field.property | textilize | markdownify }}
+{{ 'string' | truncate: 100 param='df"g' }}
+
+{% cycle '1', 2, var %}
+{% cycle 'group1': '1', var, 2 %}
+{% cycle group2: '1', var, 2 %}
+
+{% if a == 'B' %}
+{% elsif a == 'C%}' %}
+{% else %}
+{% endif %}
+
+{% unless not a %}
+{% else %}
+{% endunless %}
+
+{% case a %}
+{% when 'B' %}
+{% when 'C' %}
+{% else %}
+{% endcase %}

data/vendor/pygments-main/tests/examplefiles/example.ma

@@ -0,0 +1,8 @@
+1 + 1 (* This is a comment *)
+Global`
+SomeNamespace`Foo
+f[x_, y__, 3, z___] := tsneirsnteintie "fosrt" neisnrteiasrn
+E + 3
+Plus[1,Times[2,3]]
+Map[#1 + #2&, SomePairList]
+Plus[1.,-1,-1.,-1.0,]

data/vendor/pygments-main/tests/examplefiles/example.mq4

@@ -0,0 +1,187 @@
+//+------------------------------------------------------------------+
+//|                                              PeriodConverter.mq4 |
+//|                   Copyright 2006-2014, MetaQuotes Software Corp. |
+//|                                        http://www.metaquotes.net |
+//+------------------------------------------------------------------+
+#property copyright   "2006-2014, MetaQuotes Software Corp."
+#property link        "http://www.mql4.com"
+#property description "Period Converter to updated format of history base"
+#property strict
+#property show_inputs
+#include <WinUser32.mqh>
+
+input int InpPeriodMultiplier=3; // Period multiplier factor
+int       ExtHandle=-1;
+//+------------------------------------------------------------------+
+//| script program start function                                    |
+//+------------------------------------------------------------------+
+void OnStart()
+  {
+   datetime time0;
+   ulong    last_fpos=0;
+   long     last_volume=0;
+   int      i,start_pos,periodseconds;
+   int      hwnd=0,cnt=0;
+//---- History header
+   int      file_version=401;
+   string   c_copyright;
+   string   c_symbol=Symbol();
+   int      i_period=Period()*InpPeriodMultiplier;
+   int      i_digits=Digits;
+   int      i_unused[13];
+   MqlRates rate;
+//---  
+   ExtHandle=FileOpenHistory(c_symbol+(string)i_period+".hst",FILE_BIN|FILE_WRITE|FILE_SHARE_WRITE|FILE_SHARE_READ|FILE_ANSI);
+   if(ExtHandle<0)
+      return;
+   c_copyright="(C)opyright 2003, MetaQuotes Software Corp.";
+   ArrayInitialize(i_unused,0);
+//--- write history file header
+   FileWriteInteger(ExtHandle,file_version,LONG_VALUE);
+   FileWriteString(ExtHandle,c_copyright,64);
+   FileWriteString(ExtHandle,c_symbol,12);
+   FileWriteInteger(ExtHandle,i_period,LONG_VALUE);
+   FileWriteInteger(ExtHandle,i_digits,LONG_VALUE);
+   FileWriteInteger(ExtHandle,0,LONG_VALUE);
+   FileWriteInteger(ExtHandle,0,LONG_VALUE);
+   FileWriteArray(ExtHandle,i_unused,0,13);
+//--- write history file
+   periodseconds=i_period*60;
+   start_pos=Bars-1;
+   rate.open=Open[start_pos];
+   rate.low=Low[start_pos];
+   rate.high=High[start_pos];
+   rate.tick_volume=(long)Volume[start_pos];
+   rate.spread=0;
+   rate.real_volume=0;
+   //--- normalize open time
+   rate.time=Time[start_pos]/periodseconds;
+   rate.time*=periodseconds;
+   for(i=start_pos-1; i>=0; i--)
+     {
+      if(IsStopped())
+         break;
+      time0=Time[i];
+      //--- history may be updated
+      if(i==0)
+        {
+         //--- modify index if history was updated
+         if(RefreshRates())
+            i=iBarShift(NULL,0,time0);
+        }
+      //---
+      if(time0>=rate.time+periodseconds || i==0)
+        {
+         if(i==0 && time0<rate.time+periodseconds)
+           {
+            rate.tick_volume+=(long)Volume[0];
+            if(rate.low>Low[0])
+               rate.low=Low[0];
+            if(rate.high<High[0])
+               rate.high=High[0];
+            rate.close=Close[0];
+           }
+         last_fpos=FileTell(ExtHandle);
+         last_volume=(long)Volume[i];
+         FileWriteStruct(ExtHandle,rate);
+         cnt++;
+         if(time0>=rate.time+periodseconds)
+           {
+            rate.time=time0/periodseconds;
+            rate.time*=periodseconds;
+            rate.open=Open[i];
+            rate.low=Low[i];
+            rate.high=High[i];
+            rate.close=Close[i];
+            rate.tick_volume=last_volume;
+           }
+        }
+       else
+        {
+         rate.tick_volume+=(long)Volume[i];
+         if(rate.low>Low[i])
+            rate.low=Low[i];
+         if(rate.high<High[i])
+            rate.high=High[i];
+         rate.close=Close[i];
+        }
+     } 
+   FileFlush(ExtHandle);
+   Print(cnt," record(s) written");
+//--- collect incoming ticks
+   datetime last_time=LocalTime()-5;
+   while(!IsStopped())
+     {
+      datetime cur_time=LocalTime();
+      //--- check for new rates
+      if(RefreshRates())
+        {
+         time0=Time[0];
+         FileSeek(ExtHandle,last_fpos,SEEK_SET);
+         //--- is there current bar?
+         if(time0<rate.time+periodseconds)
+           {
+            rate.tick_volume+=(long)Volume[0]-last_volume;
+            last_volume=(long)Volume[0]; 
+            if(rate.low>Low[0])
+               rate.low=Low[0];
+            if(rate.high<High[0])
+               rate.high=High[0];
+            rate.close=Close[0];
+           }
+         else
+           {
+            //--- no, there is new bar
+            rate.tick_volume+=(long)Volume[1]-last_volume;
+            if(rate.low>Low[1])
+               rate.low=Low[1];
+            if(rate.high<High[1])
+               rate.high=High[1];
+            //--- write previous bar remains
+            FileWriteStruct(ExtHandle,rate);
+            last_fpos=FileTell(ExtHandle);
+            //----
+            rate.time=time0/periodseconds;
+            rate.time*=periodseconds;
+            rate.open=Open[0];
+            rate.low=Low[0];
+            rate.high=High[0];
+            rate.close=Close[0];
+            rate.tick_volume=(long)Volume[0];
+            last_volume=rate.tick_volume;
+           }
+         //----
+         FileWriteStruct(ExtHandle,rate);
+         FileFlush(ExtHandle);
+         //---
+         if(hwnd==0)
+           {
+            hwnd=WindowHandle(Symbol(),i_period);
+            if(hwnd!=0)
+               Print("Chart window detected");
+           }
+         //--- refresh window not frequently than 1 time in 2 seconds
+         if(hwnd!=0 && cur_time-last_time>=2)
+           {
+            PostMessageA(hwnd,WM_COMMAND,33324,0);
+            last_time=cur_time;
+           }
+        }
+      Sleep(50); 
+     }      
+//---
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+  {
+//---
+   if(ExtHandle>=0)
+     {
+      FileClose(ExtHandle);
+      ExtHandle=-1;
+     }
+//---
+  }
+//+------------------------------------------------------------------+

data/vendor/pygments-main/tests/examplefiles/example.mqh

@@ -0,0 +1,123 @@
+//+------------------------------------------------------------------+
+//|                                                        Array.mqh |
+//|                   Copyright 2009-2013, MetaQuotes Software Corp. |
+//|                                              http://www.mql4.com |
+//+------------------------------------------------------------------+
+#include <Object.mqh>
+//+------------------------------------------------------------------+
+//| Class CArray                                                     |
+//| Purpose: Base class of dynamic arrays.                           |
+//|          Derives from class CObject.                             |
+//+------------------------------------------------------------------+
+class CArray : public CObject
+  {
+protected:
+   int               m_step_resize;      // increment size of the array
+   int               m_data_total;       // number of elements
+   int               m_data_max;         // maximmum size of the array without memory reallocation
+   int               m_sort_mode;        // mode of array sorting
+
+public:
+                     CArray(void);
+                    ~CArray(void);
+   //--- methods of access to protected data
+   int               Step(void) const { return(m_step_resize); }
+   bool              Step(const int step);
+   int               Total(void) const { return(m_data_total); }
+   int               Available(void) const { return(m_data_max-m_data_total); }
+   int               Max(void) const { return(m_data_max); }
+   bool              IsSorted(const int mode=0) const { return(m_sort_mode==mode); }
+   int               SortMode(void) const { return(m_sort_mode); }
+   //--- cleaning method
+   void              Clear(void) { m_data_total=0; }
+   //--- methods for working with files
+   virtual bool      Save(const int file_handle);
+   virtual bool      Load(const int file_handle);
+   //--- sorting method
+   void              Sort(const int mode=0);
+
+protected:
+   virtual void      QuickSort(int beg,int end,const int mode=0) { }
+  };
+//+------------------------------------------------------------------+
+//| Constructor                                                      |
+//+------------------------------------------------------------------+
+CArray::CArray(void) : m_step_resize(16),
+                       m_data_total(0),
+                       m_data_max(0),
+                       m_sort_mode(-1)
+  {
+  }
+//+------------------------------------------------------------------+
+//| Destructor                                                       |
+//+------------------------------------------------------------------+
+CArray::~CArray(void)
+  {
+  }
+//+------------------------------------------------------------------+
+//| Method Set for variable m_step_resize                            |
+//+------------------------------------------------------------------+
+bool CArray::Step(const int step)
+  {
+//--- check
+   if(step>0)
+     {
+      m_step_resize=step;
+      return(true);
+     }
+//--- failure
+   return(false);
+  }
+//+------------------------------------------------------------------+
+//| Sorting an array in ascending order                              |
+//+------------------------------------------------------------------+
+void CArray::Sort(const int mode)
+  {
+//--- check
+   if(IsSorted(mode))
+      return;
+   m_sort_mode=mode;
+   if(m_data_total<=1)
+      return;
+//--- sort
+   QuickSort(0,m_data_total-1,mode);
+  }
+//+------------------------------------------------------------------+
+//| Writing header of array to file                                  |
+//+------------------------------------------------------------------+
+bool CArray::Save(const int file_handle)
+  {
+//--- check handle
+   if(file_handle!=INVALID_HANDLE)
+     {
+      //--- write start marker - 0xFFFFFFFFFFFFFFFF
+      if(FileWriteLong(file_handle,-1)==sizeof(long))
+        {
+         //--- write array type
+         if(FileWriteInteger(file_handle,Type(),INT_VALUE)==INT_VALUE)
+            return(true);
+        }
+     }
+//--- failure
+   return(false);
+  }
+//+------------------------------------------------------------------+
+//| Reading header of array from file                                |
+//+------------------------------------------------------------------+
+bool CArray::Load(const int file_handle)
+  {
+//--- check handle
+   if(file_handle!=INVALID_HANDLE)
+     {
+      //--- read and check start marker - 0xFFFFFFFFFFFFFFFF
+      if(FileReadLong(file_handle)==-1)
+        {
+         //--- read and check array type
+         if(FileReadInteger(file_handle,INT_VALUE)==Type())
+            return(true);
+        }
+     }
+//--- failure
+   return(false);
+  }
+//+------------------------------------------------------------------+