text:
(function(){
var m = Math,
	mround = function (r) { return r >> 0; },
	vendor = (/webkit/i).test(navigator.appVersion) ? 'webkit' :
		(/firefox/i).test(navigator.userAgent) ? 'Moz' :
		'opera' in window ? 'O' : '',

    // Browser capabilities
    isAndroid = (/android/gi).test(navigator.appVersion),
    isIDevice = (/iphone|ipad/gi).test(navigator.appVersion),
    isPlaybook = (/playbook/gi).test(navigator.appVersion),
    isTouchPad = (/hp-tablet/gi).test(navigator.appVersion),

    has3d = 'WebKitCSSMatrix' in window && 'm11' in new WebKitCSSMatrix(),
    hasTouch = 'ontouchstart' in window && !isTouchPad,
    hasTransform = vendor + 'Transform' in document.documentElement.style,
    hasTransitionEnd = isIDevice || isPlaybook,

	nextFrame = (function() {
	    return window.requestAnimationFrame
			|| window.webkitRequestAnimationFrame
			|| window.mozRequestAnimationFrame
			|| window.oRequestAnimationFrame
			|| window.msRequestAnimationFrame
			|| function(callback) { return setTimeout(callback, 17); }
	})(),
	cancelFrame = (function () {
	    return window.cancelRequestAnimationFrame
			|| window.webkitCancelAnimationFrame
			|| window.webkitCancelRequestAnimationFrame
			|| window.mozCancelRequestAnimationFrame
			|| window.oCancelRequestAnimationFrame
			|| window.msCancelRequestAnimationFrame
			|| clearTimeout
	})(),

	// Events
	RESIZE_EV = 'onorientationchange' in window ? 'orientationchange' : 'resize',
	START_EV = hasTouch ? 'touchstart' : 'mousedown',
	MOVE_EV = hasTouch ? 'touchmove' : 'mousemove',
	END_EV = hasTouch ? 'touchend' : 'mouseup',
	CANCEL_EV = hasTouch ? 'touchcancel' : 'mouseup',

	// Helpers
	trnOpen = 'translate' + (has3d ? '3d(' : '('),
	trnClose = has3d ? ',0)' : ')',

	// Constructor
	iScroll = function (el, options) {
		var that = this,
			doc = document,
			i;

		console.log(that);

		that.wrapper = typeof el == 'object' ? el : doc.getElementById(el);
		that.wrapper.style.overflow = 'hidden';
		that.scroller = that.wrapper.children[0];

		// Default options
		that.options = {
			hScroll: true,
			vScroll: true,
			x: 0,
			y: 0,
			bounce: true,
			bounceLock: false,
			momentum: true,
			lockDirection: true,
			useTransform: true,
			useTransition: false,

			// Events
			onRefresh: null,
			onBeforeScrollStart: function (e) { e.preventDefault(); },
			onScrollStart: null,
			onBeforeScrollMove: null,
			onScrollMove: null,
			onBeforeScrollEnd: null,
			onScrollEnd: null,
			onTouchEnd: null,
			onDestroy: null
		};

		// User defined options
		for (i in options) that.options[i] = options[i];

		// Set starting position
		that.x = that.options.x;
		that.y = that.options.y;

		// Normalize options
		that.options.useTransform = hasTransform ? that.options.useTransform : false;
		that.options.hScrollbar = that.options.hScroll && that.options.hScrollbar;
		that.options.vScrollbar = that.options.vScroll && that.options.vScrollbar;
		that.options.useTransition = hasTransitionEnd && that.options.useTransition;

		// Set some default styles
		that.scroller.style[vendor + 'TransitionProperty'] = that.options.useTransform ? '-' + vendor.toLowerCase() + '-transform' : 'top left';
		that.scroller.style[vendor + 'TransitionDuration'] = '0';
		that.scroller.style[vendor + 'TransformOrigin'] = '0 0';
		if (that.options.useTransition) that.scroller.style[vendor + 'TransitionTimingFunction'] = 'cubic-bezier(0.33,0.66,0.66,1)';

		if (that.options.useTransform) that.scroller.style[vendor + 'Transform'] = trnOpen + that.x + 'px,' + that.y + 'px' + trnClose;
		else that.scroller.style.cssText += ';position:absolute;top:' + that.y + 'px;left:' + that.x + 'px';

		that.refresh();

		that._bind(RESIZE_EV, window);
		that._bind(START_EV);
		if (!hasTouch) that._bind('mouseout', that.wrapper);
	};

// Prototype
iScroll.prototype = {
	enabled: true,
	x: 0,
	y: 0,
	steps: [],
	scale: 1,

	handleEvent: function (e) {
		var that = this;
		switch(e.type) {
			case START_EV:
				if (!hasTouch && e.button !== 0) return;
				that._start(e);
				break;
			case MOVE_EV: that._move(e); break;
			case END_EV:
			case CANCEL_EV: that._end(e); break;
			case RESIZE_EV: that._resize(); break;
			case 'mouseout': that._mouseout(e); break;
			case 'webkitTransitionEnd': that._transitionEnd(e); break;
		}
	},

	_resize: function () {
		this.refresh();
	},

	_pos: function (x, y) {
		x = this.hScroll ? x : 0;
		y = this.vScroll ? y : 0;

		if (this.options.useTransform) {
			this.scroller.style[vendor + 'Transform'] = trnOpen + x + 'px,' + y + 'px' + trnClose + ' scale(' + this.scale + ')';
		} else {
			x = mround(x);
			y = mround(y);
			this.scroller.style.left = x + 'px';
			this.scroller.style.top = y + 'px';
		}

		this.x = x;
		this.y = y;
	},

	_start: function (e) {
		var that = this,
			point = hasTouch ? e.touches[0] : e,
			matrix, x, y;

		if (!that.enabled) return;

		if (that.options.onBeforeScrollStart) that.options.onBeforeScrollStart.call(that, e);

		if (that.options.useTransition) that._transitionTime(0);

		that.moved = false;
		that.animating = false;
		that.zoomed = false;
		that.distX = 0;
		that.distY = 0;
		that.absDistX = 0;
		that.absDistY = 0;
		that.dirX = 0;
		that.dirY = 0;

		if (that.options.momentum) {
			if (that.options.useTransform) {
				// Very lame general purpose alternative to CSSMatrix
				matrix = getComputedStyle(that.scroller, null)[vendor + 'Transform'].replace(/[^0-9-.,]/g, '').split(',');
				x = matrix[4] * 1;
				y = matrix[5] * 1;
			} else {
				x = getComputedStyle(that.scroller, null).left.replace(/[^0-9-]/g, '') * 1;
				y = getComputedStyle(that.scroller, null).top.replace(/[^0-9-]/g, '') * 1;
			}

			if (x != that.x || y != that.y) {
				if (that.options.useTransition) that._unbind('webkitTransitionEnd');
				else cancelFrame(that.aniTime);
				that.steps = [];
				that._pos(x, y);
			}
		}

		that.startX = that.x;
		that.startY = that.y;
		that.pointX = point.pageX;
		that.pointY = point.pageY;

		that.startTime = e.timeStamp || Date.now();

		if (that.options.onScrollStart) that.options.onScrollStart.call(that, e);

		that._bind(MOVE_EV);
		that._bind(END_EV);
		that._bind(CANCEL_EV);
	},

	_move: function (e) {
		var that = this,
			point = hasTouch ? e.touches[0] : e,
			deltaX = point.pageX - that.pointX,
			deltaY = point.pageY - that.pointY,
			newX = that.x + deltaX,
			newY = that.y + deltaY,
			timestamp = e.timeStamp || Date.now();

		if (that.options.onBeforeScrollMove) that.options.onBeforeScrollMove.call(that, e);

		that.pointX = point.pageX;
		that.pointY = point.pageY;

		// Slow down if outside of the boundaries
		if (newX > 0 || newX < that.maxScrollX) {
			newX = that.options.bounce ? that.x + (deltaX / 2) : newX >= 0 || that.maxScrollX >= 0 ? 0 : that.maxScrollX;
		}
		if (newY > 0 || newY < that.maxScrollY) {
			newY = that.options.bounce ? that.y + (deltaY / 2) : newY >= 0 || that.maxScrollY >= 0 ? 0 : that.maxScrollY;
		}

		that.distX += deltaX;
		that.distY += deltaY;
		that.absDistX = m.abs(that.distX);
		that.absDistY = m.abs(that.distY);

		if (that.absDistX < 6 && that.absDistY < 6) {
			return;
		}

		// Lock direction
		if (that.options.lockDirection) {
			if (that.absDistX > that.absDistY + 5) {
				newY = that.y;
				deltaY = 0;
			} else if (that.absDistY > that.absDistX + 5) {
				newX = that.x;
				deltaX = 0;
			}
		}

		that.moved = true;
		that._pos(newX, newY);
		that.dirX = deltaX > 0 ? -1 : deltaX < 0 ? 1 : 0;
		that.dirY = deltaY > 0 ? -1 : deltaY < 0 ? 1 : 0;

		if (timestamp - that.startTime > 300) {
			that.startTime = timestamp;
			that.startX = that.x;
			that.startY = that.y;
		}

		if (that.options.onScrollMove) that.options.onScrollMove.call(that, e);
	},

	_end: function (e) {
		if (hasTouch && e.touches.length != 0) return;

		var that = this,
			point = hasTouch ? e.changedTouches[0] : e,
			target, ev,
			momentumX = { dist:0, time:0 },
			momentumY = { dist:0, time:0 },
			duration = (e.timeStamp || Date.now()) - that.startTime,
			newPosX = that.x,
			newPosY = that.y,
			newDuration;

		that._unbind(MOVE_EV);
		that._unbind(END_EV);
		that._unbind(CANCEL_EV);

		if (that.options.onBeforeScrollEnd) that.options.onBeforeScrollEnd.call(that, e);

		if (!that.moved) {
			if (hasTouch) {
				// Find the last touched element
				target = point.target;
				while (target.nodeType != 1) target = target.parentNode;

				if (target.tagName != 'SELECT' && target.tagName != 'INPUT' && target.tagName != 'TEXTAREA') {
					ev = document.createEvent('MouseEvents');
					ev.initMouseEvent('click', true, true, e.view, 1,
						point.screenX, point.screenY, point.clientX, point.clientY,
						e.ctrlKey, e.altKey, e.shiftKey, e.metaKey,
						0, null);
					ev._fake = true;
					target.dispatchEvent(ev);
				}
			}

			that._resetPos(200);

			if (that.options.onTouchEnd) that.options.onTouchEnd.call(that, e);
			return;
		}

		if (duration < 300 && that.options.momentum) {
			momentumX = newPosX ? that._momentum(newPosX - that.startX, duration, -that.x, that.scrollerW - that.wrapperW + that.x, that.options.bounce ? that.wrapperW : 0) : momentumX;
			momentumY = newPosY ? that._momentum(newPosY - that.startY, duration, -that.y, (that.maxScrollY < 0 ? that.scrollerH - that.wrapperH + that.y : 0), that.options.bounce ? that.wrapperH : 0) : momentumY;

			newPosX = that.x + momentumX.dist;
			newPosY = that.y + momentumY.dist;

 			if ((that.x > 0 && newPosX > 0) || (that.x < that.maxScrollX && newPosX < that.maxScrollX)) momentumX = { dist:0, time:0 };
 			if ((that.y > 0 && newPosY > 0) || (that.y < that.maxScrollY && newPosY < that.maxScrollY)) momentumY = { dist:0, time:0 };
		}

		if (momentumX.dist || momentumY.dist) {
			newDuration = m.max(m.max(momentumX.time, momentumY.time), 10);

			that.scrollTo(mround(newPosX), mround(newPosY), newDuration);

			if (that.options.onTouchEnd) that.options.onTouchEnd.call(that, e);
			return;
		}

		that._resetPos(200);
		if (that.options.onTouchEnd) that.options.onTouchEnd.call(that, e);
	},

	_resetPos: function (time) {
		var that = this,
			resetX = that.x >= 0 ? 0 : that.x < that.maxScrollX ? that.maxScrollX : that.x,
			resetY = that.y >= 0 || that.maxScrollY > 0 ? 0 : that.y < that.maxScrollY ? that.maxScrollY : that.y;

		if (resetX == that.x && resetY == that.y) {
			if (that.moved) {
				if (that.options.onScrollEnd) that.options.onScrollEnd.call(that);		// Execute custom code on scroll end
				that.moved = false;
			}

			return;
		}

		that.scrollTo(resetX, resetY, time || 0);
	},

	_mouseout: function (e) {
		var t = e.relatedTarget;

		if (!t) {
			this._end(e);
			return;
		}

		while (t = t.parentNode) if (t == this.wrapper) return;

		this._end(e);
	},

	_transitionEnd: function (e) {
		var that = this;

		if (e.target != that.scroller) return;

		that._unbind('webkitTransitionEnd');

		that._startAni();
	},

	/**
	 *
	 * Utilities
	 *
	 */
	_startAni: function () {
		var that = this,
			startX = that.x, startY = that.y,
			startTime = Date.now(),
			step, easeOut,
			animate;

		if (that.animating) return;

		if (!that.steps.length) {
			that._resetPos(400);
			return;
		}

		step = that.steps.shift();

		if (step.x == startX && step.y == startY) step.time = 0;

		that.animating = true;
		that.moved = true;

		if (that.options.useTransition) {
			that._transitionTime(step.time);
			that._pos(step.x, step.y);
			that.animating = false;
			if (step.time) that._bind('webkitTransitionEnd');
			else that._resetPos(0);
			return;
		}

		animate = function () {
			var now = Date.now(),
				newX, newY;

			if (now >= startTime + step.time) {
				that._pos(step.x, step.y);
				that.animating = false;
				if (that.options.onAnimationEnd) that.options.onAnimationEnd.call(that);			// Execute custom code on animation end
				that._startAni();
				return;
			}

			now = (now - startTime) / step.time - 1;
			easeOut = m.sqrt(1 - now * now);
			newX = (step.x - startX) * easeOut + startX;
			newY = (step.y - startY) * easeOut + startY;
			that._pos(newX, newY);
			if (that.animating) that.aniTime = nextFrame(animate);
		};

		animate();
	},

	_transitionTime: function (time) {
		this.scroller.style[vendor + 'TransitionDuration'] = time + 'ms';
	},

	_momentum: function (dist, time, maxDistUpper, maxDistLower, size) {
		var deceleration = 0.0006,
			speed = m.abs(dist) / time,
			newDist = (speed * speed) / (2 * deceleration),
			newTime = 0, outsideDist = 0;

		// Proportinally reduce speed if we are outside of the boundaries
		if (dist > 0 && newDist > maxDistUpper) {
			outsideDist = size / (6 / (newDist / speed * deceleration));
			maxDistUpper = maxDistUpper + outsideDist;
			speed = speed * maxDistUpper / newDist;
			newDist = maxDistUpper;
		} else if (dist < 0 && newDist > maxDistLower) {
			outsideDist = size / (6 / (newDist / speed * deceleration));
			maxDistLower = maxDistLower + outsideDist;
			speed = speed * maxDistLower / newDist;
			newDist = maxDistLower;
		}

		newDist = newDist * (dist < 0 ? -1 : 1);
		newTime = speed / deceleration;

		return { dist: newDist, time: mround(newTime) };
	},

	_offset: function (el) {
		var left = -el.offsetLeft,
			top = -el.offsetTop;

		while (el = el.offsetParent) {
			left -= el.offsetLeft;
			top -= el.offsetTop;
		}

		return { left: left, top: top };
	},

	_bind: function (type, el, bubble) {
		(el || this.scroller).addEventListener(type, this, !!bubble);
	},

	_unbind: function (type, el, bubble) {
		(el || this.scroller).removeEventListener(type, this, !!bubble);
	},

	/**
	 *
	 * Public methods
	 *
	 */
	destroy: function () {
		var that = this;

		that.scroller.style[vendor + 'Transform'] = '';

		// Remove the event listeners
		that._unbind(RESIZE_EV, window);
		that._unbind(START_EV);
		that._unbind(MOVE_EV);
		that._unbind(END_EV);
		that._unbind(CANCEL_EV);
		that._unbind('mouseout', that.wrapper);
		if (that.options.useTransition) that._unbind('webkitTransitionEnd');

		if (that.options.onDestroy) that.options.onDestroy.call(that);
	},

	refresh: function () {
		var that = this,
			offset;

		that.wrapperW = that.wrapper.clientWidth;
		that.wrapperH = that.wrapper.clientHeight;

		that.scrollerW = that.scroller.offsetWidth;
		that.scrollerH = that.scroller.offsetHeight;
		that.maxScrollX = that.wrapperW - that.scrollerW;
		that.maxScrollY = that.wrapperH - that.scrollerH;
		that.dirX = 0;
		that.dirY = 0;

		that.hScroll = that.options.hScroll && that.maxScrollX < 0;
		that.vScroll = that.options.vScroll && (!that.options.bounceLock && !that.hScroll || that.scrollerH > that.wrapperH);

		offset = that._offset(that.wrapper);
		that.wrapperOffsetLeft = -offset.left;
		that.wrapperOffsetTop = -offset.top;

		that.scroller.style[vendor + 'TransitionDuration'] = '0';

		that._resetPos(200);
	},

	scrollTo: function (x, y, time, relative) {
		var that = this,
			step = x,
			i, l;

		that.stop();

		if (!step.length) step = [{ x: x, y: y, time: time, relative: relative }];

		for (i=0, l=step.length; i<l; i++) {
			if (step[i].relative) { step[i].x = that.x - step[i].x; step[i].y = that.y - step[i].y; }
			that.steps.push({ x: step[i].x, y: step[i].y, time: step[i].time || 0 });
		}

		that._startAni();
	},

	scrollToElement: function (el, time) {
		var that = this, pos;
		el = el.nodeType ? el : that.scroller.querySelector(el);
		if (!el) return;

		pos = that._offset(el);
		pos.left += that.wrapperOffsetLeft;
		pos.top += that.wrapperOffsetTop;

		pos.left = pos.left > 0 ? 0 : pos.left < that.maxScrollX ? that.maxScrollX : pos.left;
		pos.top = pos.top > 0 ? 0 : pos.top < that.maxScrollY ? that.maxScrollY : pos.top;
		time = time === undefined ? m.max(m.abs(pos.left)*2, m.abs(pos.top)*2) : time;

		that.scrollTo(pos.left, pos.top, time);
	},

	disable: function () {
		this.stop();
		this._resetPos(0);
		this.enabled = false;

		// If disabled after touchstart we make sure that there are no left over events
		this._unbind(MOVE_EV);
		this._unbind(END_EV);
		this._unbind(CANCEL_EV);
	},

	enable: function () {
		this.enabled = true;
	},

	stop: function () {
		cancelFrame(this.aniTime);
		this.steps = [];
		this.moved = false;
		this.animating = false;
	}
};

if (typeof exports !== 'undefined') exports.iScroll = iScroll;
else window.iScroll = iScroll;

})();


