pygments.rb 0.5.4 → 0.6.0

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

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+printf "%d %s\n" 10 "foo"
+printf "%d %s\n" $((10#1)) "bar"
+
+let "m = 10#${1:1:2}"
+echo $m
+
+m=$((10#${1:4:3} + 10#${1:1:3}))
+echo $m
+
+m=$((10#${1:4:3}))
+echo $m
+
+m=$((10#$1))
+echo $m
+
+m=$((10#1))
+echo $m
+
+m=$((10))
+echo $m

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

@@ -0,0 +1,31 @@
+doctype html
+html
+  head
+    title Slim Examples
+    meta name="keywords" content="template language"
+    meta name="author" content=author
+    javascript:
+      alert('Slim supports embedded javascript!')
+
+  body
+    h1 Markup examples
+
+    #content
+      p This example shows you how a basic Slim file looks like.
+
+      == yield
+
+      - unless items.empty?
+        table
+          - for item in items do
+            tr
+              td.name = item.name
+              td.price = item.price
+      - else
+        p
+          | No items found. Please add some inventory.
+            Thank you!
+
+    div id="footer"
+      = render 'footer'
+      | Copyright (C) #{year} #{author}

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

@@ -0,0 +1,51 @@
+include:
+  - moosefs
+
+{% for mnt in salt['cmd.run']('ls /dev/data/moose*').split() %}
+/mnt/moose{{ mnt[-1] }}:
+  mount.mounted:
+    - device: {{ mnt }}
+    - fstype: xfs
+    - mkmnt: True
+  file.directory:
+    - user: mfs
+    - group: mfs
+    - require:
+      - user: mfs
+      - group: mfs
+{% endfor %}
+
+/etc/mfshdd.cfg:
+  file.managed:
+    - source: salt://moosefs/mfshdd.cfg
+    - user: root
+    - group: root
+    - mode: 644
+    - template: jinja
+    - require:
+      - pkg: mfs-chunkserver
+
+/etc/mfschunkserver.cfg:
+  file.managed:
+    - source: salt://moosefs/mfschunkserver.cfg
+    - user: root
+    - group: root
+    - mode: 644
+    - template: jinja
+    - require:
+      - pkg: mfs-chunkserver
+
+mfs-chunkserver:
+  pkg:
+    - installed
+mfschunkserver:
+  service:
+    - running
+    - require:
+{% for mnt in salt['cmd.run']('ls /dev/data/moose*') %}
+      - mount: /mnt/moose{{ mnt[-1] }}
+      - file: /mnt/moose{{ mnt[-1] }}
+{% endfor %}
+      - file: /etc/mfschunkserver.cfg
+      - file: /etc/mfshdd.cfg
+      - file: /var/lib/mfs

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

@@ -19,6 +19,7 @@ data {
   positive_ordered[3] wibble;
   corr_matrix[3] grault;
   cov_matrix[3] garply;
+  cholesky_factor_cov[3] waldo;
   
   real<lower=-1,upper=1> foo1;
   real<lower=0> foo2;
@@ -94,6 +95,7 @@ model {
   // lp__ should be highlighted
   // normal_log as a function
   lp__ <- lp__ + normal_log(plugh, 0, 1);
+  increment_log_prob(normal_log(plugh, 0, 1));
   
   // print statement and string literal
   print("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_~@#$%^&*`'-+={}[].,;: ");

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

@@ -0,0 +1,9 @@
+(A) Call Mom @Phone +Family
+(A) 2014-01-08 Schedule annual checkup +Health
+(B) Outline chapter 5 +Novel @Computer
+(C) Add cover sheets @Office +TPSReports
+Plan backyard herb garden @Home
+Pick up milk @GroceryStore
+Research self-publishing services +Novel @Computer
+x 2014-01-10 Download Todo.txt mobile app @Phone
+x 2014-01-10 2014-01-07 Download Todo.txt CLI @Computer

data/vendor/pygments-main/tests/examplefiles/exampleScript.cfc

@@ -0,0 +1,241 @@
+<cfscript>
+/**
+********************************************************************************
+ContentBox - A Modular Content Platform
+Copyright 2012 by Luis Majano and Ortus Solutions, Corp
+www.gocontentbox.org | www.luismajano.com | www.ortussolutions.com
+********************************************************************************
+Apache License, Version 2.0
+
+Copyright Since [2012] [Luis Majano and Ortus Solutions,Corp]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+********************************************************************************
+* A generic content service for content objects
+*/
+component extends="coldbox.system.orm.hibernate.VirtualEntityService" singleton{
+
+	// DI
+	property name="settingService"			inject="id:settingService@cb";
+	property name="cacheBox"				inject="cachebox";
+	property name="log"						inject="logbox:logger:{this}";
+	property name="customFieldService" 	 	inject="customFieldService@cb";
+	property name="categoryService" 	 	inject="categoryService@cb";
+	property name="commentService" 	 		inject="commentService@cb";
+	property name="contentVersionService"	inject="contentVersionService@cb";
+	property name="authorService"			inject="authorService@cb";
+	property name="populator"				inject="wirebox:populator";
+	property name="systemUtil"				inject="SystemUtil@cb";
+	
+	/*
+	* Constructor
+	* @entityName.hint The content entity name to bind this service to.
+	*/
+	ContentService function init(entityName="cbContent"){
+		// init it
+		super.init(entityName=arguments.entityName, useQueryCaching=true);
+
+		// Test scope coloring in pygments
+		this.colorTestVar = "Just for testing pygments!";
+		cookie.colorTestVar = "";
+		client.colorTestVar = ""
+		session.colorTestVar = "";
+		application.colorTestVar = "";
+
+		return this;
+	}
+
+	/**
+	* Clear all content caches
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearAllCaches(boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clearByKeySnippet(keySnippet="cb-content",async=arguments.async);
+		return this;
+	}
+
+	/**
+	* Clear all page wrapper caches
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearAllPageWrapperCaches(boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper",async=arguments.async);
+		return this;
+	}
+
+	/**
+	* Clear all page wrapper caches
+	* @slug.hint The slug partial to clean on
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearPageWrapperCaches(required any slug, boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper-#arguments.slug#",async=arguments.async);
+		return this;
+	}
+
+	/**
+	* Clear a page wrapper cache
+	* @slug.hint The slug to clean
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearPageWrapper(required any slug, boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clear("cb-content-pagewrapper-#arguments.slug#/");
+		return this;
+	}
+
+	/**
+	* Searches published content with cool paramters, remember published content only
+	* @searchTerm.hint The search term to search
+	* @max.hint The maximum number of records to paginate
+	* @offset.hint The offset in the pagination
+	* @asQuery.hint Return as query or array of objects, defaults to array of objects
+	* @sortOrder.hint The sorting of the search results, defaults to publishedDate DESC
+	* @isPublished.hint Search for published, non-published or both content objects [true, false, 'all']
+	* @searchActiveContent.hint Search only content titles or both title and active content. Defaults to both.
+	*/
+	function searchContent(
+		any searchTerm="", 
+		numeric max=0, 
+		numeric offset=0, 
+		boolean asQuery=false, 
+		any sortOrder="publishedDate DESC", 
+		any isPublished=true, 
+		boolean searchActiveContent=true){
+
+		var results = {};
+		var c = newCriteria();
+
+		// only published content
+		if( isBoolean( arguments.isPublished ) ){
+			// Published bit
+			c.isEq( "isPublished", javaCast( "Boolean", arguments.isPublished ) );
+			// Published eq true evaluate other params
+			if( arguments.isPublished ){
+				c.isLt("publishedDate", now() )
+				.$or( c.restrictions.isNull("expireDate"), c.restrictions.isGT("expireDate", now() ) )
+				.isEq("passwordProtection","");
+			}
+		}
+
+		// Search Criteria
+		if( len( arguments.searchTerm ) ){
+			// like disjunctions
+			c.createAlias("activeContent","ac");
+			// Do we search title and active content or just title?
+			if( arguments.searchActiveContent ){
+				c.$or( c.restrictions.like("title","%#arguments.searchTerm#%"),
+				  	  c.restrictions.like("ac.content", "%#arguments.searchTerm#%") );
+			}
+			else{
+				c.like( "title", "%#arguments.searchTerm#%" ); 
+			}
+		}
+
+		// run criteria query and projections count
+		results.count = c.count( "contentID" );
+		results.content = c.resultTransformer( c.DISTINCT_ROOT_ENTITY )
+							.list(offset=arguments.offset, max=arguments.max, sortOrder=arguments.sortOrder, asQuery=arguments.asQuery);
+	
+		return results;
+	}
+
+/********************************************* PRIVATE *********************************************/
+	
+
+	/**
+	* Update the content hits
+	* @contentID.hint The content id to update
+	*/
+	private function syncUpdateHits(required contentID){
+		var q = new Query(sql="UPDATE cb_content SET hits = hits + 1 WHERE contentID = #arguments.contentID#").execute();
+		return this;
+	}
+	
+	
+	private function closureTest(){
+		methodCall(
+			param1,
+			function( arg1, required arg2 ){
+				var settings = settingService.getAllSettings(asStruct=true);
+				// Get appropriate cache provider
+				var cache = cacheBox.getCache( settings.cb_content_cacheName );
+				cache.clear("cb-content-pagewrapper-#arguments.slug#/");
+				return this;
+			},
+			param1
+		);
+	}
+	
+	private function StructliteralTest(){
+		return {
+			foo = bar,
+			brad = 'Wood',
+			func = function( arg1, required arg2 ){
+				var settings = settingService.getAllSettings(asStruct=true);
+				// Get appropriate cache provider
+				var cache = cacheBox.getCache( settings.cb_content_cacheName );
+				cache.clear("cb-content-pagewrapper-#arguments.slug#/");
+				return this;
+			},
+			array = [
+				1,
+				2,
+				3,
+				4,
+				5,
+				'test',
+				'testing',
+				'testerton',
+				{
+					foo = true,
+					brad = false,
+					wood = null
+				}
+			],
+			last = "final"
+		};
+	}
+	
+	private function arrayliteralTest(){
+		return [
+			1,
+			2,
+			3,
+			4,
+			5,
+			'test',
+			'testing',
+			'testerton',
+			{
+				foo = true,
+				brad = false,
+				wood = null
+			},
+			'testy-von-testavich'
+		];
+	}
+	
+}
+</cfscript>

data/vendor/pygments-main/tests/examplefiles/exampleTag.cfc

@@ -0,0 +1,18 @@
+<cfcomponent>
+	
+	<cffunction name="init" access="public" returntype="any">
+		<cfargument name="arg1" type="any" required="true">
+		<cfset this.myVariable = arguments.arg1>
+
+		<cfreturn this>
+	</cffunction>
+
+	<cffunction name="testFunc" access="private" returntype="void">
+		<cfargument name="arg1" type="any" required="false">
+		
+		<cfif structKeyExists(arguments, "arg1")>
+			<cfset writeoutput("Argument exists")>
+		</cfif>
+	</cffunction>
+	
+</cfcomponent>

data/vendor/pygments-main/tests/examplefiles/example_elixir.ex

@@ -1,363 +1,205 @@
-# We cannot use to_char_list because it depends on inspect,
-# which depends on protocol, which depends on this module.
-import Elixir::Builtin, except: [to_char_list: 1]
-
-defmodule Module do
-  require Erlang.ets, as: ETS
-
-  @moduledoc """
-  This module provides many functions to deal with modules during
-  compilation time. It allows a developer to dynamically attach
-  documentation, merge data, register attributes and so forth.
-
-  After the module is compiled, using many of the functions in
-  this module will raise errors, since it is out of their purpose
-  to inspect runtime data. Most of the runtime data can be inspected
-  via the `__info__(attr)` function attached to each compiled module.
-  """
-
-  @doc """
-  Evalutes the quotes contents in the given module context.
-  Raises an error if the module was already compiled.
-
-  ## Examples
-
-      defmodule Foo do
-        contents = quote do: (def sum(a, b), do: a + b)
-        Module.eval_quoted __MODULE__, contents, [], __FILE__, __LINE__
-      end
-
-      Foo.sum(1, 2) #=> 3
-  """
-  def eval_quoted(module, quoted, binding, filename, line) do
-    assert_not_compiled!(:eval_quoted, module)
-    { binding, scope } = Erlang.elixir_module.binding_and_scope_for_eval(line, to_char_list(filename), module, binding)
-    Erlang.elixir_def.reset_last(module)
-    Erlang.elixir.eval_quoted([quoted], binding, line, scope)
-  end
-
-  @doc """
-  Checks if the module is compiled or not.
-
-  ## Examples
-
-      defmodule Foo do
-        Module.compiled?(__MODULE__) #=> false
-      end
-
-      Module.compiled?(Foo) #=> true
-
-  """
-  def compiled?(module) do
-    table = data_table_for(module)
-    table == ETS.info(table, :name)
-  end
-
-  @doc """
-  Reads the data for the given module. This is used
-  to read data of uncompiled modules. If the module
-  was already compiled, you shoul access the data
-  directly by invoking `__info__(:data)` in that module.
-
-  ## Examples
-
-      defmodule Foo do
-        Module.merge_data __MODULE__, value: 1
-        Module.read_data __MODULE__ #=> [value: 1]
-      end
-
-  """
-  def read_data(module) do
-    assert_not_compiled!(:read_data, module)
-    ETS.lookup_element(data_table_for(module), :data, 2)
-  end
-
-  @doc """
-  Reads the data from `module` at the given key `at`.
-
-  ## Examples
-
-      defmodule Foo do
-        Module.merge_data __MODULE__, value: 1
-        Module.read_data __MODULE__, :value #=> 1
-      end
-
-  """
-  def read_data(module, at) do
-    Orddict.get read_data(module), at
-  end
-
-  @doc """
-  Merge the given data into the module, overriding any
-  previous one.
-
-  If any of the given data is a registered attribute, it is
-  automatically added to the attribute set, instead of marking
-  it as data. See register_attribute/2 and add_attribute/3 for
-  more info.
-
-  ## Examples
-
-      defmodule Foo do
-        Module.merge_data __MODULE__, value: 1
-      end
-
-      Foo.__info__(:data) #=> [value: 1]
-
-  """
-  def merge_data(module, data) do
-    assert_not_compiled!(:merge_data, module)
-
-    table      = data_table_for(module)
-    old        = ETS.lookup_element(table, :data, 2)
-    registered = ETS.lookup_element(table, :registered_attributes, 2)
-
-    { attrs, new } = Enum.partition data, fn({k,_}) -> List.member?(registered, k) end
-    Enum.each attrs, fn({k,v}) -> add_attribute(module, k, v) end
-    ETS.insert(table, { :data,  Orddict.merge(old, new) })
-  end
-
-  @doc """
-  Attaches documentation to a given function. It expects
-  the module the function belongs to, the line (a non negative
-  integer), the kind (def or defmacro), a tuple representing
-  the function and its arity and the documentation, which should
-  be either a binary or a boolean.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.add_doc(__MODULE__, __LINE__ + 1, :def, { :version, 0 }, "Manually added docs")
-        def version, do: 1
-      end
-
-  """
-  def add_doc(module, line, kind, tuple, doc) when
-      is_binary(doc) or is_boolean(doc) do
-    assert_not_compiled!(:add_doc, module)
-    case kind do
-    match: :defp
-      :warn
-    else:
-      table = docs_table_for(module)
-      ETS.insert(table, { tuple, line, kind, doc })
-      :ok
-    end
-  end
+# Numbers
+0b0101011
+1234 ; 0x1A ; 0xbeef ; 0763
+3.14 ; 5.0e21 ; 0.5e-12
+100_000_000
+
+# Characters
+?a ; ?1 ; ?\n ; ?\s ; ?\c ; ? ; ?,
+?\x{12} ; ?\x{abcd}
+?\x34 ; ?\xf
+?\123 ; ?\12 ; ?\7
+
+# Atoms
+:this ; :that
+:'complex atom'
+:"with' \"\" 'quotes"
+:" multi
+ line ' \s \123 \xff
+atom"
+:... ; :<<>> ; :%{} ; :% ; :{}
+:++; :--; :*; :~~~
+
+# Strings
+"Hello world"
+"Interspersed \x{ff} codes \7 \8 \65 \016 and \t\s\z\+ \\ escapes"
+"Quotes ' inside \" \123 the \"\" \xF string \\\" end"
+"Multiline
+   string"
+
+# Char lists
+'this is a list'
+'escapes \' \t \\\''
+'Multiline
+    char
+  list
+'
+
+# Binaries
+<<1, 2, 3>>
+<<"hello"::binary, c :: utf8, x::[4, unit(2)]>> = "hello™1"
+
+# Sigils
+~r/this + i\s "a" regex/
+~R'this + i\s "a" regex too'
+~w(hello #{ ["has" <> "123", '\c\d', "\123 interpol" | []] } world)s
+~W(hello #{no "123" \c\d \123 interpol} world)s
+
+~S"No escapes \s\t\n and no #{interpolation}"
+
+:"atoms work #{"to" <> "o"}"
+
+# Operators
+x = 1 + 2.0 * 3
+y = true and false; z = false xor true
+... = 144
+... == !x && y || z
+"hello" |> String.upcase |> String.downcase()
+{^z, a} = {true, x}
+
+# Lists, tuples, maps, keywords
+[1, :a, 'hello'] ++ [2, 3]
+[:head | [?t, ?a, ?i, ?l]]
+
+{:one, 2.0, "three"}
+
+[...: "this", <<>>: "is", %{}: "a keyword", %: "list", {}: "too"]
+["this is an atom too": 1, "so is this": 2]
+[option: "value", key: :word]
+[++: "operator", ~~~: :&&&]
+
+map = %{shortcut: "syntax"}
+%{map | "update" => "me"}
+%{ 12 => 13, :weird => ['thing'] }
+
+# Comprehensions
+for x <- 1..10, x < 5, do: {x, x}
+pixels = "12345678"
+for << <<r::4, g::4, b::4, a::4>> <- pixels >> do
+  [r, {g, %{"b" => a}}]
+end
+
+# String interpolation
+"String #{inspect "interpolation"} is quite #{1+4+7} difficult"
+
+# Modules
+defmodule Long.Module.Name do
+  @moduledoc "Simple module docstring"
 
   @doc """
-  Checks if a function was defined, regardless if it is
-  a macro or a private function. Use function_defined?/3
-  to assert for an specific type.
-
-  ## Examples
-
-      defmodule Example do
-        Module.function_defined? __MODULE__, { :version, 0 } #=> false
-        def version, do: 1
-        Module.function_defined? __MODULE__, { :version, 0 } #=> true
-      end
-
+  Multiline docstring
+  "with quotes"
+  and #{ %{"interpolation" => "in" <> "action"} }
   """
-  def function_defined?(module, tuple) when is_tuple(tuple) do
-    assert_not_compiled!(:function_defined?, module)
-    table = function_table_for(module)
-    ETS.lookup(table, tuple) != []
-  end
+  defstruct [:a, :name, :height]
 
-  @doc """
-  Checks if a function was defined and also for its `kind`.
-  `kind` can be either :def, :defp or :defmacro.
+  @doc ~S'''
+  No #{interpolation} of any kind.
+  \000 \x{ff}
 
-  ## Examples
-
-      defmodule Example do
-        Module.function_defined? __MODULE__, { :version, 0 }, :defp #=> false
-        def version, do: 1
-        Module.function_defined? __MODULE__, { :version, 0 }, :defp #=> false
-      end
-
-  """
-  def function_defined?(module, tuple, kind) do
-    List.member? defined_functions(module, kind), tuple
-  end
-
-  @doc """
-  Return all functions defined in the given module.
-
-  ## Examples
-
-      defmodule Example do
-        def version, do: 1
-        Module.defined_functions __MODULE__ #=> [{:version,1}]
-      end
-
-  """
-  def defined_functions(module) do
-    assert_not_compiled!(:defined_functions, module)
-    table = function_table_for(module)
-    lc { tuple, _, _ } in ETS.tab2list(table), do: tuple
-  end
-
-  @doc """
-  Returns all functions defined in te given module according
-  to its kind.
-
-  ## Examples
-
-      defmodule Example do
-        def version, do: 1
-        Module.defined_functions __MODULE__, :def  #=> [{:version,1}]
-        Module.defined_functions __MODULE__, :defp #=> []
-      end
-
-  """
-  def defined_functions(module, kind) do
-    assert_not_compiled!(:defined_functions, module)
-    table = function_table_for(module)
-    entry = kind_to_entry(kind)
-    ETS.lookup_element(table, entry, 2)
-  end
-
-  @doc """
-  Adds a compilation callback hook that is invoked
-  exactly before the module is compiled.
-
-  This callback is useful when used with `use` as a mechanism
-  to clean up any internal data in the module before it is compiled.
-
-  ## Examples
-
-  Imagine you are creating a module/library that is meant for
-  external usage called `MyLib`. It could be defined as:
-
-      defmodule MyLib do
-        def __using__(target) do
-          Module.merge_data target, some_data: true
-          Module.add_compile_callback(target, __MODULE__, :__callback__)
-        end
-
-        defmacro __callback__(target) do
-          value = Orddict.get(Module.read_data(target), :some_data, [])
-          quote do: (def my_lib_value, do: unquote(value))
-        end
-      end
-
-  And a module could use `MyLib` with:
-
-      defmodule App do
-        use ModuleTest::ToBeUsed
-      end
-
-  In the example above, `MyLib` defines a data to the target. This data
-  can be updated throughout the module definition and therefore, the final
-  value of the data can only be compiled using a compiation callback,
-  which will read the final value of :some_data and compile to a function.
-  """
-  def add_compile_callback(module, target, fun // :__compiling__) do
-    assert_not_compiled!(:add_compile_callback, module)
-    new   = { target, fun }
-    table = data_table_for(module)
-    old   = ETS.lookup_element(table, :compile_callbacks, 2)
-    ETS.insert(table, { :compile_callbacks,  [new|old] })
-  end
-
-  @doc """
-  Adds an Erlang attribute to the given module with the given
-  key and value. The same attribute can be added more than once.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.add_attribute __MODULE__, :custom_threshold_for_lib, 10
-      end
-
-  """
-  def add_attribute(module, key, value) when is_atom(key) do
-    assert_not_compiled!(:add_attribute, module)
-    table = data_table_for(module)
-    attrs = ETS.lookup_element(table, :attributes, 2)
-    ETS.insert(table, { :attributes, [{key, value}|attrs] })
-  end
-
-  @doc """
-  Deletes all attributes that matches the given key.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.add_attribute __MODULE__, :custom_threshold_for_lib, 10
-        Module.delete_attribute __MODULE__, :custom_threshold_for_lib
-      end
-
-  """
-  def delete_attribute(module, key) when is_atom(key) do
-    assert_not_compiled!(:delete_attribute, module)
-    table = data_table_for(module)
-    attrs = ETS.lookup_element(table, :attributes, 2)
-    final = lc {k,v} in attrs, k != key, do: {k,v}
-    ETS.insert(table, { :attributes, final })
-  end
-
-  @doc """
-  Registers an attribute. This allows a developer to use the data API
-  but Elixir will register the data as an attribute automatically.
-  By default, `vsn`, `behavior` and other Erlang attributes are
-  automatically registered.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.register_attribute __MODULE__, :custom_threshold_for_lib
-        @custom_threshold_for_lib 10
-      end
-
-  """
-  def register_attribute(module, new) do
-    assert_not_compiled!(:register_attribute, module)
-    table = data_table_for(module)
-    old = ETS.lookup_element(table, :registered_attributes, 2)
-    ETS.insert(table, { :registered_attributes,  [new|old] })
-  end
+  \n #{\x{ff}}
+  '''
+  def func(a, b \\ []), do: :ok
 
   @doc false
-  # Used internally to compile documentation. This function
-  # is private and must be used only internally.
-  def compile_doc(module, line, kind, pair) do
-    case read_data(module, :doc) do
-    match: nil
-      # We simply discard nil
-    match: doc
-      result = add_doc(module, line, kind, pair, doc)
-      merge_data(module, doc: nil)
-      result
-    end
+  def __before_compile__(_) do
+    :ok
   end
+end
 
-  ## Helpers
+# Structs
+defmodule Second.Module do
+  s = %Long.Module.Name{name: "Silly"}
+  %{s | height: {192, :cm}}
+end
 
-  defp kind_to_entry(:def),      do: :public
-  defp kind_to_entry(:defp),     do: :private
-  defp kind_to_entry(:defmacro), do: :macros
+# Types, pseudo-vars, attributes
+defmodule M do
+  @custom_attr :some_constant
 
-  defp to_char_list(list) when is_list(list),  do: list
-  defp to_char_list(bin)  when is_binary(bin), do: binary_to_list(bin)
+  @before_compile Long.Module.Name
 
-  defp data_table_for(module) do
-    list_to_atom Erlang.lists.concat([:d, module])
-  end
+  @typedoc "This is a type"
+  @type typ :: integer
 
-  defp function_table_for(module) do
-    list_to_atom Erlang.lists.concat([:f, module])
-  end
-
-  defp docs_table_for(module) do
-    list_to_atom Erlang.lists.concat([:o, module])
-  end
-
-  defp assert_not_compiled!(fun, module) do
-    compiled?(module) ||
-      raise ArgumentError, message:
-        "could not call #{fun} on module #{module} because it was already compiled"
-  end
-end
+  @typedoc """
+  Another type
+  """
+  @opaque typtyp :: 1..10
+
+  @spec func(typ, typtyp) :: :ok | :fail
+  def func(a, b) do
+    a || b || :ok || :fail
+    Path.expand("..", __DIR__)
+    IO.inspect __ENV__
+    __NOTAPSEUDOVAR__ = 11
+    __MODULE__.func(b, a)
+  end
+
+  defmacro m() do
+    __CALLER__
+  end
+end
+
+# Functions
+anon = fn x, y, z ->
+  fn(a, b, c) ->
+    &(x + y - z * a / &1 + b + div(&2, c))
+  end
+end
+
+&Set.put(&1, &2) ; & Set.put(&1, &2) ; &( Set.put(&1, &1) )
+
+# Function calls
+anon.(1, 2, 3); self; hd([1,2,3])
+Kernel.spawn(fn -> :ok end)
+IO.ANSI.black
+
+# Control flow
+if :this do
+  :that
+else
+  :otherwise
+end
+
+pid = self
+receive do
+  {:EXIT, _} -> :done
+  {^pid, :_} -> nil
+  after 100 -> :no_luck
+end
+
+case __ENV__.line do
+  x when is_integer(x) -> x
+  x when x in 1..12 -> -x
+end
+
+cond do
+  false -> "too bad"
+  4 > 5 -> "oops"
+  true -> nil
+end
+
+# Lexical scope modifiers
+import Kernel, except: [spawn: 1, +: 2, /: 2, Unless: 2]
+alias Long.Module.Name, as: Namen
+use Bitwise
+
+4 &&& 5
+2 <<< 3
+
+# Protocols
+defprotocol Useless do
+  def func1(this)
+  def func2(that)
+end
+
+defimpl Useless, for: Atom do
+end
+
+# Exceptions
+defmodule NotAnError do
+  defexception [:message]
+end
+
+raise NotAnError, message: "This is not an error"