text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Telligent.Evolution.Mobile.Web.Services;
using Telligent.Evolution.Mobile.Web.Configuration;
using System.Configuration;
using Telligent.Evolution.Extensibility.UI.Version1;
using Telligent.Evolution.Mobile.Web.Model;
using System.IO;
using System.Xml;
using System.Timers;

namespace Telligent.Evolution.Mobile.Web.Implementations
{
	internal class MobileConfiguration : IMobileConfiguration
	{
		private readonly object _settingsLock = new object();
		private FileSystemWatcher _watcher;
		private string _path;
		private DateTime _lastModified = DateTime.MinValue;

		static Timer _cacheInvalidatorThrottleTimer = null;
		static DateTime? _shouldInvalidateCacheAfter = null;
		static readonly object _cacheInvalidationLock = new object();

		internal MobileConfiguration()
		{
			var config = ConfigurationManager.GetSection("mobile") as MobileConfigurationSection;
			if (config != null)
			{
				EvolutionUrl = config.EvolutionUrl;
				EvolutionNetworkDomain = config.NetworkDomain;
				EvolutionNetworkPassword = config.NetworkPassword;
				EvolutionNetworkUserName = config.NetworkUserName;
				OAuthClientId = config.OAuth.ClientId;
				OAuthClientSecret = config.OAuth.ClientSecret;
				DefaultUserName = config.DefaultUser.UserName;
				DefaultUserLanguageKey = config.DefaultUser.LanguageKey;
				AuthorizationCookieName = config.Authorization.CookieName;
				AllowAnonymous = config.Authorization.AllowAnonymous;
				LoginPage = config.Authorization.LoginPage;
				UrlScheme = config.UrlScheme;

				if (config.DataFormats != null && config.DataFormats.Telephone != null && !string.IsNullOrEmpty(config.DataFormats.Telephone.Pattern))
					TelephonePattern = config.DataFormats.Telephone.Pattern;
				else
					TelephonePattern = @"(?:(?:\(?(?:00|\+)?(?:[1-4]\d\d|[1-9]\d?)\)?)?[\-\.\s\\\/]?)?(?:(?:\(?\d{3,}\)?[\-\.\s\\\/]?){2,})";
			}

			var dir = new DirectoryInfo(Path.GetDirectoryName(GetType().Assembly.CodeBase).Substring(6));
			_path = Path.Combine(dir.Parent.FullName, "Resources");

			_watcher = new FileSystemWatcher(_path);
			_watcher.Changed += (sender, e) => _shouldInvalidateCacheAfter = DateTime.Now.AddMilliseconds(500);
			_watcher.EnableRaisingEvents = true;

			// debounce cache invalidation to not pick up multiple changes when many files are
			// added or removed at once from /Resources
			_cacheInvalidatorThrottleTimer = new Timer(100);
			_cacheInvalidatorThrottleTimer.Elapsed += (sender, e) =>
			{
				try
				{
					lock (_cacheInvalidationLock)
					{
						if (_shouldInvalidateCacheAfter != null && DateTime.Now > _shouldInvalidateCacheAfter)
						{
							_shouldInvalidateCacheAfter = null;
							UpdateSettings();
							Host.Get(Host.DefaultId).ExpireCaches();
						}
					}
				}
				catch (Exception)
				{
				}
			};
			_cacheInvalidatorThrottleTimer.Start();

			UpdateSettings();
		}

		#region Settings Helpers