text:
=========
enumerate
=========

Description
===========
Returns an enumerate object.

Syntax
======
**enumerate** *(sequence, start=0)*

*sequence*
	Required. Must be a sequence, an iterator, or some other object which supports iteration.
*start*
	Optional. Index at which enumeration starts.

Return Value
============
#TODO

Time Complexity
============
#TODO

Remarks
=======
The next() method of the iterator returned by enumerate() returns a tuple containing a count (from start which defaults to 0) and the values obtained from iterating over sequence.

Example 1
=========
>>> for i in enumerate((1, 2, 3)):
...     print i
...
(0, 1)
(1, 2)
(2, 3)

Example 2
=========
>>> e = enumerate([1, 2])
>>> e.next()
(0, 1)
>>> e.next()
(1, 2)
>>> e.next()
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
StopIteration

Example 3
=========
>>> e = enumerate([1, 2, 3], 1)
>>> e = enumerate([1, 2, 3], start=1)
>>> e.next()
(1, 1)
>>> e.next()
(2, 2)
>>> e.next()
(3, 3)
>>> e.next()

See Also
========
#TODO

redpajama_set_name: RedPajamaGithub


text:
package com.example.ottowagner.rxedward;

import android.util.Log;

import java.util.List;

import rx.Observable;
import rx.Observer;
import rx.Subscriber;

