text:
package com.example.ligang.commonlibrary.loadingdrawable;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.util.DisplayMetrics;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;

public abstract class LoadingRenderer {
  private static final long ANIMATION_DURATION = 1333;

  private static final float DEFAULT_SIZE = 56.0f;
  private static final float DEFAULT_CENTER_RADIUS = 12.5f;
  private static final float DEFAULT_STROKE_WIDTH = 2.5f;

  protected float mWidth;
  protected float mHeight;
  protected float mStrokeWidth;
  protected float mCenterRadius;

  private long mDuration;
  private Drawable.Callback mCallback;
  private ValueAnimator mRenderAnimator;

  public LoadingRenderer(Context context) {
    setupDefaultParams(context);
    setupAnimators();
  }

  public abstract void draw(Canvas canvas, Rect bounds);
  public abstract void computeRender(float renderProgress);
  public abstract void setAlpha(int alpha);
  public abstract void setColorFilter(ColorFilter cf);
  public abstract void reset();

  public void start() {
    reset();
    setDuration(10000);
    mRenderAnimator.start();
  }

  public void stop() {
    mRenderAnimator.cancel();
  }

  public boolean isRunning() {
    return mRenderAnimator.isRunning();
  }

  public void setCallback(Drawable.Callback callback) {
    this.mCallback = callback;
  }

  protected void invalidateSelf() {
    mCallback.invalidateDrawable(null);
  }

  private void setupDefaultParams(Context context) {
    final DisplayMetrics metrics = context.getResources().getDisplayMetrics();
    final float screenDensity = metrics.density;

    mWidth = DEFAULT_SIZE * screenDensity;
    mHeight = DEFAULT_SIZE * screenDensity;
    mStrokeWidth = 2;
    mCenterRadius = DEFAULT_CENTER_RADIUS * screenDensity;

    mDuration = ANIMATION_DURATION;
  }

  private void setupAnimators() {
    mRenderAnimator = ValueAnimator.ofFloat(0.0f, 1.0f);
    mRenderAnimator.setRepeatCount(Animation.INFINITE);
    mRenderAnimator.setRepeatMode(ValueAnimator.RESTART);
    //fuck you! the default interpolator is AccelerateDecelerateInterpolator
    mRenderAnimator.setInterpolator(new LinearInterpolator());
    mRenderAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
      @Override
      public void onAnimationUpdate(ValueAnimator animation) {
        computeRender((float) animation.getAnimatedValue());
        invalidateSelf();
      }
    });
  }

  protected void addRenderListener(Animator.AnimatorListener animatorListener) {
    mRenderAnimator.addListener(animatorListener);
  }

  public void setCenterRadius(float centerRadius) {
    mCenterRadius = centerRadius;
  }

  public float getCenterRadius() {
    return mCenterRadius;
  }

  public void setStrokeWidth(float strokeWidth) {
    mStrokeWidth = strokeWidth;
  }

  public float getStrokeWidth() {
    return mStrokeWidth;
  }

  public float getWidth() {
    return mWidth;
  }

  public void setWidth(float width) {
    this.mWidth = width;
  }

  public float getHeight() {
    return mHeight;
  }

  public void setHeight(float height) {
    this.mHeight = height;
  }

  public long getDuration() {
    return mDuration;
  }

  public void setDuration(long duration) {
    this.mDuration = duration;
    mRenderAnimator.setDuration(mDuration);
  }
}


text:
package org.tinylog.impl.format.pattern.placeholders;

import java.util.EnumSet;
import java.util.Set;

import org.tinylog.impl.LogEntry;
import org.tinylog.impl.LogEntryValue;
import org.tinylog.impl.format.pattern.ValueType;

/**
 * Placeholder implementation for resolving the line number of a log entry in the source file.
 */
public class LinePlaceholder implements Placeholder {

	/** */
	public LinePlaceholder() {
	}

	@Override
	public Set<LogEntryValue> getRequiredLogEntryValues() {
		return EnumSet.of(LogEntryValue.LINE);
	}

	@Override
	public ValueType getType() {
		return ValueType.INTEGER;
	}

	@Override
	public Integer getValue(LogEntry entry) {
		int lineNumber = entry.getLineNumber();
		return lineNumber < 0 ? null : lineNumber;
	}

	@Override
	public void render(StringBuilder builder, LogEntry entry) {
		int lineNumber = entry.getLineNumber();
		if (lineNumber < 0) {
			builder.append("?");
		} else {
			builder.append(lineNumber);
		}
	}

}

redpajama_set_name: RedPajamaGithub


text:
#ifndef _ink_code_h_
#define _ink_code_h_

#include "ts/ink_apidefs.h"
#include "ts/ink_defs.h"
#include <openssl/md5.h>

/* INK_MD5 context. */
typedef MD5_CTX INK_DIGEST_CTX;

/*
  Wrappers around the MD5 functions, all of this should be depericated and just use the functions directly
*/

inkcoreapi int ink_code_md5(unsigned const char *input, int input_length, unsigned char *sixteen_byte_hash_pointer);
inkcoreapi char *ink_code_to_hex_str(char *dest33, uint8_t const *md5);

inkcoreapi int ink_code_incr_md5_init(INK_DIGEST_CTX *context);
inkcoreapi int ink_code_incr_md5_update(INK_DIGEST_CTX *context, const char *input, int input_length);
inkcoreapi int ink_code_incr_md5_final(char *sixteen_byte_hash_pointer, INK_DIGEST_CTX *context);
#endif


text:
package org.liferay.jukebox.trash;

import com.liferay.portal.kernel.exception.PortalException;
import com.liferay.portal.kernel.exception.SystemException;
import com.liferay.portal.kernel.trash.TrashActionKeys;
import com.liferay.portal.kernel.trash.TrashHandler;
import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
import com.liferay.portal.kernel.trash.TrashRenderer;
import com.liferay.portal.kernel.util.Validator;
import com.liferay.portal.kernel.util.WebKeys;
import com.liferay.portal.model.ContainerModel;
import com.liferay.portal.model.TrashedModel;
import com.liferay.portal.security.permission.PermissionChecker;
import com.liferay.portal.service.ServiceContext;
import com.liferay.portal.theme.ThemeDisplay;
import com.liferay.portal.util.PortalUtil;
import com.liferay.portlet.PortletURLFactoryUtil;
import com.liferay.portlet.trash.DuplicateEntryException;
import com.liferay.portlet.trash.TrashEntryConstants;
import com.liferay.portlet.trash.model.TrashEntry;

import java.util.ArrayList;
import java.util.List;

import javax.portlet.PortletRequest;
import javax.portlet.PortletURL;

import org.liferay.jukebox.model.Album;
import org.liferay.jukebox.model.Song;
import org.liferay.jukebox.service.AlbumLocalServiceUtil;
import org.liferay.jukebox.service.SongLocalServiceUtil;
import org.liferay.jukebox.service.permission.AlbumPermission;
import org.liferay.jukebox.service.permission.SongPermission;
import org.liferay.jukebox.util.PortletKeys;

/**
 * Implements trash handling for the songs.
 *
 * @author Sergio González
 */
public class SongTrashHandler extends JukeBoxBaseTrashHandler {

	public void checkDuplicateTrashEntry(
			TrashEntry trashEntry, long containerModelId, String newName)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(trashEntry.getClassPK());

		if (containerModelId == TrashEntryConstants.DEFAULT_CONTAINER_ID) {
			containerModelId = song.getAlbumId();
		}

		String originalName = trashEntry.getTypeSettingsProperty("title");

		if (Validator.isNotNull(newName)) {
			originalName = newName;
		}

		Song duplicateSong = SongLocalServiceUtil.getSong(
			song.getGroupId(), song.getArtistId(), containerModelId,
			originalName);

		if (duplicateSong != null) {
			DuplicateEntryException dee = new DuplicateEntryException();

			dee.setDuplicateEntryId(duplicateSong.getSongId());
			dee.setOldName(duplicateSong.getName());
			dee.setTrashEntryId(trashEntry.getEntryId());

			throw dee;
		}
	}

	@Override
	public void deleteTrashEntry(long classPK)
		throws PortalException, SystemException {

		SongLocalServiceUtil.deleteSong(classPK);
	}

	@Override
	public String getClassName() {
		return Song.class.getName();
	}

	@Override
	public ContainerModel getParentContainerModel(long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		return getContainerModel(song.getAlbumId());
	}

	@Override
	public ContainerModel getParentContainerModel(TrashedModel trashedModel)
		throws PortalException, SystemException {

		Song song = (Song)trashedModel;

		return getContainerModel(song.getAlbumId());
	}

	@Override
	public String getRestoreContainerModelLink(
			PortletRequest portletRequest, long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		PortletURL portletURL = getRestoreURL(portletRequest, classPK);

		portletURL.setParameter("songId", String.valueOf(song.getSongId()));

		return portletURL.toString();
	}

	@Override
	public String getRestoreMessage(
		PortletRequest portletRequest, long classPK) {

		ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
			WebKeys.THEME_DISPLAY);

		return themeDisplay.translate("songs");
	}

	@Override
	public String getTrashContainedModelName() {
		return "songs";
	}

	@Override
	public int getTrashContainedModelsCount(long classPK)
		throws PortalException, SystemException {

		Album album = AlbumLocalServiceUtil.getAlbum(classPK);

		return SongLocalServiceUtil.getSongsByAlbumIdCount(classPK);
	}

	@Override
	public List<TrashRenderer> getTrashContainedModelTrashRenderers(
			long classPK, int start, int end)
		throws PortalException, SystemException {

		List<TrashRenderer> trashRenderers = new ArrayList<TrashRenderer>();

		List<Song> songs = SongLocalServiceUtil.getSongsByAlbumId(
			classPK, start, end);

		for (Song song : songs) {
			TrashHandler trashHandler =
				TrashHandlerRegistryUtil.getTrashHandler(Song.class.getName());

			TrashRenderer trashRenderer = trashHandler.getTrashRenderer(
				song.getSongId());

			trashRenderers.add(trashRenderer);
		}

		return trashRenderers;
	}

	@Override
	public TrashEntry getTrashEntry(long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		return song.getTrashEntry();
	}

	@Override
	public boolean hasTrashPermission(
			PermissionChecker permissionChecker, long groupId, long classPK,
			String trashActionId)
		throws PortalException, SystemException {

		if (trashActionId.equals(TrashActionKeys.MOVE)) {
			return AlbumPermission.contains(
				permissionChecker, classPK, "ADD_ALBUM");
		}

		return super.hasTrashPermission(
			permissionChecker, groupId, classPK, trashActionId);
	}

	@Override
	public boolean isInTrash(long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		return song.isInTrash();
	}

	@Override
	public boolean isInTrashContainer(long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		return song.isInTrashContainer();
	}

	@Override
	public boolean isRestorable(long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		if ((song.getAlbumId() > 0) &&
			(AlbumLocalServiceUtil.fetchAlbum(song.getAlbumId()) == null)) {

			return false;
		}

		return !song.isInTrashContainer();
	}

	@Override
	public void moveEntry(
			long userId, long classPK, long containerModelId,
			ServiceContext serviceContext)
		throws PortalException, SystemException {

		SongLocalServiceUtil.moveSong(classPK, containerModelId);
	}

	@Override
	public void moveTrashEntry(
			long userId, long classPK, long containerId,
			ServiceContext serviceContext)
		throws PortalException, SystemException {

		SongLocalServiceUtil.moveSongFromTrash(userId, classPK, containerId);
	}

	@Override
	public void restoreTrashEntry(long userId, long classPK)
		throws PortalException, SystemException {

		SongLocalServiceUtil.restoreSongFromTrash(userId, classPK);
	}

	@Override
	public void updateTitle(long classPK, String name)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		song.setName(name);

		SongLocalServiceUtil.updateSong(song);
	}

	@Override
	protected long getGroupId(long classPK)
		throws PortalException, SystemException {

		Song song = SongLocalServiceUtil.getSong(classPK);

		return song.getGroupId();
	}

	protected PortletURL getRestoreURL(
			PortletRequest portletRequest, long classPK)
		throws PortalException, SystemException {

		String portletId = PortletKeys.SONGS;

		Song song = SongLocalServiceUtil.getSong(classPK);

		long plid = PortalUtil.getPlidFromPortletId(
			song.getGroupId(), PortletKeys.SONGS);

		PortletURL portletURL = PortletURLFactoryUtil.create(
			portletRequest, portletId, plid, PortletRequest.RENDER_PHASE);

		portletURL.setParameter("jspPage", "/html/songs/view_song.jsp");

		return portletURL;
	}

	@Override
	protected boolean hasPermission(
			PermissionChecker permissionChecker, long classPK, String actionId)
		throws PortalException, SystemException {

		return SongPermission.contains(permissionChecker, classPK, actionId);
	}

}