		private void UpdateSettings()
		{
			List<IScriptedContentFragmentExtension> extensions = new List<IScriptedContentFragmentExtension>();
			List<EntityUrl> entityUrls = new List<EntityUrl>();
			List<string> styleSheets = new List<string>();
			List<string> javaScripts = new List<string>();
			List<EmbeddedFile> files = new List<EmbeddedFile>();

			foreach (var file in System.IO.Directory.EnumerateFiles(_path, "*.xml").OrderBy(x => x))
			{
				var fileInfo = new FileInfo(file);
				if (fileInfo != null)
				{
					var lastModified = fileInfo.LastWriteTimeUtc;
					if (lastModified > _lastModified)
						_lastModified = lastModified;

					using (Stream stream = fileInfo.OpenRead())
					{
						XmlDocument document = new XmlDocument();
						XmlReaderSettings settings = new XmlReaderSettings();
						settings.DtdProcessing = DtdProcessing.Prohibit;
						document.Load(XmlReader.Create(stream, settings));

						var node = document.SelectSingleNode("descendant::entityUrls");
						if (node != null)
							LoadEntityUrls(node, entityUrls);

						node = document.SelectSingleNode("descendant::extensions");
						if (node != null)
							LoadExtensions(node, extensions);

						node = document.SelectSingleNode("descendant::styleSheets");
						if (node != null)
							LoadStyleSheets(node, styleSheets);

						node = document.SelectSingleNode("descendant::javaScripts");
						if (node != null)
							LoadJavaScripts(node, javaScripts);

						node = document.SelectSingleNode("descendant::embeddedFiles");
						if (node != null)
							LoadEmbeddedFiles(node, files);
					}
				}
			}

			Extensions = extensions.ToArray();
			EntityUrls = entityUrls.ToArray();
			StyleSheets = styleSheets.ToArray();
			JavaScripts = javaScripts.ToArray();
			EmbeddedFiles = files.ToArray();
		}

		private void LoadExtensions(XmlNode parentNode, List<IScriptedContentFragmentExtension> extensions)
		{
			foreach (XmlNode node in parentNode.ChildNodes)
			{
				if (node.Name == "extension")
				{
					var typeName = node.Attributes["type"] != null ? node.Attributes["type"].Value : null;
					if (!string.IsNullOrEmpty(typeName))
					{
						var type = Type.GetType(typeName, false);
						if (type != null)
						{
							var extension = Activator.CreateInstance(type) as IScriptedContentFragmentExtension;
							if (extension != null)
								extensions.Add(extension);
						}
					}
				}
			}
		}

		private void LoadEntityUrls(XmlNode parentNode, List<EntityUrl> entityUrls)
		{
			foreach (XmlNode node in parentNode.ChildNodes)
			{
				if (node.Name == "entityUrl")
				{
					var url = node.Attributes["url"] != null ? node.Attributes["url"].Value : null;

					if (!string.IsNullOrEmpty(url))
						entityUrls.Add(new EntityUrl {
							Url = url,
							Requirements = LoadEntityUrlRequirements(node),
							Tokens = LoadEntityUrlTokens(node)
						});
				}
			}
		}

		private EntityUrlRequirement[] LoadEntityUrlRequirements(XmlNode parentNode)
		{
			List<EntityUrlRequirement> requirements = new List<EntityUrlRequirement>();

			foreach (XmlNode node in parentNode.SelectNodes("descendant::requirements/requirement"))
			{
				var entity = node.Attributes["entityType"] != null ? node.Attributes["entityType"].Value : null;
				var idEquals = node.Attributes["idEquals"] != null ? node.Attributes["idEquals"].Value : null;
				var relationship = node.Attributes["relationship"] != null ? node.Attributes["relationship"].Value : null;
				var containerTypeIdEquals = node.Attributes["containerTypeIdEquals"] != null ? (Guid?) Guid.Parse(node.Attributes["containerTypeIdEquals"].Value) : (Guid?) null;
				var applicationTypeIdEquals = node.Attributes["applicationTypeIdEquals"] != null ? (Guid?) Guid.Parse(node.Attributes["applicationTypeIdEquals"].Value) : (Guid?) null;

				if (!string.IsNullOrEmpty(entity) && (idEquals != null || containerTypeIdEquals != null || applicationTypeIdEquals != null))
					requirements.Add(new EntityUrlRequirement {
						EntityType = entity,
						IdEquals = idEquals,
						ContainerTypeIdEquals = containerTypeIdEquals,
						ApplicationTypeIdEquals = applicationTypeIdEquals,
						Relationship = string.IsNullOrEmpty(relationship) ? null : relationship
					});
			}

			return requirements.ToArray();
		}