/**
 * Created by ottowagner on 8/1/14.
 */
public class RxEdwardOperators extends Observable<Double>
{
  /**
   * Creates an Observable with a Function to execute when it is subscribed to.
   *

   * Note: Use {@link #create(rx.Observable.OnSubscribe)} to create an Observable, instead of this constructor,
   * unless you specifically have a need for inheritance.
   *
   * @param f {@link rx.Observable.OnSubscribe} to be executed when {@link #subscribe(rx.Subscriber)} is called
   */
  protected RxEdwardOperators(OnSubscribe<Double> f) {
    super(f);
  }

  public Observable<Double> sma (int frame)
  {
    return lift(new SimpleMovingAverage(frame));
  }
}

//
//public class PlacesResponseToPlaceOperator implements Observable.Operator<double> {
//  @Override
//  public Subscriber<? super PlacesResonse> call(final Subscriber<? super Place> subscriber) {
//    Log.i("PlacesResponseToPlaceOperator", "SUBSCRIBED");
//
//    return new Subscriber<PlacesResonse>(subscriber) {
//      @Override
//      public void onCompleted() {
//        subscriber.onCompleted();
//      }
//
//      @Override
//      public void onError(Throwable e) {
//        subscriber.onError(e);
//      }
//
//      @Override
//      public void onNext(PlacesResonse placesResonse) {
//
//        final List<Place> places = placesResonse.getPlaces();
//        for (int i = 0, il = Math.min(places.size(), MAX_PLACES); i < il; i++) {
//          subscriber.onNext(places.get(i));
//        }
//      }
//    };
//  }
//}
/*
* private static final class PlacesResponseToPlaceOperator implements Observable.Operator<Place, PlacesResonse> {
    @Override
    public Subscriber<? super PlacesResonse> call(final Subscriber<? super Place> subscriber) {
      Log.i("PlacesResponseToPlaceOperator", "SUBSCRIBED");

      return new Subscriber<PlacesResonse>(subscriber) {
        @Override
        public void onCompleted() {
          subscriber.onCompleted();
        }

        @Override
        public void onError(Throwable e) {
          subscriber.onError(e);
        }

        @Override
        public void onNext(PlacesResonse placesResonse) {

          final List<Place> places = placesResonse.getPlaces();
          for (int i = 0, il = Math.min(places.size(), MAX_PLACES); i < il; i++) {
            subscriber.onNext(places.get(i));
          }
        }
      };
    }
  }
*
* */