text:
export * from './player.component';
export * from '../shared/services/player.service';


text:
DATASET=$1

if [ -f "${DATASET}/gateway_config" ]; then
    echo "Loading gateway_config"
    . ${DATASET}/gateway_config
else
    echo "Unable to find gatway config script (${DATASET}/gateway_config.sh)"
    exit 1
fi

CERTS_DIR=${DATASET}/certs

rm -f ${CERTS_DIR}/${VOLUME}
rm -f ${CERTS_DIR}/${AG_NAME}
rm -f ${CERTS_DIR}/${ANONYMOUS_UG_NAME}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Day4
{
    using System.Security.Cryptography;

    public class AdventCointMiner
    {
        private readonly string _secret;

        public AdventCointMiner(string secret)
        {
            _secret = secret;
        }

        public int CalcNextMatch5(int seed)
        {
            var hasher = MD5.Create();

            for (;; seed++)
            {
                var sequence = Encoding.UTF7.GetBytes(_secret + seed);
                byte[] hash = hasher.ComputeHash(sequence);

                if (hash[0] == 0 && hash[1] == 0 && (hash[2] & 0xf0) == 0)
                {
                    return seed;
                }
            }
        }

        public int CalcNextMatch6(int seed)
        {
            var hasher = MD5.Create();

            for (; ; seed++)
            {
                var sequence = Encoding.UTF7.GetBytes(_secret + seed);
                byte[] hash = hasher.ComputeHash(sequence);

                if (hash[0] == 0 && hash[1] == 0 && hash[2] == 0)
                {
                    return seed;
                }
            }
        }
    }
}


text:
// script.aculo.us effects.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us,
// http://mir.aculo.us)
// Contributors:
// Justin Palmer (http://encytemedia.com/)
// Mark Pilgrim (http://diveintomark.org/)
// Martin Bialasinki
//
// script.aculo.us is freely distributable under the terms of an MIT-style
// license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

// converts rgb() and #xxx to #xxxxxx format,
// returns self (or first argument) if not convertable
String.prototype.parseColor = function() {
	var color = '#';
	if (this.slice(0, 4) == 'rgb(') {
		var cols = this.slice(4, this.length - 1).split(',');
		var i = 0;
		do {
			color += parseInt(cols[i]).toColorPart()
		} while (++i < 3);
	} else {
		if (this.slice(0, 1) == '#') {
			if (this.length == 4)
				for (var i = 1; i < 4; i++)
					color += (this.charAt(i) + this.charAt(i)).toLowerCase();
			if (this.length == 7)
				color = this.toLowerCase();
		}
	}
	return (color.length == 7 ? color : (arguments[0] || this));
};

/*--------------------------------------------------------------------------*/

Element.collectTextNodes = function(element) {
	return $A($(element).childNodes).collect(function(node) {
		return (node.nodeType == 3 ? node.nodeValue : (node.hasChildNodes()
				? Element.collectTextNodes(node)
				: ''));
	}).flatten().join('');
};

Element.collectTextNodesIgnoreClass = function(element, className) {
	return $A($(element).childNodes).collect(function(node) {
		return (node.nodeType == 3
				? node.nodeValue
				: ((node.hasChildNodes() && !Element.hasClassName(node,
						className)) ? Element.collectTextNodesIgnoreClass(node,
						className) : ''));
	}).flatten().join('');
};

Element.setContentZoom = function(element, percent) {
	element = $(element);
	element.setStyle({
				fontSize : (percent / 100) + 'em'
			});
	if (Prototype.Browser.WebKit)
		window.scrollBy(0, 0);
	return element;
};

Element.getInlineOpacity = function(element) {
	return $(element).style.opacity || '';
};

Element.forceRerendering = function(element) {
	try {
		element = $(element);
		var n = document.createTextNode(' ');
		element.appendChild(n);
		element.removeChild(n);
	} catch (e) {
	}
};

/*--------------------------------------------------------------------------*/

var Effect = {
	_elementDoesNotExistError : {
		name : 'ElementDoesNotExistError',
		message : 'The specified DOM element does not exist, but is required for this effect to operate'
	},
	Transitions : {
		linear : Prototype.K,
		sinoidal : function(pos) {
			return (-Math.cos(pos * Math.PI) / 2) + 0.5;
		},
		reverse : function(pos) {
			return 1 - pos;
		},
		flicker : function(pos) {
			var pos = ((-Math.cos(pos * Math.PI) / 4) + 0.75) + Math.random()
					/ 4;
			return pos > 1 ? 1 : pos;
		},
		wobble : function(pos) {
			return (-Math.cos(pos * Math.PI * (9 * pos)) / 2) + 0.5;
		},
		pulse : function(pos, pulses) {
			pulses = pulses || 5;
			return (((pos % (1 / pulses)) * pulses).round() == 0 ? ((pos
					* pulses * 2) - (pos * pulses * 2).floor()) : 1
					- ((pos * pulses * 2) - (pos * pulses * 2).floor()));
		},
		spring : function(pos) {
			return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
		},
		none : function(pos) {
			return 0;
		},
		full : function(pos) {
			return 1;
		}
	},
	DefaultOptions : {
		duration : 1.0, // seconds
		fps : 100, // 100= assume 66fps max.
		sync : false, // true for combining
		from : 0.0,
		to : 1.0,
		delay : 0.0,
		queue : 'parallel'
	},
	tagifyText : function(element) {
		var tagifyStyle = 'position:relative';
		if (Prototype.Browser.IE)
			tagifyStyle += ';zoom:1';

		element = $(element);
		$A(element.childNodes).each(function(child) {
			if (child.nodeType == 3) {
				child.nodeValue.toArray().each(function(character) {
					element.insertBefore(new Element('span', {
										style : tagifyStyle
									}).update(character == ' ' ? String
											.fromCharCode(160) : character),
							child);
				});
				Element.remove(child);
			}
		});
	},
	multiple : function(element, effect) {
		var elements;
		if (((typeof element == 'object') || Object.isFunction(element))
				&& (element.length))
			elements = element;
		else
			elements = $(element).childNodes;

		var options = Object.extend({
					speed : 0.1,
					delay : 0.0
				}, arguments[2] || {});
		var masterDelay = options.delay;

		$A(elements).each(function(element, index) {
					new effect(element, Object.extend(options, {
										delay : index * options.speed
												+ masterDelay
									}));
				});
	},
	PAIRS : {
		'slide' : ['SlideDown', 'SlideUp'],
		'blind' : ['BlindDown', 'BlindUp'],
		'appear' : ['Appear', 'Fade']
	},
	toggle : function(element, effect) {
		element = $(element);
		effect = (effect || 'appear').toLowerCase();
		var options = Object.extend({
					queue : {
						position : 'end',
						scope : (element.id || 'global'),
						limit : 1
					}
				}, arguments[2] || {});
		Effect[element.visible()
				? Effect.PAIRS[effect][1]
				: Effect.PAIRS[effect][0]](element, options);
	}
};

Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create(Enumerable, {
			initialize : function() {
				this.effects = [];
				this.interval = null;
			},
			_each : function(iterator) {
				this.effects._each(iterator);
			},
			add : function(effect) {
				var timestamp = new Date().getTime();

				var position = Object.isString(effect.options.queue)
						? effect.options.queue
						: effect.options.queue.position;

				switch (position) {
					case 'front' :
						// move unstarted effects after this effect
						this.effects.findAll(function(e) {
									return e.state == 'idle'
								}).each(function(e) {
									e.startOn += effect.finishOn;
									e.finishOn += effect.finishOn;
								});
						break;
					case 'with-last' :
						timestamp = this.effects.pluck('startOn').max()
								|| timestamp;
						break;
					case 'end' :
						// start effect after last queued effect has finished
						timestamp = this.effects.pluck('finishOn').max()
								|| timestamp;
						break;
				}

				effect.startOn += timestamp;
				effect.finishOn += timestamp;

				if (!effect.options.queue.limit
						|| (this.effects.length < effect.options.queue.limit))
					this.effects.push(effect);

				if (!this.interval)
					this.interval = setInterval(this.loop.bind(this), 15);
			},
			remove : function(effect) {
				this.effects = this.effects.reject(function(e) {
							return e == effect
						});
				if (this.effects.length == 0) {
					clearInterval(this.interval);
					this.interval = null;
				}
			},
			loop : function() {
				var timePos = new Date().getTime();
				for (var i = 0, len = this.effects.length; i < len; i++)
					this.effects[i] && this.effects[i].loop(timePos);
			}
		});

Effect.Queues = {
	instances : $H(),
	get : function(queueName) {
		if (!Object.isString(queueName))
			return queueName;

		return this.instances.get(queueName)
				|| this.instances.set(queueName, new Effect.ScopedQueue());
	}
};
Effect.Queue = Effect.Queues.get('global');