		private EntityUrlToken[] LoadEntityUrlTokens(XmlNode parentNode)
		{
			List<EntityUrlToken> tokens = new List<EntityUrlToken>();

			foreach (XmlNode node in parentNode.SelectNodes("descendant::tokens/token"))
			{
				var name = node.Attributes["name"] != null ? node.Attributes["name"].Value : null;
				var entity = node.Attributes["entityType"] != null ? node.Attributes["entityType"].Value : null;
				var relationship = node.Attributes["relationship"] != null ? node.Attributes["relationship"].Value : null;

				if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(entity))
					tokens.Add(new EntityUrlToken {
						EntityType = entity,
						Name = name,
						Relationship = string.IsNullOrEmpty(relationship) ? null : relationship
					});
			}

			return tokens.ToArray();
		}

		private void LoadStyleSheets(XmlNode parentNode, List<string> styleSheets)
		{
			foreach (XmlNode node in parentNode.ChildNodes)
			{
				if (node.Name == "styleSheet")
				{
					var styleSheet = node.InnerText;
					if (!string.IsNullOrEmpty(styleSheet))
						styleSheets.Add(styleSheet);
				}
			}
		}

		private void LoadJavaScripts(XmlNode parentNode, List<string> javaScripts)
		{
			foreach (XmlNode node in parentNode.ChildNodes)
			{
				if (node.Name == "javaScript")
				{
					var javaScript = node.InnerText;
					if (!string.IsNullOrEmpty(javaScript))
						javaScripts.Add(javaScript);
				}
			}
		}

		private void LoadEmbeddedFiles(XmlNode parentNode, List<EmbeddedFile> files)
		{
			foreach (XmlNode node in parentNode.ChildNodes)
			{
				if (node.Name == "embeddedFile")
				{
					var name = node.Attributes["name"] == null ? null : node.Attributes["name"].Value;
					var mimeType = node.Attributes["type"] == null ? null : node.Attributes["type"].Value;
					var isBase64 = node.Attributes["base64"] == null ? false : string.Compare(node.Attributes["base64"].Value, "true", StringComparison.OrdinalIgnoreCase) == 0;
					var data = node.InnerText;

					if (!string.IsNullOrEmpty(name))
					{
						files.Add(new EmbeddedFile(
							name,
							string.IsNullOrEmpty(mimeType) ? "application/octet-stream" : mimeType,
							isBase64 ? Convert.FromBase64String(data) : Encoding.UTF8.GetBytes(data)
							));
					}
				}
			}
		}

		#endregion

		#region IMobileConfiguration Members

		public string EvolutionUrl { get; private set; }
		public string EvolutionNetworkUserName { get; private set; }
		public string EvolutionNetworkPassword { get; private set; }
		public string EvolutionNetworkDomain { get; private set; }
		public string OAuthClientId { get; private set; }
		public string OAuthClientSecret { get; private set; }
		public string DefaultUserName { get; private set; }
		public string DefaultUserLanguageKey { get; private set; }
		public string AuthorizationCookieName { get; private set; }
		public bool AllowAnonymous { get; set; }
		public string LoginPage { get; private set; }
		public DateTime LastModifiedDateUtc { get { return _lastModified; } }
		public string UrlScheme { get; private set; }
		public string TelephonePattern { get; private set; }

		private IScriptedContentFragmentExtension[] _extensions;
		public IScriptedContentFragmentExtension[] Extensions
		{
			get
			{
				lock (_settingsLock)
				{
					return _extensions;
				}
			}
			private set
			{
				lock (_settingsLock)
				{
					_extensions = value;
				}
			}
		}

		private EmbeddedFile[] _embeddedFiles;
		public EmbeddedFile[] EmbeddedFiles
		{
			get
			{
				lock (_settingsLock)
				{
					return _embeddedFiles;
				}
			}
			private set
			{
				lock (_settingsLock)
				{
					_embeddedFiles = value;
				}
			}
		}

		private EntityUrl[] _entityUrls;
		public EntityUrl[] EntityUrls
		{
			get
			{
				lock (_settingsLock)
				{
					return _entityUrls;
				}
			}
			private set
			{
				lock (_settingsLock)
				{
					_entityUrls = value;
				}
			}
		}