text:
require 'spec_helper'

describe Forem::FormattingHelper do
  # This formatter uses the simple_format helper, which will um..
  # simply format things. Yes, that'll do.
  describe "as_formatted_html(text)" do
    let(:raw_html) {"
html
"}
    let(:text) {'three blind mice'}
    before { Forem.formatter = nil }

    describe "unsafe html" do
      subject { helper.as_formatted_html(" LOL") }
      it "is escaped" do
        subject.should == "
 LOL
"
      end
      it {should be_html_safe}
    end

    describe "safe html" do
      subject { helper.as_formatted_html(raw_html.html_safe) }
      specify "is not escaped" do
        subject.should == "

html
"
      end
      it {should be_html_safe}
    end
  end

  describe "as_quoted_text" do
    let(:raw_html) {"
html
"}
    describe "default formatter" do
      before { Forem.formatter = nil }

      describe "unsafe html" do
        subject { helper.as_quoted_text(raw_html) }
        it "is escaped" do
          subject.should == "
" + ERB::Util.h(raw_html) + "
\n\n"
        end
        it {should be_html_safe}
      end

      describe "safe html" do
        subject { helper.as_quoted_text(raw_html.html_safe) }
        specify "is not escaped" do
          subject.should == "
" + raw_html + "
\n\n"
        end
        it {should be_html_safe}
      end
    end

    describe "Markdown" do
      let(:markdown) { "**strong text**" }
      before {
        # MRI-specific C-extention tests
        if Forem::Platform.mri?
          Forem.formatter = Forem::Formatters::Redcarpet
        else
          Forem.formatter = Forem::Formatters::Kramdown
        end
      }

      describe "uses
 if no blockquote method" do
        subject { helper.as_quoted_text(markdown) }
        before { Forem.formatter.stub('respond_to?').with(:blockquote).and_return(false) }
        it "wraps the content in blockquotes" do
          subject.should == "
#{markdown}
\n\n"
        end
        it {should be_html_safe}
      end

      describe "uses formatter quoting method if exists" do
        subject { helper.as_quoted_text(raw_html) }
        before do
          Forem.formatter.stub('respond_to?').with(:blockquote).and_return(true)
          Forem.formatter.stub('respond_to?').with(:sanitize).and_return(false)

          Forem.formatter.stub(:blockquote).and_return("> #{markdown}")
        end

        it "quotes the original content" do
          subject.should == "> #{markdown}"
        end
        it {should be_html_safe}
      end

      describe "uses formatter sanitize method if exists" do
        subject { helper.as_formatted_html(markdown) }

        before {
          Forem.formatter.stub('respond_to?').with(:blockquote).and_return(false)
          Forem.formatter.stub('respond_to?').with(:sanitize).and_return(true)

          Forem.formatter.stub(:sanitize).and_return("sanitized it")
        }

        it {subject.should =~ %r{\A
sanitized it
$}}

      end
    end
  end
end


text:
require './test/test_helper'

class PathParameterStrategyTest < ActiveSupport::TestCase
  setup do
    @strategy = VersionCake::PathParameterStrategy.new
  end

  test "a request with an api_version path parameter retrieves the version" do
    request = stub(:path_parameters => {:api_version => '11', :other => 'parameter'})
    assert_equal 11, @strategy.extract(request)
  end

  test "a request without an api_version path parameter returns nil" do
    request = stub(:path_parameters => {:other => 'parameter', :another => 'parameter'})
    assert_nil @strategy.extract(request)
  end
end


text:
`git clone https://github.com/cerebral/cerebral-boilerplate-express.git` (and delete .git folder)

or **ZIP it** :-)

## Requirements
You need **NPM v3** and **NODE v5**.

## Run
1. `npm install`
2. `npm start`

## Build client for production
`npm run build`

Creates a dist folder with the bundle. This bundle can be used with any .html file. Make sure you run it from an actual server, like Node, Nginx etc. You can test with `python -m SimpleHTTPServer 3000` in the folder where you have your .html file and bundle.

## Overview

### React by default
The project runs with React by default and hot replacement of changes to the modules

### CSS Modules
CSS files loaded into components are locally scoped and you can point to class names with javascript. You can also compose classes together, also from other files. These are also hot loaded. Read more about them [here](http://glenmaddern.com/articles/css-modules).

### Hot reloading
Any changes to React components will instantly update in the browser, but changes to other code will require you to do a refresh. Webpack tells you about this in the devtools console of the browser. Soon the boilerplate will automatically to a full refresh when this occurs, just waiting for an update :-)

### Hot reloading on server
You do not need to restart the server when doing changes. Try by removing colors in `server/index.js` and hitting the random color button.


text:
<?php

namespace Magento\Setup\Console\Command;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\App\Utility\Files;
use Magento\Framework\Component\ComponentRegistrar;
use Magento\Framework\Component\ComponentRegistrarInterface;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Module\Dependency\ServiceLocator;

/**
 * Command for showing numbers of dependencies on Magento Framework
 */
class DependenciesShowFrameworkCommand extends AbstractDependenciesCommand
{
    /**
     * @var ComponentRegistrarInterface
     */
    private $registrar;

    /**
     * Constructor
     *
     * @param ComponentRegistrarInterface $registrar
     * @param ObjectManagerProvider $objectManagerProvider
     */
    public function __construct(ComponentRegistrarInterface $registrar, ObjectManagerProvider $objectManagerProvider)
    {
        $this->registrar = $registrar;
        parent::__construct($objectManagerProvider);
    }

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this->setDescription('Shows number of dependencies on Magento framework')
            ->setName('info:dependencies:show-framework');
        parent::configure();
    }

    /**
     * Return default output filename for framework dependencies report
     *
     * @return string
     */
    protected function getDefaultOutputFilename()
    {
        return 'framework-dependencies.csv';
    }

    /**
     * Build Framework dependencies report
     *
     * @param string $outputPath
     * @return void
     */
    protected function buildReport($outputPath)
    {
        $filePaths = $this->registrar->getPaths(ComponentRegistrar::MODULE);

        $filesForParse = Files::init()->getFiles($filePaths, '*');
        $configFiles = Files::init()->getConfigFiles('module.xml', [], false);

        ServiceLocator::getFrameworkDependenciesReportBuilder()->build(
            [
                'parse' => [
                    'files_for_parse' => $filesForParse,
                    'config_files' => $configFiles,
                    'declared_namespaces' => Files::init()->getNamespaces(),
                ],
                'write' => ['report_filename' => $outputPath],
            ]
        );
    }
}