Effect.Base = Class.create({
	position : null,
	start : function(options) {
		function codeForEvent(options, eventName) {
			return ((options[eventName + 'Internal'] ? 'this.options.'
					+ eventName + 'Internal(this);' : '') + (options[eventName]
					? 'this.options.' + eventName + '(this);'
					: ''));
		}
		if (options && options.transition === false)
			options.transition = Effect.Transitions.linear;
		this.options = Object.extend(Object.extend({}, Effect.DefaultOptions),
				options || {});
		this.currentFrame = 0;
		this.state = 'idle';
		this.startOn = this.options.delay * 1000;
		this.finishOn = this.startOn + (this.options.duration * 1000);
		this.fromToDelta = this.options.to - this.options.from;
		this.totalTime = this.finishOn - this.startOn;
		this.totalFrames = this.options.fps * this.options.duration;

		eval('this.render = function(pos){ '
				+ 'if (this.state=="idle"){this.state="running";'
				+ codeForEvent(this.options, 'beforeSetup')
				+ (this.setup ? 'this.setup();' : '')
				+ codeForEvent(this.options, 'afterSetup')
				+ '};if (this.state=="running"){'
				+ 'pos=this.options.transition(pos)*' + this.fromToDelta + '+'
				+ this.options.from + ';' + 'this.position=pos;'
				+ codeForEvent(this.options, 'beforeUpdate')
				+ (this.update ? 'this.update(pos);' : '')
				+ codeForEvent(this.options, 'afterUpdate') + '}}');

		this.event('beforeStart');
		if (!this.options.sync)
			Effect.Queues.get(Object.isString(this.options.queue)
					? 'global'
					: this.options.queue.scope).add(this);
	},
	loop : function(timePos) {
		if (timePos >= this.startOn) {
			if (timePos >= this.finishOn) {
				this.render(1.0);
				this.cancel();
				this.event('beforeFinish');
				if (this.finish)
					this.finish();
				this.event('afterFinish');
				return;
			}
			var pos = (timePos - this.startOn) / this.totalTime, frame = (pos * this.totalFrames)
					.round();
			if (frame > this.currentFrame) {
				this.render(pos);
				this.currentFrame = frame;
			}
		}
	},
	cancel : function() {
		if (!this.options.sync)
			Effect.Queues.get(Object.isString(this.options.queue)
					? 'global'
					: this.options.queue.scope).remove(this);
		this.state = 'finished';
	},
	event : function(eventName) {
		if (this.options[eventName + 'Internal'])
			this.options[eventName + 'Internal'](this);
		if (this.options[eventName])
			this.options[eventName](this);
	},
	inspect : function() {
		var data = $H();
		for (property in this)
			if (!Object.isFunction(this[property]))
				data.set(property, this[property]);
		return '#<Effect:' + data.inspect() + ',options:'
				+ $H(this.options).inspect() + '>';
	}
});

Effect.Parallel = Class.create(Effect.Base, {
			initialize : function(effects) {
				this.effects = effects || [];
				this.start(arguments[1]);
			},
			update : function(position) {
				this.effects.invoke('render', position);
			},
			finish : function(position) {
				this.effects.each(function(effect) {
							effect.render(1.0);
							effect.cancel();
							effect.event('beforeFinish');
							if (effect.finish)
								effect.finish(position);
							effect.event('afterFinish');
						});
			}
		});

Effect.Tween = Class.create(Effect.Base, {
	initialize : function(object, from, to) {
		object = Object.isString(object) ? $(object) : object;
		var args = $A(arguments), method = args.last(), options = args.length == 5
				? args[3]
				: null;
		this.method = Object.isFunction(method) ? method.bind(object) : Object
				.isFunction(object[method])
				? object[method].bind(object)
				: function(value) {
					object[method] = value
				};
		this.start(Object.extend({
					from : from,
					to : to
				}, options || {}));
	},
	update : function(position) {
		this.method(position);
	}
});

Effect.Event = Class.create(Effect.Base, {
			initialize : function() {
				this.start(Object.extend({
							duration : 0
						}, arguments[0] || {}));
			},
			update : Prototype.emptyFunction
		});

Effect.Opacity = Class.create(Effect.Base, {
			initialize : function(element) {
				this.element = $(element);
				if (!this.element)
					throw (Effect._elementDoesNotExistError);
				// make this work on IE on elements without 'layout'
				if (Prototype.Browser.IE
						&& (!this.element.currentStyle.hasLayout))
					this.element.setStyle({
								zoom : 1
							});
				var options = Object.extend({
							from : this.element.getOpacity() || 0.0,
							to : 1.0
						}, arguments[1] || {});
				this.start(options);
			},
			update : function(position) {
				this.element.setOpacity(position);
			}
		});

Effect.Move = Class.create(Effect.Base, {
			initialize : function(element) {
				this.element = $(element);
				if (!this.element)
					throw (Effect._elementDoesNotExistError);
				var options = Object.extend({
							x : 0,
							y : 0,
							mode : 'relative'
						}, arguments[1] || {});
				this.start(options);
			},
			setup : function() {
				this.element.makePositioned();
				this.originalLeft = parseFloat(this.element.getStyle('left')
						|| '0');
				this.originalTop = parseFloat(this.element.getStyle('top')
						|| '0');
				if (this.options.mode == 'absolute') {
					this.options.x = this.options.x - this.originalLeft;
					this.options.y = this.options.y - this.originalTop;
				}
			},
			update : function(position) {
				this.element.setStyle({
							left : (this.options.x * position + this.originalLeft)
									.round()
									+ 'px',
							top : (this.options.y * position + this.originalTop)
									.round()
									+ 'px'
						});
			}
		});

// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
	return new Effect.Move(element, Object.extend({
						x : toLeft,
						y : toTop
					}, arguments[3] || {}));
};

Effect.Scale = Class.create(Effect.Base, {
			initialize : function(element, percent) {
				this.element = $(element);
				if (!this.element)
					throw (Effect._elementDoesNotExistError);
				var options = Object.extend({
							scaleX : true,
							scaleY : true,
							scaleContent : true,
							scaleFromCenter : false,
							scaleMode : 'box', // 'box' or 'contents' or { }
												// with provided values
							scaleFrom : 100.0,
							scaleTo : percent
						}, arguments[2] || {});
				this.start(options);
			},
			setup : function() {
				this.restoreAfterFinish = this.options.restoreAfterFinish || false;
				this.elementPositioning = this.element.getStyle('position');

				this.originalStyle = {};
				['top', 'left', 'width', 'height', 'fontSize'].each(
						function(k) {
							this.originalStyle[k] = this.element.style[k];
						}.bind(this));

				this.originalTop = this.element.offsetTop;
				this.originalLeft = this.element.offsetLeft;

				var fontSize = this.element.getStyle('font-size') || '100%';
				['em', 'px', '%', 'pt'].each(function(fontSizeType) {
							if (fontSize.indexOf(fontSizeType) > 0) {
								this.fontSize = parseFloat(fontSize);
								this.fontSizeType = fontSizeType;
							}
						}.bind(this));

				this.factor = (this.options.scaleTo - this.options.scaleFrom)
						/ 100;

				this.dims = null;
				if (this.options.scaleMode == 'box')
					this.dims = [this.element.offsetHeight,
							this.element.offsetWidth];
				if (/^content/.test(this.options.scaleMode))
					this.dims = [this.element.scrollHeight,
							this.element.scrollWidth];
				if (!this.dims)
					this.dims = [this.options.scaleMode.originalHeight,
							this.options.scaleMode.originalWidth];
			},
			update : function(position) {
				var currentScale = (this.options.scaleFrom / 100.0)
						+ (this.factor * position);
				if (this.options.scaleContent && this.fontSize)
					this.element.setStyle({
								fontSize : this.fontSize * currentScale
										+ this.fontSizeType
							});
				this.setDimensions(this.dims[0] * currentScale, this.dims[1]
								* currentScale);
			},
			finish : function(position) {
				if (this.restoreAfterFinish)
					this.element.setStyle(this.originalStyle);
			},
			setDimensions : function(height, width) {
				var d = {};
				if (this.options.scaleX)
					d.width = width.round() + 'px';
				if (this.options.scaleY)
					d.height = height.round() + 'px';
				if (this.options.scaleFromCenter) {
					var topd = (height - this.dims[0]) / 2;
					var leftd = (width - this.dims[1]) / 2;
					if (this.elementPositioning == 'absolute') {
						if (this.options.scaleY)
							d.top = this.originalTop - topd + 'px';
						if (this.options.scaleX)
							d.left = this.originalLeft - leftd + 'px';
					} else {
						if (this.options.scaleY)
							d.top = -topd + 'px';
						if (this.options.scaleX)
							d.left = -leftd + 'px';
					}
				}
				this.element.setStyle(d);
			}
		});

Effect.Highlight = Class.create(Effect.Base, {
	initialize : function(element) {
		this.element = $(element);
		if (!this.element)
			throw (Effect._elementDoesNotExistError);
		var options = Object.extend({
					startcolor : '#ffff99'
				}, arguments[1] || {});
		this.start(options);
	},
	setup : function() {
		// Prevent executing on elements not in the layout flow
		if (this.element.getStyle('display') == 'none') {
			this.cancel();
			return;
		}
		// Disable background image during the effect
		this.oldStyle = {};
		if (!this.options.keepBackgroundImage) {
			this.oldStyle.backgroundImage = this.element
					.getStyle('background-image');
			this.element.setStyle({
						backgroundImage : 'none'
					});
		}
		if (!this.options.endcolor)
			this.options.endcolor = this.element.getStyle('background-color')
					.parseColor('#ffffff');
		if (!this.options.restorecolor)
			this.options.restorecolor = this.element
					.getStyle('background-color');
		// init color calculations
		this._base = $R(0, 2).map(function(i) {
			return parseInt(
					this.options.startcolor.slice(i * 2 + 1, i * 2 + 3), 16)
		}.bind(this));
		this._delta = $R(0, 2).map(function(i) {
			return parseInt(this.options.endcolor.slice(i * 2 + 1, i * 2 + 3),
					16)
					- this._base[i]
		}.bind(this));
	},
	update : function(position) {
		this.element.setStyle({
					backgroundColor : $R(0, 2).inject('#', function(m, v, i) {
						return m
								+ ((this._base[i] + (this._delta[i] * position))
										.round().toColorPart());
					}.bind(this))
				});
	},
	finish : function() {
		this.element.setStyle(Object.extend(this.oldStyle, {
					backgroundColor : this.options.restorecolor
				}));
	}
});

Effect.ScrollTo = function(element) {
	var options = arguments[1] || {}, scrollOffsets = document.viewport
			.getScrollOffsets(), elementOffsets = $(element).cumulativeOffset(), max = (window.height || document.body.scrollHeight)
			- document.viewport.getHeight();

	if (options.offset)
		elementOffsets[1] += options.offset;

	return new Effect.Tween(null, scrollOffsets.top, elementOffsets[1] > max
					? max
					: elementOffsets[1], options, function(p) {
				scrollTo(scrollOffsets.left, p.round())
			});
};

/* ------------- combination effects ------------- */

Effect.Fade = function(element) {
	element = $(element);
	var oldOpacity = element.getInlineOpacity();
	var options = Object.extend({
				from : element.getOpacity() || 1.0,
				to : 0.0,
				afterFinishInternal : function(effect) {
					if (effect.options.to != 0)
						return;
					effect.element.hide().setStyle({
								opacity : oldOpacity
							});
				}
			}, arguments[1] || {});
	return new Effect.Opacity(element, options);
};

Effect.Appear = function(element) {
	element = $(element);
	var options = Object.extend({
				from : (element.getStyle('display') == 'none' ? 0.0 : element
						.getOpacity()
						|| 0.0),
				to : 1.0,
				// force Safari to render floated elements properly
				afterFinishInternal : function(effect) {
					effect.element.forceRerendering();
				},
				beforeSetup : function(effect) {
					effect.element.setOpacity(effect.options.from).show();
				}
			}, arguments[1] || {});
	return new Effect.Opacity(element, options);
};

Effect.Puff = function(element) {
	element = $(element);
	var oldStyle = {
		opacity : element.getInlineOpacity(),
		position : element.getStyle('position'),
		top : element.style.top,
		left : element.style.left,
		width : element.style.width,
		height : element.style.height
	};
	return new Effect.Parallel([new Effect.Scale(element, 200, {
								sync : true,
								scaleFromCenter : true,
								scaleContent : true,
								restoreAfterFinish : true
							}), new Effect.Opacity(element, {
								sync : true,
								to : 0.0
							})], Object.extend({
						duration : 1.0,
						beforeSetupInternal : function(effect) {
							Position.absolutize(effect.effects[0].element)
						},
						afterFinishInternal : function(effect) {
							effect.effects[0].element.hide().setStyle(oldStyle);
						}
					}, arguments[1] || {}));
};