		private string[] _styleSheets;
		public string[] StyleSheets
		{
			get
			{
				lock (_settingsLock)
				{
					return _styleSheets;
				}
			}
			private set
			{
				lock (_settingsLock)
				{
					_styleSheets = value;
				}
			}
		}

		private string[] _javaScripts;
		public string[] JavaScripts
		{
			get
			{
				lock (_settingsLock)
				{
					return _javaScripts;
				}
			}
			private set
			{
				lock (_settingsLock)
				{
					_javaScripts = value;
				}
			}
		}

		#endregion
	}
}


text:
namespace map {

AbsoluteGrid::AbsoluteGrid( int32_t Id )
    : IGrid( Id )
{

}

void AbsoluteGrid::Update( double DeltaTime )
{

}

void AbsoluteGrid::SetMousePosition( double x, double y )
{
    IGrid::SetMousePosition( x, y );
    mProcessedPosition = mMousePosition;
}

} // namespace map

redpajama_set_name: RedPajamaGithub


text:
<?php

/**
 * @uses       Zend_Service_DeveloperGarden_Request_AbstractRequest
 * @category   Zend
 * @package    Zend_Service
 * @subpackage DeveloperGarden
 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
 * @author     Marco Kaiser
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Zend_Service_DeveloperGarden_Request_LocalSearch_LocalSearchRequest
    extends Zend_Service_DeveloperGarden_Request_AbstractRequest
{
    /**
     * array of search parameters
     *
     * @var array
     */
    public $searchParameters = null;

    /**
     * original object
     *
     * @var Zend_Service_DeveloperGarden_LocalSearch_SearchParameters
     */
    private $_searchParameters = null;

    /**
     * account id
     *
     * @var integer
     */
    public $account = null;

    /**
     * constructor give them the environment and the sessionId
     *
     * @param integer $environment
     * @param Zend_Service_DeveloperGarden_LocalSearch_SearchParameters $searchParameters
     * @param integer $account
     * @return Zend_Service_DeveloperGarden_Request_AbstractRequest
     */
    public function __construct($environment,
        Zend_Service_DeveloperGarden_LocalSearch_SearchParameters $searchParameters,
        $account = null
    ) {
        parent::__construct($environment);
        $this->setSearchParameters($searchParameters)
             ->setAccount($account);
    }

    /**
     * @param integer $account
     */
    public function setAccount($account = null)
    {
        $this->account = $account;
        return $this;
    }

    /**
     * @return integer
     */
    public function getAccount()
    {
        return $this->account;
    }

    /**
     * @param Zend_Service_DeveloperGarden_LocalSearch_SearchParameters $searchParameters
     */
    public function setSearchParameters(
        Zend_Service_DeveloperGarden_LocalSearch_SearchParameters $searchParameters
    ) {
        $this->searchParameters  = $searchParameters->getSearchParameters();
        $this->_searchParameters = $searchParameters;
        return $this;
    }

    /**
     * @return Zend_Service_DeveloperGarden_LocalSearch_SearchParameters
     */
    public function getSearchParameters()
    {
        return $this->_searchParameters;
    }

}


text:
package org.jetbrains.io.webSocket;

import com.intellij.util.Time;

public final class WebSocketServerOptions {
  // client will disconnect if server doesn't response (i.e. doesn't send any message or special heartbeat packet to client) in specified time
  public int heartbeatDelay = 25 * Time.SECOND;

  public int closeTimeout = 60 * 1000;

  public WebSocketServerOptions heartbeatDelay(int value) {
    heartbeatDelay = value;
    return this;
  }

  public WebSocketServerOptions closeTimeout(int value) {
    closeTimeout = value;
    return this;
  }
}