text:
import {NotificationUiManager} from '../../src/service/notification-ui-manager';
import {macroTask} from '../../testing/yield';

describes.realWin('NotificationUiManager', {amp: 1}, () => {
  describe('Notification UI Manager', () => {
    let manager;
    let show1, show2, show3;
    let showSpy1, showSpy2, showSpy3;
    let resolve1, resolve2, resolve3;
    let p1, p2, p3;
    beforeEach(() => {
      manager = new NotificationUiManager();
      showSpy1 = window.sandbox.spy();
      showSpy2 = window.sandbox.spy();
      showSpy3 = window.sandbox.spy();

      p1 = new Promise((resolve) => {
        resolve1 = resolve;
      });
      p2 = new Promise((resolve) => {
        resolve2 = resolve;
      });
      p3 = new Promise((resolve) => {
        resolve3 = resolve;
      });

      show1 = () => {
        showSpy1();
        return p1;
      };

      show2 = () => {
        showSpy2();
        return p2;
      };

      show3 = () => {
        showSpy3();
        return p3;
      };
    });

    it('show UI in sequence', function* () {
      manager.registerUI(show1);
      manager.registerUI(show2);
      manager.registerUI(show3);
      yield macroTask();
      expect(showSpy1).to.be.calledOnce;
      expect(showSpy2).to.not.be.called;
      expect(showSpy3).to.not.be.called;
      resolve1();
      yield macroTask();
      expect(showSpy1).to.be.calledOnce;
      expect(showSpy2).to.be.calledOnce;
      expect(showSpy3).to.not.be.called;
      resolve2();
      yield macroTask();
      expect(showSpy1).to.be.calledOnce;
      expect(showSpy2).to.be.calledOnce;
      expect(showSpy3).to.be.calledOnce;
      resolve3();
      yield macroTask();
      expect(showSpy1).to.be.calledOnce;
      expect(showSpy2).to.be.calledOnce;
      expect(showSpy3).to.be.calledOnce;
    });

    it('queue empty handler', function* () {
      const handler = window.sandbox.spy();
      manager.registerUI(show1);
      manager.registerUI(show2);
      manager.onQueueEmpty(handler);
      expect(handler).to.not.be.called;
      resolve1();
      resolve2();
      yield macroTask();
      expect(handler).to.be.calledOnce;
    });

    it('queue not empty handler', function* () {
      const handler = window.sandbox.spy();
      manager.onQueueNotEmpty(handler);
      manager.registerUI(show1);
      manager.registerUI(show2);
      expect(handler).to.be.calledOnce;
      resolve1();
      resolve2();
      yield macroTask();
      expect(handler).to.be.calledOnce;
      manager.registerUI(show1);
      expect(handler).to.be.calledTwice;
    });
  });
});