Effect.BlindUp = function(element) {
	element = $(element);
	element.makeClipping();
	return new Effect.Scale(element, 0, Object.extend({
						scaleContent : false,
						scaleX : false,
						restoreAfterFinish : true,
						afterFinishInternal : function(effect) {
							effect.element.hide().undoClipping();
						}
					}, arguments[1] || {}));
};

Effect.BlindDown = function(element) {
	element = $(element);
	var elementDimensions = element.getDimensions();
	return new Effect.Scale(element, 100, Object.extend({
						scaleContent : false,
						scaleX : false,
						scaleFrom : 0,
						scaleMode : {
							originalHeight : elementDimensions.height,
							originalWidth : elementDimensions.width
						},
						restoreAfterFinish : true,
						afterSetup : function(effect) {
							effect.element.makeClipping().setStyle({
										height : '0px'
									}).show();
						},
						afterFinishInternal : function(effect) {
							effect.element.undoClipping();
						}
					}, arguments[1] || {}));
};

Effect.SwitchOff = function(element) {
	element = $(element);
	var oldOpacity = element.getInlineOpacity();
	return new Effect.Appear(element, Object.extend({
						duration : 0.4,
						from : 0,
						transition : Effect.Transitions.flicker,
						afterFinishInternal : function(effect) {
							new Effect.Scale(effect.element, 1, {
										duration : 0.3,
										scaleFromCenter : true,
										scaleX : false,
										scaleContent : false,
										restoreAfterFinish : true,
										beforeSetup : function(effect) {
											effect.element.makePositioned()
													.makeClipping();
										},
										afterFinishInternal : function(effect) {
											effect.element.hide()
													.undoClipping()
													.undoPositioned().setStyle(
															{
																opacity : oldOpacity
															});
										}
									})
						}
					}, arguments[1] || {}));
};

Effect.DropOut = function(element) {
	element = $(element);
	var oldStyle = {
		top : element.getStyle('top'),
		left : element.getStyle('left'),
		opacity : element.getInlineOpacity()
	};
	return new Effect.Parallel([new Effect.Move(element, {
								x : 0,
								y : 100,
								sync : true
							}), new Effect.Opacity(element, {
								sync : true,
								to : 0.0
							})], Object.extend({
						duration : 0.5,
						beforeSetup : function(effect) {
							effect.effects[0].element.makePositioned();
						},
						afterFinishInternal : function(effect) {
							effect.effects[0].element.hide().undoPositioned()
									.setStyle(oldStyle);
						}
					}, arguments[1] || {}));
};

Effect.Shake = function(element) {
	element = $(element);
	var options = Object.extend({
				distance : 20,
				duration : 0.5
			}, arguments[1] || {});
	var distance = parseFloat(options.distance);
	var split = parseFloat(options.duration) / 10.0;
	var oldStyle = {
		top : element.getStyle('top'),
		left : element.getStyle('left')
	};
	return new Effect.Move(element, {
		x : distance,
		y : 0,
		duration : split,
		afterFinishInternal : function(effect) {
			new Effect.Move(effect.element, {
				x : -distance * 2,
				y : 0,
				duration : split * 2,
				afterFinishInternal : function(effect) {
					new Effect.Move(effect.element, {
						x : distance * 2,
						y : 0,
						duration : split * 2,
						afterFinishInternal : function(effect) {
							new Effect.Move(effect.element, {
								x : -distance * 2,
								y : 0,
								duration : split * 2,
								afterFinishInternal : function(effect) {
									new Effect.Move(effect.element, {
										x : distance * 2,
										y : 0,
										duration : split * 2,
										afterFinishInternal : function(effect) {
											new Effect.Move(effect.element, {
												x : -distance,
												y : 0,
												duration : split,
												afterFinishInternal : function(
														effect) {
													effect.element
															.undoPositioned()
															.setStyle(oldStyle);
												}
											})
										}
									})
								}
							})
						}
					})
				}
			})
		}
	});
};

Effect.SlideDown = function(element) {
	element = $(element).cleanWhitespace();
	// SlideDown need to have the content of the element wrapped in a container
	// element with fixed height!
	var oldInnerBottom = element.down().getStyle('bottom');
	var elementDimensions = element.getDimensions();
	return new Effect.Scale(element, 100, Object.extend({
						scaleContent : false,
						scaleX : false,
						scaleFrom : window.opera ? 0 : 1,
						scaleMode : {
							originalHeight : elementDimensions.height,
							originalWidth : elementDimensions.width
						},
						restoreAfterFinish : true,
						afterSetup : function(effect) {
							effect.element.makePositioned();
							effect.element.down().makePositioned();
							if (window.opera)
								effect.element.setStyle({
											top : ''
										});
							effect.element.makeClipping().setStyle({
										height : '0px'
									}).show();
						},
						afterUpdateInternal : function(effect) {
							effect.element.down().setStyle({
								bottom : (effect.dims[0] - effect.element.clientHeight)
										+ 'px'
							});
						},
						afterFinishInternal : function(effect) {
							effect.element.undoClipping().undoPositioned();
							effect.element.down().undoPositioned().setStyle({
										bottom : oldInnerBottom
									});
						}
					}, arguments[1] || {}));
};

Effect.SlideUp = function(element) {
	element = $(element).cleanWhitespace();
	var oldInnerBottom = element.down().getStyle('bottom');
	var elementDimensions = element.getDimensions();
	return new Effect.Scale(element, window.opera ? 0 : 1, Object.extend({
						scaleContent : false,
						scaleX : false,
						scaleMode : 'box',
						scaleFrom : 100,
						scaleMode : {
							originalHeight : elementDimensions.height,
							originalWidth : elementDimensions.width
						},
						restoreAfterFinish : true,
						afterSetup : function(effect) {
							effect.element.makePositioned();
							effect.element.down().makePositioned();
							if (window.opera)
								effect.element.setStyle({
											top : ''
										});
							effect.element.makeClipping().show();
						},
						afterUpdateInternal : function(effect) {
							effect.element.down().setStyle({
								bottom : (effect.dims[0] - effect.element.clientHeight)
										+ 'px'
							});
						},
						afterFinishInternal : function(effect) {
							effect.element.hide().undoClipping()
									.undoPositioned();
							effect.element.down().undoPositioned().setStyle({
										bottom : oldInnerBottom
									});
						}
					}, arguments[1] || {}));
};

// Bug in opera makes the TD containing this element expand for a instance after
// finish
Effect.Squish = function(element) {
	return new Effect.Scale(element, window.opera ? 1 : 0, {
				restoreAfterFinish : true,
				beforeSetup : function(effect) {
					effect.element.makeClipping();
				},
				afterFinishInternal : function(effect) {
					effect.element.hide().undoClipping();
				}
			});
};

Effect.Grow = function(element) {
	element = $(element);
	var options = Object.extend({
				direction : 'center',
				moveTransition : Effect.Transitions.sinoidal,
				scaleTransition : Effect.Transitions.sinoidal,
				opacityTransition : Effect.Transitions.full
			}, arguments[1] || {});
	var oldStyle = {
		top : element.style.top,
		left : element.style.left,
		height : element.style.height,
		width : element.style.width,
		opacity : element.getInlineOpacity()
	};

	var dims = element.getDimensions();
	var initialMoveX, initialMoveY;
	var moveX, moveY;

	switch (options.direction) {
		case 'top-left' :
			initialMoveX = initialMoveY = moveX = moveY = 0;
			break;
		case 'top-right' :
			initialMoveX = dims.width;
			initialMoveY = moveY = 0;
			moveX = -dims.width;
			break;
		case 'bottom-left' :
			initialMoveX = moveX = 0;
			initialMoveY = dims.height;
			moveY = -dims.height;
			break;
		case 'bottom-right' :
			initialMoveX = dims.width;
			initialMoveY = dims.height;
			moveX = -dims.width;
			moveY = -dims.height;
			break;
		case 'center' :
			initialMoveX = dims.width / 2;
			initialMoveY = dims.height / 2;
			moveX = -dims.width / 2;
			moveY = -dims.height / 2;
			break;
	}

	return new Effect.Move(element, {
				x : initialMoveX,
				y : initialMoveY,
				duration : 0.01,
				beforeSetup : function(effect) {
					effect.element.hide().makeClipping().makePositioned();
				},
				afterFinishInternal : function(effect) {
					new Effect.Parallel([
									new Effect.Opacity(effect.element, {
												sync : true,
												to : 1.0,
												from : 0.0,
												transition : options.opacityTransition
											}),
									new Effect.Move(effect.element, {
												x : moveX,
												y : moveY,
												sync : true,
												transition : options.moveTransition
											}),
									new Effect.Scale(effect.element, 100, {
												scaleMode : {
													originalHeight : dims.height,
													originalWidth : dims.width
												},
												sync : true,
												scaleFrom : window.opera
														? 1
														: 0,
												transition : options.scaleTransition,
												restoreAfterFinish : true
											})], Object.extend({
										beforeSetup : function(effect) {
											effect.effects[0].element.setStyle(
													{
														height : '0px'
													}).show();
										},
										afterFinishInternal : function(effect) {
											effect.effects[0].element
													.undoClipping()
													.undoPositioned()
													.setStyle(oldStyle);
										}
									}, options))
				}
			});
};

Effect.Shrink = function(element) {
	element = $(element);
	var options = Object.extend({
				direction : 'center',
				moveTransition : Effect.Transitions.sinoidal,
				scaleTransition : Effect.Transitions.sinoidal,
				opacityTransition : Effect.Transitions.none
			}, arguments[1] || {});
	var oldStyle = {
		top : element.style.top,
		left : element.style.left,
		height : element.style.height,
		width : element.style.width,
		opacity : element.getInlineOpacity()
	};

	var dims = element.getDimensions();
	var moveX, moveY;

	switch (options.direction) {
		case 'top-left' :
			moveX = moveY = 0;
			break;
		case 'top-right' :
			moveX = dims.width;
			moveY = 0;
			break;
		case 'bottom-left' :
			moveX = 0;
			moveY = dims.height;
			break;
		case 'bottom-right' :
			moveX = dims.width;
			moveY = dims.height;
			break;
		case 'center' :
			moveX = dims.width / 2;
			moveY = dims.height / 2;
			break;
	}

	return new Effect.Parallel([new Effect.Opacity(element, {
								sync : true,
								to : 0.0,
								from : 1.0,
								transition : options.opacityTransition
							}),
					new Effect.Scale(element, window.opera ? 1 : 0, {
								sync : true,
								transition : options.scaleTransition,
								restoreAfterFinish : true
							}), new Effect.Move(element, {
								x : moveX,
								y : moveY,
								sync : true,
								transition : options.moveTransition
							})], Object.extend({
						beforeStartInternal : function(effect) {
							effect.effects[0].element.makePositioned()
									.makeClipping();
						},
						afterFinishInternal : function(effect) {
							effect.effects[0].element.hide().undoClipping()
									.undoPositioned().setStyle(oldStyle);
						}
					}, options));
};