text:
var Prism = (function() {

	var self = {

		languages : {},

		highlightAll : function() {
			var elements = document.querySelectorAll('code[class*="language-"]');

			for (var i = 0, element; element = elements[i++];) {
				self.highlightElement(element);
			}
		},

		highlightElement : function(element) {
			var language = element.className.match(/\blanguage-(?!\*)(\w+)\b/i)[1];
			var grammar = self.languages[language];

			// Set language on the parent, for styling
			var parent = element.parentNode;
			if (/pre/i.test(parent.nodeName)) {
				parent.className = parent.className + ' language-' + language;
			}

			var code = element.textContent;

			element.innerHTML = self.highlight(code, grammar, language);
		},

		highlight : function(text, grammar, language) {
			var tokens = self.tokenize(text, grammar);
			return self.Token.stringify(tokens, language);
		},

		tokenize : function(text, grammar) {
			var strarr = [ text ];

			tokenloop: for ( var token in grammar) {
				if (!grammar.hasOwnProperty(token) || !grammar[token]) {
					continue;
				}

				var pattern = grammar[token],
				    lookbehind = !!pattern.lookbehind,
				    lookbehindLength = 0;

				pattern = pattern.pattern || pattern;

				for (var i = 0; i < strarr.length; i++) { // Don't cache length as it changes during the loop

					var str = strarr[i];

					if (str instanceof self.Token) {
						continue;
					}

					var match = pattern.exec(str);

					if (match) {
						if (lookbehind) {
							lookbehindLength = match[1].length;
						}

						var from = match.index - 1 + lookbehindLength,
						    match = match[0].slice(lookbehindLength),
						    len = match.length,
						    to = from + len,
						    before = str.slice(0, from + 1),
						    after = str.slice(to + 1);

						var args = [ i, 1 ];

						if (before) {
							args.push(before);
						}

						var wrapped = new self.Token(token, match);

						args.push(wrapped);

						if (after) {
							args.push(after);
						}

						Array.prototype.splice.apply(strarr, args);
					}
				}
			}

			return strarr;
		},

		Token: function(type, content) {
			this.type = type;
			this.content = content;

			self.Token.stringify = function(o, language, parent) {
				if (typeof o == 'string') {
					return o;
				}

				if (Array.isArray(o)) {
					return o.map(function(element) {
						return self.Token.stringify(element, language, o);
					}).join('');
				}

				var content = self.Token.stringify(o.content, language, parent);
				var	classes = [ 'token', o.type ];

				return '' + content + '';
			};
		}
	};

	return self;

})();

document.addEventListener('DOMContentLoaded', Prism.highlightAll);