text:
from matlablib import *
from foo import *

# 'pip install nb2xls ' - EXCEL reference; https://towardsdatascience.com/jupyter-is-the-new-excel-but-not-for-your-boss-d24340ebf314
import os
import sys

# raise Exception

##
# TODO
# - ALT+4, CTRL+W to close current window
# - CTRL+W is currently expand,
# - CTRL+D jump to definition (Currently CTRL+B)

##
fname='words.xlsx'
cwd= os.getcwd() # current working directory

Fname=os.path.join(cwd, fname)
df = pd.read_excel (Fname, header=None, sheet_name='Sheet1', names=['order', 'word']) #for an earlier version of Excel, you may need to use the file extension of 'xls'
# df.rename(columns={"Entry_Order": "col1", "Word":"verd"}) # Must be a dictionary

# Adjust case - note in-place overwrite
df['word'] = df['word'].str.upper() # Convert all to caps
df['word'] = df['word'].str.capitalize()

df=df.sort_values('word') # Sort in descending order
df.head(5) # print first few lines
df.tail(5)# print last few lines

#df['firstLetter'] = df['word'].astype(str).str[0] # AStype to COERCE to a string
df['firstLetter'] = df['word'].str[0] # Create new column with the first letter from the 'word' column

# *********
"""print('now dropping to embed *********************************************************')
embed(header='type quit() to quit')
print('now resuming from embed')
"""#