Effect.Pulsate = function(element) {
	element = $(element);
	var options = arguments[1] || {};
	var oldOpacity = element.getInlineOpacity();
	var transition = options.transition || Effect.Transitions.sinoidal;
	var reverser = function(pos) {
		return transition(1 - Effect.Transitions.pulse(pos, options.pulses))
	};
	reverser.bind(transition);
	return new Effect.Opacity(element, Object.extend(Object.extend({
								duration : 2.0,
								from : 0,
								afterFinishInternal : function(effect) {
									effect.element.setStyle({
												opacity : oldOpacity
											});
								}
							}, options), {
						transition : reverser
					}));
};

Effect.Fold = function(element) {
	element = $(element);
	var oldStyle = {
		top : element.style.top,
		left : element.style.left,
		width : element.style.width,
		height : element.style.height
	};
	element.makeClipping();
	return new Effect.Scale(element, 5, Object.extend({
						scaleContent : false,
						scaleX : false,
						afterFinishInternal : function(effect) {
							new Effect.Scale(element, 1, {
										scaleContent : false,
										scaleY : false,
										afterFinishInternal : function(effect) {
											effect.element.hide()
													.undoClipping()
													.setStyle(oldStyle);
										}
									});
						}
					}, arguments[1] || {}));
};

Effect.Morph = Class.create(Effect.Base, {
	initialize : function(element) {
		this.element = $(element);
		if (!this.element)
			throw (Effect._elementDoesNotExistError);
		var options = Object.extend({
					style : {}
				}, arguments[1] || {});

		if (!Object.isString(options.style))
			this.style = $H(options.style);
		else {
			if (options.style.include(':'))
				this.style = options.style.parseStyle();
			else {
				this.element.addClassName(options.style);
				this.style = $H(this.element.getStyles());
				this.element.removeClassName(options.style);
				var css = this.element.getStyles();
				this.style = this.style.reject(function(style) {
							return style.value == css[style.key];
						});
				options.afterFinishInternal = function(effect) {
					effect.element.addClassName(effect.options.style);
					effect.transforms.each(function(transform) {
								effect.element.style[transform.style] = '';
							});
				}
			}
		}
		this.start(options);
	},

	setup : function() {
		function parseColor(color) {
			if (!color || ['rgba(0, 0, 0, 0)', 'transparent'].include(color))
				color = '#ffffff';
			color = color.parseColor();
			return $R(0, 2).map(function(i) {
						return parseInt(color.slice(i * 2 + 1, i * 2 + 3), 16)
					});
		}
		this.transforms = this.style.map(function(pair) {
			var property = pair[0], value = pair[1], unit = null;

			if (value.parseColor('#zzzzzz') != '#zzzzzz') {
				value = value.parseColor();
				unit = 'color';
			} else if (property == 'opacity') {
				value = parseFloat(value);
				if (Prototype.Browser.IE
						&& (!this.element.currentStyle.hasLayout))
					this.element.setStyle({
								zoom : 1
							});
			} else if (Element.CSS_LENGTH.test(value)) {
				var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
				value = parseFloat(components[1]);
				unit = (components.length == 3) ? components[2] : null;
			}

			var originalValue = this.element.getStyle(property);
			return {
				style : property.camelize(),
				originalValue : unit == 'color'
						? parseColor(originalValue)
						: parseFloat(originalValue || 0),
				targetValue : unit == 'color' ? parseColor(value) : value,
				unit : unit
			};
		}.bind(this)).reject(function(transform) {
			return ((transform.originalValue == transform.targetValue) || (transform.unit != 'color' && (isNaN(transform.originalValue) || isNaN(transform.targetValue))))
		});
	},
	update : function(position) {
		var style = {}, transform, i = this.transforms.length;
		while (i--)
			style[(transform = this.transforms[i]).style] = transform.unit == 'color'
					? '#'
							+ (Math
									.round(transform.originalValue[0]
											+ (transform.targetValue[0] - transform.originalValue[0])
											* position)).toColorPart()
							+ (Math
									.round(transform.originalValue[1]
											+ (transform.targetValue[1] - transform.originalValue[1])
											* position)).toColorPart()
							+ (Math
									.round(transform.originalValue[2]
											+ (transform.targetValue[2] - transform.originalValue[2])
											* position)).toColorPart()
					: (transform.originalValue + (transform.targetValue - transform.originalValue)
							* position).toFixed(3)
							+ (transform.unit === null ? '' : transform.unit);
		this.element.setStyle(style, true);
	}
});

Effect.Transform = Class.create({
	initialize : function(tracks) {
		this.tracks = [];
		this.options = arguments[1] || {};
		this.addTracks(tracks);
	},
	addTracks : function(tracks) {
		tracks.each(function(track) {
					track = $H(track);
					var data = track.values().first();
					this.tracks.push($H({
								ids : track.keys().first(),
								effect : Effect.Morph,
								options : {
									style : data
								}
							}));
				}.bind(this));
		return this;
	},
	play : function() {
		return new Effect.Parallel(this.tracks.map(function(track) {
			var ids = track.get('ids'), effect = track.get('effect'), options = track
					.get('options');
			var elements = [$(ids) || $$(ids)].flatten();
			return elements.map(function(e) {
						return new effect(e, Object.extend({
											sync : true
										}, options))
					});
		}).flatten(), this.options);
	}
});

Element.CSS_PROPERTIES = $w('backgroundColor backgroundPosition borderBottomColor borderBottomStyle '
				+ 'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth '
				+ 'borderRightColor borderRightStyle borderRightWidth borderSpacing '
				+ 'borderTopColor borderTopStyle borderTopWidth bottom clip color '
				+ 'fontSize fontWeight height left letterSpacing lineHeight '
				+ 'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '
				+ 'maxWidth minHeight minWidth opacity outlineColor outlineOffset '
				+ 'outlineWidth paddingBottom paddingLeft paddingRight paddingTop '
				+ 'right textIndent top width wordSpacing zIndex');

Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function() {
	var style, styleRules = $H();
	if (Prototype.Browser.WebKit)
		style = new Element('div', {
					style : this
				}).style;
	else {
		String.__parseStyleElement.innerHTML = '<div style="' + this
				+ '"></div>';
		style = String.__parseStyleElement.childNodes[0].style;
	}

	Element.CSS_PROPERTIES.each(function(property) {
				if (style[property])
					styleRules.set(property, style[property]);
			});

	if (Prototype.Browser.IE && this.include('opacity'))
		styleRules.set('opacity',
				this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);

	return styleRules;
};

if (document.defaultView && document.defaultView.getComputedStyle) {
	Element.getStyles = function(element) {
		var css = document.defaultView.getComputedStyle($(element), null);
		return Element.CSS_PROPERTIES.inject({}, function(styles, property) {
					styles[property] = css[property];
					return styles;
				});
	};
} else {
	Element.getStyles = function(element) {
		element = $(element);
		var css = element.currentStyle, styles;
		styles = Element.CSS_PROPERTIES.inject({}, function(results, property) {
					results[property] = css[property];
					return results;
				});
		if (!styles.opacity)
			styles.opacity = element.getOpacity();
		return styles;
	};
};

Effect.Methods = {
	morph : function(element, style) {
		element = $(element);
		new Effect.Morph(element, Object.extend({
							style : style
						}, arguments[2] || {}));
		return element;
	},
	visualEffect : function(element, effect, options) {
		element = $(element)
		var s = effect.dasherize().camelize(), klass = s.charAt(0)
				.toUpperCase()
				+ s.substring(1);
		new Effect[klass](element, options);
		return element;
	},
	highlight : function(element, options) {
		element = $(element);
		new Effect.Highlight(element, options);
		return element;
	}
};

$w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '
		+ 'pulsate shake puff squish switchOff dropOut').each(function(effect) {
	Effect.Methods[effect] = function(element, options) {
		element = $(element);
		Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element,
				options);
		return element;
	}
});

$w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles')
		.each(function(f) {
					Effect.Methods[f] = Element[f];
				});

Element.addMethods(Effect.Methods);


text:
ReactBoard
==========