Prism.languages.java = {
	// C-like
	'comment': {
			pattern: /(^|[^\\])\/\*[\w\W]*?\*\//g,
			lookbehind: true
	},
	'string': /("|')(\\?.)*?\1/g,
	'class-name': {
		pattern: /((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/ig,
		lookbehind: true
	},
	'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/g,
	'boolean': /\b(true|false)\b/g,
	'function': {
		pattern: /[a-z0-9_]+\(/ig,
	},
	'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/g,
	'operator': /[-+]{1,2}|!|<=?|>=?|={1,3}|&{1,2}|\|?\||\?|\*|\/|\~|\^|\%/g,
	'ignore': /&(lt|gt|amp);/gi,
	'punctuation': /[{}[\];(),.:]/g,

	// Java Specific
	'keyword': /\b(abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while)\b/g,
	'number': /\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp\-]+\b|\b\d*\.?\d+[e]?[\d]*[df]\b|\W\d*\.?\d+\b/gi,
	'operator': {
		pattern: /(^|[^\.])(?:\+=|\+\+?|-=|--?|!=?|<{1,2}=?|>{1,3}=?|==?|&=|&&?|\|=|\|\|?|\?|\*=?|\/=?|%=?|\^=?|:|~)/gm,
		lookbehind: true
	}
};


text:
class TicketsController < ApplicationController
  before_action :authenticate_user!
  load_resource :conference, find_by: :short_title
  load_resource :ticket, through: :conference
  authorize_resource :conference_registrations, class: Registration
  before_action :check_load_resource, only: :index

  def index; end

  def check_load_resource
    if @tickets.empty?
      redirect_to root_path, notice: "There are no tickets available for #{@conference.title}!"
    end
  end
end


text:
Use MutationObserver to get notified of change events from the browser (Chrome, Firefox)

Mutation Observer is deprecated, but that's okay because we're not using it for actual content of changes, just notifications of change events.

Dependencies / Browser Version Quirks:

- Changes: Use polling in browsers that don't support MutationObserver (IE<9)
- Sockets: Flash instead of sockets for IE

---

## File by File
Overview of each file in alphabetical order

### change.js
Detect, serialize, and send changes

### core.js
Extend Underscore.js with modified and added functionality

### crc.js
A cyclic redundancy check (CRC) is a non-secure hash function designed to detect accidental changes to raw computer data. Not used anywhere yet.

### Data.js

	loads existing stored dom data

### difflib.js
jsdifflib v1.0. <http://snowtide.com/jsdifflib>

### dom.js

	not sure what this is, interface to id from the dom and helper functions for common dom operations?

### enact.js
Apply changes received to the user's dom nodes

- [fillmeout]

### ids.js
Utility functions for ids:

- retrieve or generate document hash ids
- retrieve global timestamp
- assemble message_id's

### indexdb_storage.js
initialize indexdb localstorage db & schema

### json.js
<http://www.JSON.org/js.html> JSON functions for non-modern browsers

### load_swf.js
IE shenanigans for sockets through swf, used by socket.js

### localstorage_storage.js
store, pack, get, etc. functions for local storage

### msgpack.js
(<http://msgpack.sourceforge.net/>) would be used to serialize/deserialize change data for localStorage

### mutation.js
Uses MutationObserver to check if the nodes have been modified and triggering callback.  It's the caller's responsibility to check before doing anything, to avoid infinite recursion. The call back we have prevents infinite recursion by storing the serialized dom node in jQuery data & diffing in the callback to ensure the incoming change is a new one.

If IE <9, fallback to polling with dom.traverse

### sequence_store.js
conditional code for index db vs local storage

### socket.js
Cross browser socketing

### storage.js
Currently short-circuited to use localStorage, but we'll need to use indexDB and serialize more complex objects (the deltas that transferred over the wire) when using localStorage, most likely using lz77 compressed json or msgpack

### swfobject.js
N/A, not used anywhere but would let you inject swf's.

### sync.js
The main API js file. Check or create the URL hash of a page, and use that to connect to a particular document socket

We should offer sample pasteable code for when the developer is already using the hash that reads/assembles a query string in the hash


text:
This repository defines Chef Style DevOps Kung fu.

It includes a presentation you can give, or ask people to watch, which explains
what DevOps is, and defines a style of practice that comes from the lived
experience of many DevOps professionals. It is a collaborative space, where all
practitioners of the style can come together to create a reference for how to
build up their own DevOps Kung fu, and teach others how to improve theirs.

You should start by [watching the presentation](https://www.youtube.com/watch?v=_DEToXsgrPc), then come back here. If you agree
with the fundamental principles, wish to practice our forms, and apply the style
to your professional life, you can join our school by sending a pull request to
this README file, and adding your name to the list of practitioners.

If you like most of what you see, but not all, or wish to emphasize different
things about your style - but you agree on the same fundamental principles - you
should fork this repository, remove the names of practitioners from this file,
and found your own school of DevOps Kung fu. All we ask is that you please give
attribution of your style as a derivative of Chef Style DevOps Kung fu.

## What is DevOps?

A cultural and professional movement, focused on how we build and operate high
velocity organizations, born from the experiences of its practitioners.

## Practitioners of Chef Style DevOps

* [Adam Jacob](http://chef.io)
* [Chris Nandor](http://pudge.net/)
* [Kenneth L McDowell II](https://github.com/kmcdowell85)
* [Parth Monga](https://github.com/Parthmonga)
* [Mark Lüntzel](https://github.com/luntzel)
* [Patrick O'Connor](http://github.com/dontrebootme)
* [Vandad Chaharlengi](https://github.com/vandadck)
* [Shashi Shilarnav](https://github.com/shashirsa)
* [Micah Coletti](http://ancestry.com)
* [Ian Atkin](https://versal.com)
* [Ian Henry](http://geekblood.com)
* [Paul Judt](http://www.shopatron.com)
* [Tony Flint](http://nefario.us)
* [Shaun Keenan](http://skeenan.net)
* [Marcin Sawicki](https://github.com/odcinek)
* Robert Wolff
* [Gregory Ruiz-Ade](https://github.com/gkra)
* [Phil Dibowitz](http://github.com/jaymzh)
* [Andy Claiborne](http://github.com/veloandy)
* [Joshua Timberman](https://github.com/jtimberman)
* [Scott Macfarlane](https://github.com/smacfarlane)
* [Luke Bradbury](https://github.com/hanskreuger)
* [Samuel Cassiba](http://github.com/scassiba)
* [Robb Kidd](http://github.com/robbkidd)
* [Thom May](https://github.com/thommay)
* [Matt Ray](http://github.com/mattray)
* [James Johnson](http://github.com/jcejohnson)
* [Nathen Harvey](http://github.com/nathenharvey)
* [Jason Schadel](http://github.com/wyrdvans)
* [Jessica DeVita](http://github.com/ubergeekgirl)
* [Terry J Fundak](http://github.com/tjsoftworks)
* [Erik Rogneby](http://github.com/err0)
* [Bryce Lynn](http://github.com/bignastybryce)
* [Todd Michael Bushnell](http://github.com/toddmichael)
* [Brian Scott](http://github.com/bscott)
* [Jeff LaPlante](http://github.com/jefflaplante)
* [Paul Dunnavant](http://github.com/pdunnavant)
* [Jim Constantine](http://github.com/jaconstantine)
* [Julian Dunn](http://github.com/juliandunn)
* [Justin Arbuckle](http://github.com/dromologue)
* [Jeff Hackert](https://github.com/jchackert)
* [John Martin](http://github.com/tekbuddha)
* [Alex Manly](http://github.com/alexmanly)
* [Alex Vinyar](http://github.com/vinyar)
* [Kim Halavakoski](http://github.com/khalavak)
* [Justin Schuhmann](https://github.com/EasyAsABC123)
* [Nathan Cerny](https://github.com/ncerny/)
* [Pawel Bartusch](http://twitter.com/pbartusch)
* [Steve Clark](http://github.com/sclark007)
* [Christopher Webber](https://github.com/cwebberOps)
* [Mark Bainter](http://github.com/mbainter)
* [Mike Thibodeau](http://github.com/MikeTLive)
* [David Chou](https://twitter.com/iamdavidschou)
* [David Echols](http://github.com/echohack)
* [Salim Afiune](http://github.com/afiune)
* [Michael Ducy](https://twitter.com/mfdii)
* [Tyler Fitch](https://github.com/tfitch)
* [Sander van Zoest](https://github.com/svanzoest)
* [Soo Choi](https://github.com/soosiechoi)
* [Kevin J. Dickerson](http://github.com/kevindickerson)
* [Seth Falcon](https://github.com/seth)
* [JJ Asghar](https://github.com/jjasghar)
* [Will Fisher](https://github.com/teknofire)
* [Jason McDonald](https://github.com/hamburglar)
* [Joe Nuspl](http://github.com/nvwls)
* [Ryan Cragun](https://github.com/ryancragun)
* [Nick Rycar](https://github.com/ChefRycar)
* [Justin Redd](https://twitter.com/justinredd)
* [Joshua Miller](https://github.com/jassinpain)
* [Rex Cerbas](https://github.com/rx007)
* [Lukasz Jagiello](https://github.com/ljagiello)
* [Kai Forsthövel](https://github.com/kforsthoevel)
* [Adam Leff](https://github.com/adamleff)
* [Steven Murawski](https://github.com/smurawski)
* [George Miranda](https://github.com/gmiranda23)
* [Sean OMeara](https://github.com/someara)
* [Torben Knerr](https://github.com/tknerr)
* [Franklin Webber](https://github.com/burtlo)
* [Jake Fagan](https://github.com/jakef)
* [Chris Sanders](https://github.com/chris-sanders-dot-org)
* [Lane McLaughlin](https://github.com/spacattac)
* [Jim Grill](https://github.com/jgrill)
* [Karolin Beck](https://github.com/karobeck)
* [Tony Notto](https://github.com/tonynotto)
* [Jeffery Padgett](https://github.com/jbpadgett)
* [Manuel Henke](https://github.com/ducke)
* [Kristian Vlaardingerbroek](https://github.com/rarenerd)
* [Andy Fleener](https://github.com/anfleene)
* [Jeffrey Einhorn](https://twitter.com/JeffEinhorn)
* [Mickie Smith](https://twitter.com/pagnmickie)
* [Kevin Duane](https://twitter.com/crackmac)
* [Will Moore](https://twitter.com/willmoore)
* [Michael Goetz](https://github.com/micgo)
* [Nick Thompson](https://github.com/wnthompson78)
* [Yvo van Doorn](https://twitter.com/yvov)
* [Jay Kline](https://github.com/slushpupie)
* [Matt Stratton](https://twitter.com/mattstratton)
* [Trevor Alexander Powell](https://www.linkedin.com/in/trevorapowell)
* [Dan Webb](https://github.com/damacus)
* [Jonathan Poole](https://github.com/digitaljedi2)
* [Medya Gh](https://github.com/medyagh)
* [Richard Nixon](https://github.com/trickyearlobe)
* [Chris Patti](http://www.feoh.org)
* [Amitraj Budhu](https://github.com/abudhu)
* [Reuben Dunn](https://github.com/DefSol)
* [Merritt Krakowitzer](https://github.com/mkrakowitzer)
* [David Aronsohn](https://github.com/tbunnyman)
* [Oleg Sumarokov](http://thgsn.org)
* [Fahd Sultan](https://github.com/fsultan)
* [Jesse R. Adams](https://github.com/jesseadams)
* [Rudger Gravestein](https://github.com/Rud5G)
* [Rakesh Patel](https://github.com/rocpatel)
* [Sean Carolan](https://github.com/scarolan)
* [Kevin Short](https://github.com/kshortdyn)
* [Venkat P](https://github.com/vbp11)
* [Bill Weiss](https://github.com/BillWeiss)
* [Nicholas Ng](https://github.com/nicholasnggithub)
* [Mahesh Varma](https://github.com/varmamahesh)
* [Trevor Hess](https://github.com/trevorghess)
* [Mark Jaffe](https://github.com/jaff)
* [Ricardo Lupo](https://github.com/ricardolupo)
* [Mark Lehmann](https://github.com/marklehmann26)
* [Marcin Mazurek](https://twitter.com/mazuchna)
* [Yigal Weinstein](http://8leggedunicorn.com)
* [Mike Tavares](https://github.com/TavaTech)
* [Jason Reslock](https://github.com/jreslock)
* [Justin Franks](https://github.com/justintfranks)
* [Travis Spaulding](https://github.com/tspaulding295)
* [Federico Castagnini](https://github.com/facastagnini)
* [Paul Everton](https://github.com/patternpaul)
* [Daniel Siefert](https://github.com/OfCourseITestedIt)
* [Mike Tyler](https://github.com/mtyler)
* [Matt Trail](https://github.com/mwtrail)
* [Shaw Innes](http://shawinnes.com)
* [Pavlos Ratis](https://github.com/dastergon)
* [Curtis Yanko](https://github.com/CMYanko)
* [Sam Thwaites](http://thwaitesy.com)
* [Jean Paul Mugizi] (https://github.com/mugizico)
* [Randall Morse](http://rmorse.com)
* [Petr Michalec](https://github.com/epcim)
* [Carlos Camacho](https://github.com/carlosdcg)
* [Joe Goggins](https://github.com/joegoggins)
* [Emir Ozer](https://github.com/emirozer)
* [Anshul Sharma](https://github.com/justanshulsharma)
* [Jason Walker](https://github.com/desktophero)
* [Tony Witherspoon](https://github.com/twitherspoon)
* [Martin Neiiendam](https://github.com/fracklen)
* [Rory Bramwell](https://github.com/rbramwell)
* [Jose Ventura](https://github.com/joventuraz)
* [Rajesh Raheja](https://github.com/rraheja)

## License

Chef Style DevOps Kung fu by Chef Software, Inc. is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License. A full list of incorporated sources is included.

## Based on reveal.js

Based on [reveal.js](http://lab.hakim.se/reveal-js).

Reveal.js is MIT licensed

Copyright (C) 2015 Hakim El Hattab, http://hakim.se