# Using counts function that will analyze the occurrene of given letters - will return a Series
df2=df['firstLetter'].value_counts() # Returns a series
df2=df2.sort_index() # sorted list of letters...still a seris
df3=DataFrame(df2) #, columns=['letters'])  # Change our new series into a dataframe to access methods

df3['index_col'] = range(1, len(df3) + 1) #Create index column with enumerated rows - name it 'index_col'
df3['Letters']=df3.index # copy the letters to a unique column
df3.index=df3['index_col'] # set index_column to be the indes

df3 = df3.drop('index_col', 1)  # where 1 is the axis number (0 for rows and 1 for columns.)
df3=df3.rename(columns={'word':'counts'})

# Alias function, ref=https://stackoverflow.com/questions/48217149/python-how-do-i-alias-a-function-with-specific-parameters
# from functools import partial
# keyboard = partial(embed)

##
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=  TRY TO KICK OUT
print('Analysis complete on wordcount')
# b=embed(header='exit() to return')

#%% DONE!
print('here are some new words')

for i, word in enumerate(df['word']):
    my_string=f'{i}, {word}'
    print(my_string)

# keyboard()           # drop to console in this sesstion

#%%

## Figure
# df3.plot(x =df3.index.values, y='counts', kind = 'scatter')
# x=df3.index.values
# y=df3['counts'].values
#
# plt.plot(x,y)
# plt.xticks( df3['Letters'], df3.index.values )
# plt.show()