[![SensioLabsInsight](https://insight.sensiolabs.com/projects/8c654e5d-b84d-4fed-8958-614102f00da8/mini.png)](https://insight.sensiolabs.com/projects/8c654e5d-b84d-4fed-8958-614102f00da8)

![screenshot](http://i.imgur.com/mwlWFUI.png?1)

What is it ?
------------

ReactBoard is an extensible dashboard based on React, Rachet and the Symfony Components. Install it on a server, set up the applications
you wish and plug a screen !

You can interact in real time with it via an http API.

Getting started
---------------

Create a composer.json

```json
{
    "autoload": {
        "psr-0": { "": "src/" }
    },
    "require": {
        "owlycode/reactboard": "~0.1"
    }
}
```

And then execute the following commands

```bash
composer install
cp vendor/owlycode/reactboard/app . -r
mv app/app.php.dist app/app.php
```

Now run the application with ``php app/app.php``

When browsing ``http://localhost:8080/home/landing``, you should see the welcome page.

Playing around
--------------

The following applications are included : hello, prompt, twitter and vlc.

- hello is the one you are seeing by default, it's basically an hello world.
- prompt will display a single message.
- twitter will display a live updated list of tweets from a hashtag.
- vlc will display a player (your browser needs the VLC plugin) streaming from a specified source.

You can switch between applications by issuing calls to the ``http://localhost:8080/home/command`` URL. Give a try to the following
commands and see what happens in your browser :

```bash
curl "http://localhost:8080/home/command?app=prompt&message=Oh%20Hi!"
```

Before running this one, you will need to setup a twitter application and enter its credentials in app/app.php

```bash
curl "http://localhost:8080/home/command?app=twitter&hashtag=symfony"
```

Before running this one, make sure you have vlc installed (tested on linux & windows). Don't forget to ``killall vlc`` when you are done.

```bash
vlc screen:// --screen-fps=20 --live-caching=10 --sout="#transcode{vcodec=mp2v,vb=256,fps=20,scale=Auto,acodec=none}:http{mux=raw,dst=:8081/}" -I dummy &
curl "http://localhost:8080/home/command?app=vlc&streamer=127.0.0.1:8081"
```

Customize the theme
-------------------

Create your own css file in ``app/Resources/css`` and replace the default theme in ``app/app.php`` :

```php
$kernel->link(new ExternalAsset(__DIR__ . '/Resources', 'css/your-theme-file.css'));
```

Create your own application
---------------------------

Create an ``src/MyNamespace/MyAppName`` folder with the following files :

```php
<?php
// src/MyNamespace/MyAppName/MyAppNameApplication.php

namespace MyNamespace\MyAppName;

use OwlyCode\ReactBoard\Application\AbstractApplication;
use OwlyCode\ReactBoard\Application\ApplicationInterface;

class MyAppNameApplication extends AbstractApplication implements ApplicationInterface
{
    /**
     * Called just before the socket server starts.
     */
    public function init()
    {
        $this->watch('my_app_name.request.index', function(){
            return $this->render('index.html.twig', array('status' => 'loaded'));
        });
    }

    public function getName()
    {
        return 'my_app_name';
    }
}
```

```twig
{# src/MyNamespace/MyAppName/views/index.html.twig #}

<h1>My application is {{ status }} ! :-)</h1>
```

Then register your newly created application in ``app/app.php``:

```php
$kernel->register(new MyAppNameApplication());
```

You can now start/restart ReactBoard, open your browser and try : ``curl "http://localhost:8080/home/command?app=my_app_name"``

Going further :
---------------

ReactBoard is still in early development and more documentation will be coming. If you have any question please feel free to open an issue :-)

Meanwhile, to see how to do more advanced stuff, like loading your own assets or access the dependency injection mechanism, take a look at the [builtin applications](https://github.com/OwlyCode/reactboard/tree/master/src/OwlyCode/ReactBoard/Builtin). The Twitter application is the most advanced and covers everything ReactBoard can do : application lifecycle events, live updates, dependency injection use, assets registering and many other things.


text:
<?php

/**
 * Three Advancing White Soldiers
 *
 * @phpstub
 *
 * @param array $open
 * @param array $high
 * @param array $low
 * @param array $close
 *
 * @return array Returns an array with calculated data or false on failure.
 */
function trader_cdl3whitesoldiers($open, $high, $low, $close)
{
}


text:
* Added CHANGELOG
* Update omnibus to latest software and gem 3.0
* Added chef and knife to Gemfile
* Moved version and iteration back into ci_setup script (removed from Jenkins)

## version   = 0.12.1
## iteration = 1

* original omnibus job


text:
// RequestAnimationFrame Polyfill (Android 4.3 and below)
/*! @author Paul Irish */
/*! @source https://gist.github.com/paulirish/1579671 */
(function () {
    var rafLastTime = 0;
    var win = window;
    if (!win.requestAnimationFrame) {
        win.requestAnimationFrame = function (callback) {
            var currTime = Date.now();
            var timeToCall = Math.max(0, 16 - (currTime - rafLastTime));
            var id = window.setTimeout(function () {
                callback(currTime + timeToCall);
            }, timeToCall);
            rafLastTime = currTime + timeToCall;
            return id;
        };
    }
    if (!win.cancelAnimationFrame) {
        win.cancelAnimationFrame = function (id) {
            clearTimeout(id);
        };
    }
})();
// use native raf rather than the zone wrapped one
var originalRaf = window[window['Zone']['__symbol__']('requestAnimationFrame')] || window[window['Zone']['__symbol__']('webkitRequestAnimationFrame')];
// if the originalRaf from the Zone symbol is not available, we need to provide the polyfilled version
export var nativeRaf = originalRaf !== undefined ? originalRaf['bind'](window) : window.requestAnimationFrame.bind(window);
// zone wrapped raf
export var raf = window.requestAnimationFrame.bind(window);
export var cancelRaf = window.cancelAnimationFrame.bind(window);
export var nativeTimeout = window[window['Zone']['__symbol__']('setTimeout')]['bind'](window);
export var clearNativeTimeout = window[window['Zone']['__symbol__']('clearTimeout')]['bind'](window);
export function rafFrames(framesToWait, callback) {
    framesToWait = Math.ceil(framesToWait);
    if (framesToWait < 2) {
        nativeRaf(callback);
    } else {
        nativeTimeout(function () {
            nativeRaf(callback);
        }, (framesToWait - 1) * 16.6667);
    }
}
export var CSS = {};
(function () {
    // transform
    var i;
    var keys = ['webkitTransform', 'transform', '-webkit-transform', 'webkit-transform', '-moz-transform', 'moz-transform', 'MozTransform', 'mozTransform', 'msTransform'];
    for (i = 0; i < keys.length; i++) {
        if (document.documentElement.style[keys[i]] !== undefined) {
            CSS.transform = keys[i];
            break;
        }
    }
    // transition
    keys = ['webkitTransition', 'mozTransition', 'msTransition', 'transition'];
    for (i = 0; i < keys.length; i++) {
        if (document.documentElement.style[keys[i]] !== undefined) {
            CSS.transition = keys[i];
            break;
        }
    }
    // The only prefix we care about is webkit for transitions.
    var isWebkit = CSS.transition.indexOf('webkit') > -1;
    // transition duration
    CSS.transitionDuration = (isWebkit ? '-webkit-' : '') + 'transition-duration';
    // transition timing function
    CSS.transitionTimingFn = (isWebkit ? '-webkit-' : '') + 'transition-timing-function';
    // transition delay
    CSS.transitionDelay = (isWebkit ? '-webkit-' : '') + 'transition-delay';
    // To be sure transitionend works everywhere, include *both* the webkit and non-webkit events
    CSS.transitionEnd = (isWebkit ? 'webkitTransitionEnd ' : '') + 'transitionend';
    // transform origin
    CSS.transformOrigin = (isWebkit ? '-webkit-' : '') + 'transform-origin';
})();
export function transitionEnd(el, callback) {
    if (el) {
        CSS.transitionEnd.split(' ').forEach(function (eventName) {
            el.addEventListener(eventName, onEvent);
        });
        return unregister;
    }
    function unregister() {
        CSS.transitionEnd.split(' ').forEach(function (eventName) {
            el.removeEventListener(eventName, onEvent);
        });
    }
    function onEvent(ev) {
        if (el === ev.target) {
            unregister();
            callback(ev);
        }
    }
}
export function ready(callback) {
    var promise = null;
    if (!callback) {
        // a callback wasn't provided, so let's return a promise instead
        promise = new Promise(function (resolve) {
            callback = resolve;
        });
    }
    if (document.readyState === 'complete' || document.readyState === 'interactive') {
        callback();
    } else {
        document.addEventListener('DOMContentLoaded', completed, false);
        window.addEventListener('load', completed, false);
    }
    return promise;
    function completed() {
        document.removeEventListener('DOMContentLoaded', completed, false);
        window.removeEventListener('load', completed, false);
        callback();
    }
}
export function windowLoad(callback) {
    var promise = null;
    if (!callback) {
        // a callback wasn't provided, so let's return a promise instead
        promise = new Promise(function (resolve) {
            callback = resolve;
        });
    }
    if (document.readyState === 'complete') {
        callback();
    } else {
        window.addEventListener('load', completed, false);
    }
    return promise;
    function completed() {
        window.removeEventListener('load', completed, false);
        callback();
    }
}
export function pointerCoord(ev) {
    // get coordinates for either a mouse click
    // or a touch depending on the given event
    var c = { x: 0, y: 0 };
    if (ev) {
        var touches = ev.touches && ev.touches.length ? ev.touches : [ev];
        var e = ev.changedTouches && ev.changedTouches[0] || touches[0];
        if (e) {
            c.x = e.clientX || e.pageX || 0;
            c.y = e.clientY || e.pageY || 0;
        }
    }
    return c;
}
export function hasPointerMoved(threshold, startCoord, endCoord) {
    return startCoord && endCoord && (Math.abs(startCoord.x - endCoord.x) > threshold || Math.abs(startCoord.y - endCoord.y) > threshold);
}
export function isActive(ele) {
    return !!(ele && document.activeElement === ele);
}
export function hasFocus(ele) {
    return isActive(ele) && ele.parentElement.querySelector(':focus') === ele;
}
export function isTextInput(ele) {
    return !!ele && (ele.tagName === 'TEXTAREA' || ele.contentEditable === 'true' || ele.tagName === 'INPUT' && !/^(radio|checkbox|range|file|submit|reset|color|image|button)$/i.test(ele.type));
}
export function hasFocusedTextInput() {
    var ele = document.activeElement;
    if (isTextInput(ele)) {
        return ele.parentElement.querySelector(':focus') === ele;
    }
    return false;
}
var skipInputAttrsReg = /^(value|checked|disabled|type|class|style|id|autofocus|autocomplete|autocorrect)$/i;
export function copyInputAttributes(srcElement, destElement) {
    // copy attributes from one element to another
    // however, skip over a few of them as they're already
    // handled in the angular world
    var attrs = srcElement.attributes;
    for (var i = 0; i < attrs.length; i++) {
        var attr = attrs[i];
        if (!skipInputAttrsReg.test(attr.name)) {
            destElement.setAttribute(attr.name, attr.value);
        }
    }
}
var matchesFn = void 0;
var matchesMethods = ['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector'];
matchesMethods.some(function (fn) {
    if (typeof document.documentElement[fn] === 'function') {
        matchesFn = fn;
        return true;
    }
});
export function closest(ele, selector, checkSelf) {
    if (ele && matchesFn) {
        // traverse parents
        ele = checkSelf ? ele : ele.parentElement;
        while (ele !== null) {
            if (ele[matchesFn](selector)) {
                return ele;
            }
            ele = ele.parentElement;
        }
    }
    return null;
}
/**
 * Get the element offsetWidth and offsetHeight. Values are cached
 * to reduce DOM reads. Cache is cleared on a window resize.
 */
export function getDimensions(ele, id) {
    var dimensions = dimensionCache[id];
    if (!dimensions) {
        // make sure we got good values before caching
        if (ele.offsetWidth && ele.offsetHeight) {
            dimensions = dimensionCache[id] = {
                width: ele.offsetWidth,
                height: ele.offsetHeight,
                left: ele.offsetLeft,
                top: ele.offsetTop
            };
        } else {
            // do not cache bad values
            return { width: 0, height: 0, left: 0, top: 0 };
        }
    }
    return dimensions;
}
export function clearDimensions(id) {
    delete dimensionCache[id];
}
export function windowDimensions() {
    if (!dimensionCache.win) {
        // make sure we got good values before caching
        if (window.innerWidth && window.innerHeight) {
            dimensionCache.win = {
                width: window.innerWidth,
                height: window.innerHeight
            };
        } else {
            // do not cache bad values
            return { width: 0, height: 0 };
        }
    }
    return dimensionCache.win;
}
export function flushDimensionCache() {
    dimensionCache = {};
}
var dimensionCache = {};


text:
from django.contrib import admin
from . import models

@admin.register(models.Notification)
class NotificationAdmin(admin.ModelAdmin):
    list_display = (
        'creator',
        'to',
        'notification_type',
        'comment',
        'image',
        'created_at',
    )


text:
<?php

namespace LIN3S\AdminBundle\Twig;

use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

/**
 * Twig filter path function.
 *
 * @author Gorka Laucirica <gorka.lauzirka@gmail.com>
 */
class TwigFilterPathFunction extends \Twig_Extension
{
    /**
     * The request stack.
     *
     * @var RequestStack
     */
    private $requestStack;

    /**
     * The URL generator.
     *
     * @var UrlGeneratorInterface
     */
    protected $urlGenerator;

    /**
     * Constructor.
     *
     * @param UrlGeneratorInterface $urlGenerator The URL generator
     * @param RequestStack          $requestStack The request stack
     */
    public function __construct(UrlGeneratorInterface $urlGenerator, RequestStack $requestStack)
    {
        $this->urlGenerator = $urlGenerator;
        $this->requestStack = $requestStack;
    }

    /**
     * {@inheritdoc}
     */
    public function getFunctions()
    {
        return [
            new \Twig_SimpleFunction('filterPath', [$this, 'filterPath']),
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'lin3s_admin_twig_filter_path';
    }

    /**
     * Callback of paginator path Twig function that returns the generated url.
     *
     * @param string $field          The field
     * @param string $currentOrderBy The current order by
     * @param string $currentOrder   The current order, by default "ASC"
     *
     * @return string
     */
    public function filterPath($field, $currentOrderBy, $currentOrder = 'ASC')
    {
        $field = $this->normalizeField($field);

        $request = $this->requestStack->getMasterRequest();
        if ($currentOrderBy === $field) {
            $currentOrder = $currentOrder === 'DESC' ? 'ASC' : 'DESC';
        } else {
            $currentOrder = 'ASC';
        }

        return $this->urlGenerator->generate(
            $request->attributes->get('_route'),
            array_merge($request->query->all(), [
                'entity'  => $request->get('entity'),
                'orderBy' => $field,
                'order'   => $currentOrder,
                'page'    => 1,
            ])
        );
    }

    /**
     * Converts anemic getter functions into property names
     *
     * @param string $field        The field
     *
     * @return string
     */
    private function normalizeField($field)
    {
        $properties = explode('.', $field);

        foreach ($properties as &$property) {
            if (substr($property, 0, strlen('get')) == 'get') {
                $property = substr($property, strlen('get'));
                $property = lcfirst($property);
            }
        }

        return implode('.', $properties);
    }
}


text:
require 'abstract_interface'

class ConferenceBoundary
  include AbstractInterface

  def attend(person, event)
    DatabaseBoundary.api_not_implemented(self)
  end

  def speak_at(person, event)
    DatabaseBoundary.api_not_implemented(self)
  end

  def sponsor(organization, event)
    DatabaseBoundary.api_not_implemented(self)
  end

  def set_schedule(event)
    DatabaseBoundary.api_not_implemented(self)
  end

end


text:
<!DOCTYPE html>

<meta charset="utf-8">

<title>class SurveysController - Rails Application Documentation</title>

<link href="./css/fonts.css" rel="stylesheet">
<link href="./css/rdoc.css" rel="stylesheet">

    Home

    Pages
    Classes
    Methods

  <form action="#" method="get" accept-charset="utf-8">

      <input id="search-field" role="combobox" aria-label="Search"
             aria-autocomplete="list" aria-controls="search-results"
             type="text" name="search" placeholder="Search" spellcheck="false"
             title="Type to search, Up and Down to navigate, Enter to load">

  </form>

Parent

ApplicationController

Methods

#create

#index

#new

#survey_params

    class SurveysController

Public Instance Methods

          create()

          click to toggle source

# File app/controllers/surveys_controller.rb, line 13
def create
  @survey = User.find(session[:current_user_id]).surveys.new(survey_params)
  unless @survey.save
    redirect_to :calendar, flash: { error: 'Survey  was not created' }
    return
  end
  Notification.find_by(event_id: @survey.event_id, user_id: @survey.user_id, notification_type: 'survey').destroy
  redirect_to :calendar, flash: { success: 'Event survey was submitted' }
end

          index()

          click to toggle source

# File app/controllers/surveys_controller.rb, line 5
def index
  @surveys = Survey.where(event_id:  params[:id])
end

          new()

          click to toggle source

# File app/controllers/surveys_controller.rb, line 9
def new
  @survey = Event.find(params[:event_id]).surveys.new
end

          survey_params()

          click to toggle source

# File app/controllers/surveys_controller.rb, line 23
def survey_params
  params.require(:survey).permit(:went_well, :improved, :host_knowledge, :host_presentation, :effect, :extra, :event_id)
end

Validate

Generated by RDoc 4.2.0.

Based on Darkfish by Michael Granger.


text:
"""Presubmit script for changes affecting Source/platform.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into depot_tools.
"""

import difflib
import os
import re
import sys

USE_PYTHON3 = True
RUNTIMEENABLED_NAME = re.compile(r'\s*name\s*:\s*"([^"]*)"')
CHROMEOS_STATUS = "ChromeOS"
LACROS_STATUS = "Lacros"

# The ignore list will be removed once existing features adopt parity across
# Lacros and ChromeOS.
LACROS_CHROMEOS_FEATURE_STATUS_PARITY_IGNORE_LIST = [
    'BarcodeDetector',  # crbug.com/1235855
    'DigitalGoods',  # crbug.com/1235859
    'NetInfoDownlinkMax',  # crbug.com/1235864
    'WebBluetooth',  # crbug.com/1235867
    'WebBluetoothManufacturerDataFilter',  # crbug.com/1235869
    'WebBluetoothRemoteCharacteristicNewWriteValue',  # crbug.com/235870
]

# pyright: reportMissingImports=false
def RuntimeEnabledFeatures(input_api, filename):
    """Returns the features present in the specified features JSON5 file."""

    # We need to wait until we have an input_api object and use this
    # roundabout construct to import json5 because this file is
    # eval-ed and thus doesn't have __file__.
    try:
        json5_path = input_api.os_path.join(input_api.PresubmitLocalPath(),
                                            '..', '..', '..', 'pyjson5', 'src')
        sys.path.append(json5_path)
        import json5
        return json5.load(open(filename, encoding='utf-8'))['data']
    finally:
        # Restore sys.path to what it was before.
        sys.path.remove(json5_path)

def RuntimeEnabledFeatureNames(filename):
    """Reads the 'name' of each feature in runtime_enabled_features.json5."""
    # Note: We don't have a JSON5 parser available, so just use a regex.
    with open(filename) as f:
        for line in f:
            match = RUNTIMEENABLED_NAME.match(line)
            if match:
                yield match.group(1)

def _CheckRuntimeEnabledFeaturesSorted(input_api, output_api):
    """Check: runtime_enabled_features.json5 feature list sorted alphabetically.
    """
    # Read runtime_enabled_features.json5 using the JSON5 parser.
    filename = os.path.join(input_api.PresubmitLocalPath(),
                            'runtime_enabled_features.json5')
    features = list(RuntimeEnabledFeatureNames(filename))

    # Sort the 'data' section by name.
    features_sorted = sorted(features, key=lambda s: s.lower())

    if features == features_sorted:
        return []

    # Diff the sorted/unsorted versions.
    differ = difflib.Differ()
    diff = differ.compare(features, features_sorted)
    return [
        output_api.PresubmitError(
            'runtime_enabled_features.json5 features must be sorted alphabetically. '
            'Diff of feature order follows:',
            long_text='\n'.join(diff))
    ]

def _CheckLacrosChromeOSFeatureStatusParity(input_api, output_api):
    """Check: runtime_enabled_features.json5 feature status parity across Lacros
     and ChromeOS.
    """

    filename = os.path.join(input_api.PresubmitLocalPath(),
                            'runtime_enabled_features.json5')
    try:
        features = RuntimeEnabledFeatures(input_api, filename)
        # Check that all features with a status specified for ChromeOS have the
        # same status specified for Lacros.
        for feature in features:
            if feature[
                    'name'] in LACROS_CHROMEOS_FEATURE_STATUS_PARITY_IGNORE_LIST:
                continue
            if 'status' in feature and type(feature['status']) is dict:
                status_dict = feature['status']
                if (CHROMEOS_STATUS in status_dict
                        or LACROS_STATUS in status_dict) and (
                            status_dict.get(LACROS_STATUS) !=
                            status_dict.get(CHROMEOS_STATUS)):
                    return [output_api.PresubmitError('Feature {} does not have status parity '\
                      'across Lacros and ChromeOS.'.format(feature['name']))]
    except:
        return [
            output_api.PresubmitError(
                'Failed to parse {} for checks'.format(filename))
        ]

    return []

def _CommonChecks(input_api, output_api):
    """Checks common to both upload and commit."""
    results = []
    results.extend(_CheckRuntimeEnabledFeaturesSorted(input_api, output_api))
    results.extend(
        _CheckLacrosChromeOSFeatureStatusParity(input_api, output_api))

    return results

def CheckChangeOnUpload(input_api, output_api):
    return _CommonChecks(input_api, output_api)

def CheckChangeOnCommit(input_api, output_api):
    return _CommonChecks(input_api, output_api)


text:
from typing import Callable

import gdsfactory as gf
from gdsfactory.cell import cell
from gdsfactory.component import Component
from gdsfactory.components.pad import pad_array as pad_array_function
from gdsfactory.components.straight_heater_metal import straight_heater_metal
from gdsfactory.port import select_ports_electrical
from gdsfactory.routing.get_bundle import get_bundle_electrical
from gdsfactory.routing.sort_ports import sort_ports_x
from gdsfactory.types import ComponentSpec, Float2

@cell
def add_electrical_pads_top_dc(
    component: ComponentSpec = straight_heater_metal,
    spacing: Float2 = (0.0, 100.0),
    pad_array: ComponentSpec = pad_array_function,
    select_ports: Callable = select_ports_electrical,
    get_bundle_function: Callable = get_bundle_electrical,
    **kwargs,
) -> Component:
    """Returns new component with electrical ports connected to a pad array at \
    the top.

    Args:
        component: component spec to connect to.
        spacing: component to pad spacing.
        pad_array: component spec for pad_array.
        select_ports: function to select_ports.
        get_bundle_function: function to route bundle of ports.
        kwargs: route settings.

    .. plot::
        :include-source:

        import gdsfactory as gf
        c = gf.components.straight_heater_metal(length=100)
        c = gf.routing.add_electrical_pads_top_dc(c, width=10)
        c.plot()

    """
    c = Component()
    component = gf.get_component(component)

    cref = c << component
    ports = select_ports(cref.ports)
    ports_component = list(ports.values())
    ports_component = [port.copy() for port in ports_component]

    for port in ports_component:
        port.orientation = 90

    pad_array = gf.get_component(pad_array, columns=len(ports))
    pads = c << pad_array
    pads.x = cref.x + spacing[0]
    pads.ymin = cref.ymax + spacing[1]

    ports_pads = list(pads.ports.values())
    ports_component = sort_ports_x(ports_component)
    ports_pads = sort_ports_x(ports_pads)

    routes = get_bundle_function(ports_component, ports_pads, **kwargs)
    for route in routes:
        c.add(route.references)

    c.add_ports(cref.ports)

    # remove electrical ports
    for port in ports_component:
        c.ports.pop(port.name)

    c.add_ports(pads.ports)
    c.copy_child_info(component)
    return c

if __name__ == "__main__":
    c = gf.components.straight_heater_metal(length=100.0)
    c = gf.components.straight(length=100.0)
    cc = add_electrical_pads_top_dc(component=c, width=10)
    cc.show(show_ports=True)


text:
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using InfluxDB.InfluxQL.Client;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Shouldly;
using Xunit;

namespace InfluxDB.InfluxQL.Tests.Client
{
    public class PointJsonConverterTests
    {
        [Theory, MemberData(nameof(TestPoints))]
        public void Can_convert_point(object points)
        {
            var converter = new PointJsonConverter();

            converter.CanConvert(points.GetType()).ShouldBe(true);
        }

        [Theory, MemberData(nameof(TestPoints))]
        public void Serialises_to_json_array_of_arrays(object points)
        {
            var converter = new PointJsonConverter();

            var writer = new JTokenWriter();

            converter.WriteJson(writer, points, JsonSerializer.CreateDefault());

            writer.Token.Type.ShouldBe(JTokenType.Array);
            writer.Token.First.Type.ShouldBe(JTokenType.Array);
        }

        [Theory, MemberData(nameof(TestPoints))]
        public void Can_round_trip(object points)
        {
            var converter = new PointJsonConverter();

            var stringBuilder = new StringBuilder();

            var writer = new JsonTextWriter(new StringWriter(stringBuilder));
            converter.WriteJson(writer, points, JsonSerializer.CreateDefault());

            var reader = new JsonTextReader(new StringReader(stringBuilder.ToString()));
            reader.Read();
            var clone = converter.ReadJson(reader, points.GetType(), null, JsonSerializer.CreateDefault());

            clone.ShouldBe(points);
        }

        [Fact]
        public void Can_deserialsie_mixed_int_and_float_values_to_float()
        {
            var json = "[ [12345, 1.4, 3], [12346, 5, 78.9] ]";

            var reader = new JsonTextReader(new StringReader(json));
            reader.Read();
            var converter = new PointJsonConverter();
            var clone = (IList)converter.ReadJson(reader, typeof(IList<Point<(float, double)>>), null, JsonSerializer.CreateDefault());

            clone.Count.ShouldBe(2);
        }

        public static IEnumerable<object[]> TestPoints()
        {
            List<Point<T>> CreatePoints<T>(params T[] values) => values.Select(x => new Point<T>(DateTime.UtcNow, x)).ToList();

            yield return new object[] { CreatePoints(new { a_double = 34d }) };
            yield return new object[] { CreatePoints(new { a_string = "foo" }) };
            yield return new object[] { CreatePoints(new { a_long = 134L }) };
            yield return new object[] { CreatePoints(new { an_int = 1 }) };
            yield return new object[] { CreatePoints(new { an_bool = true }) };
            yield return new object[] { CreatePoints(new { value = 1 }, new { value = 2 }, new { value = 3 }) };
            yield return new object[] { CreatePoints(new { value = 1d }, new { value = 2.2 }) };
            yield return new object[] { CreatePoints(new { value = (int?)1 }, new { value = (int?)null }) };
            yield return new object[] { CreatePoints((34, "test")) };
        }
    }
}


text:
Data Miner is a set of data mining tools written in PHP. It is designed for easy integration with existing websites.

##Installation

You can install Data Miner very easily with [Composer](https://getcomposer.org/).

Include this in your composer.json file's require section:

```
"require": {
        "thominj/data-miner": "1.*"
    }
```

Then run:

```
composer install
```

Finally, include the composer autoload file in your project:

```php
require_once(PATH_TO_VENDOR_DIR.'/autoload.php');
```

##Histogram

Histograms bin data by counting the number of times a value occurs within a given range. The bin ranges are given by an array where each value corresponds to the left endpoint (inclusive) of the range. The last value is the right end point of the last bin.

For example:

```php
$bins = [ 0, 1, 2, 3];
$data = [ -1, 0, 0.5, 1, 3, 4 ];

$histogram = new thominj\DataMiner\Histogram($bins, $data);
$result = $histogram->getResult();

print_r($result);
```

This will output:

```
Array
(
    [less] => 1
    [0] => 2
    [1] => 1
    [2] => 0
    [3] => 2
)
```
The last bin labeled '3' contains all values greater than or equal to 3.

###Setting Bins and Adding Data

You can set the bins and add data in lots of different ways. Each of these will give the same result:

```php
// Set bins and add data in the constructor
$histogram = new thominj\DataMiner\Histogram($bins, $data);

// Set bins in the constructor, add data later
$histogram = new thominj\DataMiner\Histogram($bins);
$histogram->addData($data);

// Set bins and add data after instancing the histogram
$histogram = new thominj\DataMiner\Histogram();
$histogram->setBins($bins);
$histogram->addData($data);
```

###Online Mode

You can also run in online mode to repeatedly add data sets. Histogram will sort the data as it comes in, accumulating the results and letting you check them whenever you like:

```php
// Online mode
$histogram = new thominj\DataMiner\Histogram($bins);

// Add some data
$histogram->addData($data);

// Get the result
print_r($histogram->getResult());

// Add some more data
$histogram->addData($data);

// Get the new result
print_r($histogram->getResult());
```

This will give:

```
Array
(
    [less] => 1
    [0] => 2
    [1] => 1
    [2] => 0
    [3] => 2
)
Array
(
    [less] => 2
    [0] => 4
    [1] => 2
    [2] => 0
    [3] => 4
)
```

###Save and Resume

You can even save a set of results, then pre-load it before adding more data. This lets you save results in the middle of a long process, re-load them, and pick up where you left off.

```php
$old_result = array(
  'less' => 2,
  0 => 4,
  1 => 2,
  2 => 0,
  3 => 4
);

$histogram = new thominj\DataMiner\Histogram();
$histogram->preload($old_result);
$histogram->addData($data);

print_r($histogram->getResult());
```

This outputs:

```
Array
(
    [less] => 3
    [0] => 6
    [1] => 3
    [2] => 0
    [3] => 6
)
```


text:
class Item
{
	double monthlyProductionCostsPerItem; // everything is per item and per month
	int monthlyProductionPerItem;
	int targetShippingTotal;
	std::string itemName;
	double prototypingCost;
	int monthsToPrototype;
	double shippingCostsPerItem;
	double ManufacturingCostsPerItem;
	int numberOfItemsOnHand;

public:
	Item();
	~Item();

	void setItem();
	void setMonthsToPrototype();
	void setprototypingCost(int availableFunds);
	double getprototypingCost();
	void setCostPerPieceToManufacture();
	void setCostPerPieceToDistribute();
	void setMonthlyDistributionTarget();
	void setMonthlyManufacturingQuota();
	//need getters and setters

};


text:
<?php

namespace Core\Controller;

use Core\Entity\Response;

class DefaultController extends CoreController
{
    /**
     * @return string
     */
    public function indexAction()
    {
        return $this->render('Default/index');
    }

    /**
     * @param string $options
     * @param string $imageSrc
     *
     * @return Response
     * @throws \Exception
     */
    public function uploadAction(string $options, string $imageSrc = null): Response
    {
        $image = $this->imageHandler()->processImage($options, $imageSrc);

        $this->response->generateImageResponse($image);

        return $this->response;
    }

    /**
     * @param string $options
     * @param string $imageSrc
     *
     * @return Response
     * @throws \Exception
     */
    public function pathAction(string $options, string $imageSrc = null): Response
    {
        $image = $this->imageHandler()->processImage($options, $imageSrc);

        $this->response->generatePathResponse($image);

        return $this->response;
    }
}


text:
@implementation ComGoodowRealtimeStoreImplCollaboratorImpl

- (instancetype)initWithComGoodowRealtimeJsonJsonObject:(id<ComGoodowRealtimeJsonJsonObject>)serialized {
  if (self = [super init]) {
    self->userId__ = [((id<ComGoodowRealtimeJsonJsonObject>) nil_chk(serialized)) getStringWithNSString:@"userId"];
    self->sessionId__ = [serialized getStringWithNSString:@"sessionId"];
    self->displayName__ = [serialized getStringWithNSString:@"displayName"];
    self->color__ = [serialized getStringWithNSString:@"color"];
    self->isMe__ = [serialized getBooleanWithNSString:ComGoodowRealtimeStoreChannelConstants_Key_get_IS_ME_()];
    self->isAnonymous__ = [serialized getBooleanWithNSString:@"isAnonymous"];
    self->photoUrl__ = [serialized getStringWithNSString:@"photoUrl"];
  }
  return self;
}

- (instancetype)initWithNSString:(NSString *)userId
                    withNSString:(NSString *)sessionId
                    withNSString:(NSString *)displayName
                    withNSString:(NSString *)color
                     withBoolean:(jboolean)isMe
                     withBoolean:(jboolean)isAnonymous
                    withNSString:(NSString *)photoUrl {
  if (self = [super init]) {
    self->userId__ = userId;
    self->sessionId__ = sessionId;
    self->displayName__ = displayName;
    self->color__ = color;
    self->isMe__ = isMe;
    self->isAnonymous__ = isAnonymous;
    self->photoUrl__ = photoUrl;
  }
  return self;
}

- (jboolean)isEqual:(id)obj {
  if (self == obj) {
    return YES;
  }
  if (obj == nil) {
    return NO;
  }
  if ([self getClass] != [nil_chk(obj) getClass]) {
    return NO;
  }
  id<ComGoodowRealtimeStoreCollaborator> other = (id<ComGoodowRealtimeStoreCollaborator>) check_protocol_cast(obj, @protocol(ComGoodowRealtimeStoreCollaborator));
  if (sessionId__ == nil) {
    if ([other sessionId] != nil) {
      return NO;
    }
  }
  else if (![sessionId__ isEqual:[other sessionId]]) {
    return NO;
  }
  if (userId__ == nil) {
    if ([other userId] != nil) {
      return NO;
    }
  }
  else if (![userId__ isEqual:[other userId]]) {
    return NO;
  }
  return YES;
}

- (NSString *)color {
  return color__;
}

- (NSString *)displayName {
  return displayName__;
}

- (NSString *)photoUrl {
  return photoUrl__;
}

- (NSString *)sessionId {
  return sessionId__;
}

- (NSString *)userId {
  return userId__;
}

- (NSUInteger)hash {
  jint prime = 31;
  jint result = 1;
  result = prime * result + ((sessionId__ == nil) ? 0 : ((jint) [sessionId__ hash]));
  result = prime * result + ((userId__ == nil) ? 0 : ((jint) [userId__ hash]));
  return result;
}

- (jboolean)isAnonymous {
  return isAnonymous__;
}

- (jboolean)isMe {
  return isMe__;
}

- (void)copyAllFieldsTo:(ComGoodowRealtimeStoreImplCollaboratorImpl *)other {
  [super copyAllFieldsTo:other];
  other->color__ = color__;
  other->displayName__ = displayName__;
  other->isAnonymous__ = isAnonymous__;
  other->isMe__ = isMe__;
  other->photoUrl__ = photoUrl__;
  other->sessionId__ = sessionId__;
  other->userId__ = userId__;
}

+ (const J2ObjcClassInfo *)__metadata {
  static const J2ObjcMethodInfo methods[] = {
    { "initWithComGoodowRealtimeJsonJsonObject:", "CollaboratorImpl", NULL, 0x1, NULL },
    { "initWithNSString:withNSString:withNSString:withNSString:withBoolean:withBoolean:withNSString:", "CollaboratorImpl", NULL, 0x1, NULL },
    { "isEqual:", "equals", "Z", 0x1, NULL },
    { "color", NULL, "Ljava.lang.String;", 0x1, NULL },
    { "displayName", NULL, "Ljava.lang.String;", 0x1, NULL },
    { "photoUrl", NULL, "Ljava.lang.String;", 0x1, NULL },
    { "sessionId", NULL, "Ljava.lang.String;", 0x1, NULL },
    { "userId", NULL, "Ljava.lang.String;", 0x1, NULL },
    { "hash", "hashCode", "I", 0x1, NULL },
    { "isAnonymous", NULL, "Z", 0x1, NULL },
    { "isMe", NULL, "Z", 0x1, NULL },
  };
  static const J2ObjcFieldInfo fields[] = {
    { "color__", "color", 0x11, "Ljava.lang.String;", NULL,  },
    { "displayName__", "displayName", 0x11, "Ljava.lang.String;", NULL,  },
    { "isAnonymous__", "isAnonymous", 0x11, "Z", NULL,  },
    { "isMe__", "isMe", 0x11, "Z", NULL,  },
    { "photoUrl__", "photoUrl", 0x11, "Ljava.lang.String;", NULL,  },
    { "sessionId__", "sessionId", 0x11, "Ljava.lang.String;", NULL,  },
    { "userId__", "userId", 0x11, "Ljava.lang.String;", NULL,  },
  };
  static const J2ObjcClassInfo _ComGoodowRealtimeStoreImplCollaboratorImpl = { 1, "CollaboratorImpl", "com.goodow.realtime.store.impl", NULL, 0x1, 11, methods, 7, fields, 0, NULL};
  return &_ComGoodowRealtimeStoreImplCollaboratorImpl;
}

@end

J2OBJC_CLASS_TYPE_LITERAL_SOURCE(ComGoodowRealtimeStoreImplCollaboratorImpl)