## DROP TO KEYBOARD, ref: https://stackoverflow.com/questions/2158097/drop-into-python-interpreter-while-executing-function
# ref: https://thepythonguru.com/python-builtin-functions/locals/ (VERY INTERSTING
# https://www.digitalocean.com/community/tutorials/how-to-debug-python-with-an-interactive-console  <--  INTERSTIN

# import code
# print('code.interact started')
# #code.interact(local=locals())
# code.interact(banner='WELCOME, CTRL+Z to return', readfunc=None, local=locals(), exitmsg='..now returning to script')
# print('returned from code.interact!')  # Not sure how to quit the code interact secssion

# NOTE: I had trouble ever returning from this in pycharm. IPython worked perfectly. So use this.

"""this is a set
of comments """

## other notes
# ## Make a dataframe out of a series
#
# ##
#
#
# letter=df['word'].str.get(0)
#
# df['word'].get(33)
# letter # dataframe of all letters
#
# # TODO Insert the letters as a new dataframe column
#
# ##
# print('cell 1')
# df2=df['firstLetter'].value_counts()
#
# ##
# df.word.count()
# wordlist=df.word.values
#
# capitalize(word) for word in wordlist:
#     print(word)
#
# # [x] for word in wordlist
#
# x = [i for i in range(10)] # list comprehension to return a list
#
# ## Generalized capitals
# capitalizedWords=[str.capitalize((word)) for word in wordlist] # This is a list
# capitalizedWords.sort() # in-place modification
#
# # TOTO: would have been cool to do this in place inside the pandas object

if 0:
    import sys, traceback, os

    def pkill(process_name):
        try:
            killed = os.system('tskill ' + process_name)
        except (Exception, e):
            killed = 0
        return killed

# THM 7999


text:
package root.gast.speech.lucene;

import java.io.Reader;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.LowerCaseFilter;
import org.apache.lucene.analysis.TokenFilter;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.WhitespaceTokenizer;
import org.apache.lucene.analysis.en.EnglishMinimalStemFilter;

import android.util.Log;

/**
 * indexers for recognizing speech results
 */
public class RecognitionIndexer extends Analyzer
{
    private static final String TAG = "RecognitionIndexer";

    private boolean phonetic;

    private boolean doStem;

    /**
     * either do stemming or just phonetic, set one to true
     */
    public RecognitionIndexer(boolean phonetic, boolean doStem)
    {
        this.phonetic = phonetic;
        this.doStem = doStem;
    }

    @Override
    public TokenStream tokenStream(String tokens, Reader reader)
    {
        WhitespaceTokenizer w =
                new WhitespaceTokenizer(LuceneParameters.VERSION, reader);
        LowerCaseFilter lower =
                new LowerCaseFilter(LuceneParameters.VERSION, w);
        TokenFilter filter = null;
        EnglishMinimalStemFilter stem = null;
        if (doStem)
        {
            stem = new EnglishMinimalStemFilter(lower);
            filter = stem;
        }

        if (phonetic)
        {
            if (doStem)
            {
                // Note: PhoneticFilter31 is our custom Lucene class that
                // works with Lucene 3.1.0 and uses any of phonetix algorithms
                PhoneticFilter31 phoneticWithStem =
                        new PhoneticFilter31(stem,
                                new com.tangentum.phonetix.Soundex());
                filter = phoneticWithStem;
                Log.d(TAG, "do stem and phonetic!");
            }
            else
            {
                PhoneticFilter31 phonetic =
                        new PhoneticFilter31(w,
                                new com.tangentum.phonetix.Soundex());
                filter = phonetic;
                Log.d(TAG, "do just phonetic");
            }
        }

        return filter;
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<phpunit backupGlobals="false"
     backupStaticAttributes="false"
     bootstrap="vendor/autoload.php"
     colors="true"
     convertErrorsToExceptions="true"
     convertNoticesToExceptions="true"
     convertWarningsToExceptions="true"
     processIsolation="false"
     stopOnFailure="false"
     syntaxCheck="false">

    <testsuites>
        <testsuite name="FCM Test Suite">
            <directory suffix=".php">./tests/</directory>
        </testsuite>
    </testsuites>
    <php>
        <env name="APP_ENV" value="testing"/>
    </php>

    <filter>
        <whitelist addUncoveredFilesFromWhitelist="false">
            <directory suffix=".php">src/</directory>
        </whitelist>
    </filter>
</phpunit>