text
stringlengths 2
6.14k
|
|---|
import globalize from 'globalize';
import configure from '../src/configure';
export default function testLocalizer() {
function getCulture(culture){
return culture ? globalize.findClosestCulture(culture) : globalize.culture()
}
function shortDay(dayOfTheWeek, culture) {
let names = getCulture(culture).calendar.days.namesShort;
return names[dayOfTheWeek.getDay()];
}
var date = {
formats: {
date: 'd',
time: 't',
default: 'f',
header: 'MMMM yyyy',
footer: 'D',
weekday: shortDay,
dayOfMonth: 'dd',
month: 'MMM',
year: 'yyyy',
decade: 'yyyy',
century: 'yyyy',
},
firstOfWeek(culture) {
culture = getCulture(culture)
return (culture && culture.calendar.firstDay) || 0
},
parse(value, format, culture){
return globalize.parseDate(value, format, culture)
},
format(value, format, culture){
return globalize.format(value, format, culture)
}
}
function formatData(format, _culture){
var culture = getCulture(_culture)
, numFormat = culture.numberFormat
if (typeof format === 'string') {
if (format.indexOf('p') !== -1) numFormat = numFormat.percent
if (format.indexOf('c') !== -1) numFormat = numFormat.curency
}
return numFormat
}
var number = {
formats: {
default: 'D'
},
parse(value, culture) {
return globalize.parseFloat(value, 10, culture)
},
format(value, format, culture){
return globalize.format(value, format, culture)
},
decimalChar(format, culture){
var data = formatData(format, culture)
return data['.'] || '.'
},
precision(format, _culture){
var data = formatData(format, _culture)
if (typeof format === 'string' && format.length > 1)
return parseFloat(format.substr(1))
return data ? data.decimals : null
}
}
configure.setLocalizers({ date, number })
}
|
var instance = null;
OptionSelect = function OptionSelect(optionSelectFunction, id, options) {
this.optionSelect = optionSelectFunction;
this.containerId = id;
this.options = options;
instance.instanceData.set(this);
}
OptionSelect.prototype.open = function() {
$(this.containerId).show();
};
Template.optionSelect.onCreated(function() {
this.instanceData = new ReactiveVar({});
instance = this;
});
Template.optionSelect.helpers({
options: function() {
return instance.instanceData.get().options;
}
});
Template.optionSelect.events({
'click .option-select__selection': function() {
var obj = instance.instanceData.get();
obj.optionSelect(this);
$(obj.containerId).hide();
},
'click #option-select-close': function() {
$(instance.instanceData.get().containerId).hide();
}
});
|
// Ember.merge only supports 2 arguments
// Ember.assign isn't available in older Embers
// Ember.$.extend isn't available in Fastboot
import Ember from 'ember';
export default function(...objects) {
let merged = {};
objects.forEach(obj => {
merged = Ember.merge(merged, obj);
});
return merged;
}
|
var fs = require('fs');
var dot = require('dot');
var defaults = require('defaults');
var Block = require('glint-block');
var Style = require('glint-plugin-block-style-editable');
var TextBlock = require('glint-block-text');
var MDBlock = require('glint-block-markdown');
var MetaBlock = require('glint-block-meta');
var CKEditorBlock = require('glint-block-ckeditor');
var Adapter = require('glint-adapter');
var PageAdapter = require('page-adapter');
var Container = require('glint-container');
var Wrap = require('glint-wrap');
var Widget = require('glint-widget');
var LayoutWrap = require('wrap-layout');
var template = fs.readFileSync(__dirname + '/index.dot', 'utf-8');
var compiled = dot.template(template);
function text() {
return Block(TextBlock()).use(Style());
}
function markdown() {
return Block(MDBlock()).use(Style());
}
function editor() {
return Block(CKEditorBlock()).use(Style());
}
exports = module.exports = function wrap(o) {
o = o || {};
var wrap = Wrap();
var blocks = {
'home-title': text().selector('[data-id=home-title]'),
'home-teaser': editor().selector('[data-id=home-teaser]'),
'home-subtitle': markdown().selector('[data-id=home-subtitle]'),
'home-box-1': markdown().selector('[data-id=home-box-1]'),
'home-box-2': markdown().selector('[data-id=home-box-2]'),
'home-box-3': markdown().selector('[data-id=home-box-3]'),
'home-box-4': markdown().selector('[data-id=home-box-4]'),
'home-box-5': markdown().selector('[data-id=home-box-5]'),
'home-box-6': markdown().selector('[data-id=home-box-6]'),
'www-title': text().selector('[data-id=www-title]'),
'www-content': editor().selector('[data-id=www-content]'),
'bb-title': text().selector('[data-id=bb-title]'),
'bb-content': markdown().selector('[data-id=bb-content]'),
'doc-title': text().selector('[data-id=doc-title]'),
'doc-content': markdown().selector('[data-id=doc-content]'),
'img-title': text().selector('[data-id=img-title]'),
'img-content': editor().selector('[data-id=img-content]'),
'contact-title': text().selector('[data-id=contact-title]'),
'contact-content': markdown().selector('[data-id=doc-content]'),
meta: Block(MetaBlock())
};
var adapter = o.adapter || PageAdapter(o);
var db = o.db || 'glint';
var type = o.type || 'main';
var id = o.id || 'main';
var templateData = o.templateData || '__template__';
var homeAdapter = Adapter(adapter)
.db(db)
.type(type)
var container = Container(blocks, homeAdapter)
.id(id)
.template(templateData);
wrap
.parallel(container)
.series('content', Widget(function(options) {
return compiled(options)
}).place('force:server'))
.series(LayoutWrap(o.layout).place('force:server'))
wrap.routes = adapter.routes;
return wrap;
};
|
var Logger = require("./Logger.js");
var Level = require("./Level.js");
var PrintPattern = require("./PrintPattern.js");
module.exports = (function() {
/* STATE VARIABLES */
// OUT configuration
var OUT_INTERVAL = undefined; // 1sec
var OUT_INTERVAL_TIMEOUT = 1000; // 1sec
var OUT_SIZE = 1000;
// logger objects
var loggers = {};
// appender list
var appenders = {};
appenders[Level.trace] = {};
appenders[Level.log] = {};
appenders[Level.info] = {};
appenders[Level.warn] = {};
appenders[Level.error] = {};
// information to log
var records = new Array();
// --------------------------------------------------------------------------
/* METHODS */
// add a logger to the map
// logger_name should be something like group.subgroup.name
var createLogger = function(logger_name) {
if (loggers[logger_name] == undefined) {
loggers[logger_name] = new Logger(logger_name, function(record) {
records.push(record);
writeLog();
});
}
return loggers[logger_name];
}
// create the appender objects
// the appender_config should be something like
// [{
// "name": "appender name",
// "type": "appender implementation",
// "level": "level that appender listens",
// "loggers": ["logger1", "logger2", "group.logger3"],
// Follows the optional attributes
// --------------------------------------------------
// "print_pattern": "[{y}/{M}/{d} {w} {h}:{m}:{s}.{ms}] [{lvl}] [{lg}]
// {out}",
// "config": {...[appender exclusive configuration]}
// }, ...]
var loadAppenderConfig = function(appender_configs) {
realeaseAppenders();
for ( var i in appender_configs) {
// get an appender config
var appender_config = appender_configs[i];
// create appender object
var AppenderType = require("./appender/" + appender_config.type
+ "Appender.js");
var appender_object = new AppenderType(appender_config.name,
new PrintPattern(appender_config.print_pattern),
appender_config.config);
for ( var l in appender_config.loggers) {
var listened_logger = appender_config.loggers[l];
// initialize listened logger appender list
if (appenders[Level[appender_config.level]][listened_logger] == undefined) {
appenders[Level[appender_config.level]][listened_logger] = new Array();
}
appenders[Level[appender_config.level]][listened_logger]
.push(appender_object);
}
}
}
// realease appenders internal resources;
var realeaseAppenders = function() {
for (lv in appenders) {
var level_appender = appenders[lv];
for (lg in level_appender) {
var logger_appender = level_appender[lg];
if (logger_appender.length > 0) {
for (i in logger_appender) {
var appender = logger_appender[i];
appender.release();
}
}
delete level_appender[lg];
}
}
};
// Wrapper that decides when the app will log without hold the process
var writeLog = function() {
if (OUT_INTERVAL == undefined) {
OUT_INTERVAL = setTimeout(writeLogImpl, OUT_INTERVAL_TIMEOUT);
}
};
// real log process
var writeLogImpl = function() {
for (var i = 0; i < OUT_SIZE; i++) {
// getting message record
var record = records[i];
// stop the loop when ther record list is empty;
if (record == undefined) {
break;
}
// the record should be logged on all appender that listen the same
// level or the appenders that listen lower levels
for (var level = record.level; level >= 1; level--) {
// getting appender list by level
var level_appenders = appenders[level];
// try to catch all appenders as possible
var logger_composition = record.logger.split(".");
var logger_name = undefined;
for (var lc = 0; lc < logger_composition.length; lc++) {
// logger name rebuild process
if (logger_name == undefined) {
logger_name = logger_composition[lc];
} else {
logger_name = logger_name + "."
+ logger_composition[lc];
}
// getting appender list by logger
var logger_appenders = level_appenders[logger_name];
// using appender
if (logger_appenders != undefined) {
for (a in logger_appenders) {
var appender = logger_appenders[a];
appender.write(record);
}
}
}
}
}
records.splice(0, OUT_SIZE);
// clean interval identifier
OUT_INTERVAL = undefined;
// if still remain any record, start again the log process
if (records.length > 0) {
writeLog();
}
};
// public interface
return {
"createLogger" : createLogger,
"loadAppenderConfig" : loadAppenderConfig
}
})();
|
/**
* @constructor
*/
var TwoSum = function() {
this.dict = {};
};
/**
* @param {number} input
* @returns {void}
*/
TwoSum.prototype.add = function(input) {
// no need to bigger that 2
this.dict[input] = this.dict[input] ? 2 : 1;
};
/**
* @param {number} val
* @returns {boolean}
*/
TwoSum.prototype.find = function(val) {
var dict = this.dict;
var keys = Object.keys(dict);
for (var i = 0; i < keys.length; i++) {
var key = parseInt(keys[i]);
var target = val - key;
if (!dict[target]) continue;
if ((target === key && dict[target] === 2) ||
target !== key) {
return true;
}
}
return false;
};
var eq = require('assert').equal;
var ts = new TwoSum();
ts.add(0);
ts.find(0)
eq(ts.find(0), false);
ts = new TwoSum();
ts.add(0);
ts.add(0);
ts.find(0)
eq(ts.find(0), true);
ts = new TwoSum();
ts.add(1);
ts.add(3);
ts.add(5);
eq(ts.find(1), false);
eq(ts.find(4), true);
eq(ts.find(7), false);
|
import Element from './Element'
export default class extends Element {
constructor (
val
) {
super({ 'w:type': {} })
if (val) this.setVal(val || null)
}
setVal (value) {
if (value) {
this.src['w:type']['@w:val'] = value
}
else {
delete this.src['w:type']['@w:val']
}
}
getVal () {
return this.src['w:type']['@w:val'] || null
}
}
|
/**
* Module dependencies.
*/
var express = require('express');
var http = require('http');
var path = require('path');
var handlebars = require('express3-handlebars');
var index = require('./routes/index');
var project = require('./routes/project');
var palette = require('./routes/palette');
// Example route
// var user = require('./routes/user');
var app = express();
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.engine('handlebars', handlebars());
app.set('view engine', 'handlebars');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
app.use(express.cookieParser('Intro HCI secret key'));
app.use(express.session());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
// development only
if ('development' == app.get('env')) {
app.use(express.errorHandler());
}
// Add routes here
app.get('/', index.view);
app.get('/project/:id', project.projectInfo);
app.get('/palette', palette.randomPalette);
// Example route
// app.get('/users', user.list);
http.createServer(app).listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
|
System.register(['core-js', './map-change-records', './collection-observation'], function (_export) {
var core, getChangeRecords, ModifyCollectionObserver, _classCallCheck, _inherits, mapProto, ModifyMapObserver;
_export('getMapObserver', getMapObserver);
function getMapObserver(taskQueue, map) {
return ModifyMapObserver.create(taskQueue, map);
}
return {
setters: [function (_coreJs) {
core = _coreJs['default'];
}, function (_mapChangeRecords) {
getChangeRecords = _mapChangeRecords.getChangeRecords;
}, function (_collectionObservation) {
ModifyCollectionObserver = _collectionObservation.ModifyCollectionObserver;
}],
execute: function () {
'use strict';
_classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } };
_inherits = function (subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
mapProto = Map.prototype;
ModifyMapObserver = (function (_ModifyCollectionObserver) {
function ModifyMapObserver(taskQueue, map) {
_classCallCheck(this, ModifyMapObserver);
_ModifyCollectionObserver.call(this, taskQueue, map);
}
_inherits(ModifyMapObserver, _ModifyCollectionObserver);
ModifyMapObserver.create = function create(taskQueue, map) {
var observer = new ModifyMapObserver(taskQueue, map);
map.set = function () {
var oldValue = map.get(arguments[0]);
var type = oldValue ? 'update' : 'add';
var methodCallResult = mapProto.set.apply(map, arguments);
observer.addChangeRecord({
type: type,
object: map,
key: arguments[0],
oldValue: oldValue
});
return methodCallResult;
};
map['delete'] = function () {
var oldValue = map.get(arguments[0]);
var methodCallResult = mapProto['delete'].apply(map, arguments);
observer.addChangeRecord({
type: 'delete',
object: map,
key: arguments[0],
oldValue: oldValue
});
return methodCallResult;
};
map.clear = function () {
var methodCallResult = mapProto.clear.apply(map, arguments);
observer.addChangeRecord({
type: 'clear',
object: map
});
return methodCallResult;
};
return observer;
};
return ModifyMapObserver;
})(ModifyCollectionObserver);
}
};
});
|
var BoardVo = require(_path.src + "/vo/BoardVo.js");
var BoardDao = require(_path.src + "/dao/BoardDao.js");
var RoleDao = require(_path.src + "/dao/RoleDao.js");
module.exports.board = function($, el, param, req, next)
{
var template = this.getTemplate($, el);
BoardDao.getBoard(param.id, function(board)
{
$(el).html(template(board));
next();
});
};
module.exports.boardList = function($, el, param, req, next)
{
var vo = new BoardVo();
if(req.session.user != null)
{
vo.signinUserId = req.session.user.id;
vo.signinUserLevel = req.session.user.level;
}
var template = this.getTemplate($, el);
BoardDao.getBoardList(vo, function(boardList)
{
RoleDao.getRoleList(function(roleList)
{
$(el).html(template({boardList : boardList, roleList : roleList}));
next();
});
});
};
|
/**
* Created by sh on 15/7/6.
*/
"use strict";
var type = require("../type");
exports.parse = function (object, define, addition) {
return type.dataParse(object, {type: Object, contents: String}, addition);
};
|
/**
* @author Iftikhar Ul Hassan
* @date 4/10/17.
*/
const util = require('../util');
module.exports = function (length) {
length = length || 21;
var isValid;
var kidNumber;
do {
kidNumber = util.generateRandomNumber(0, 9, length) + "";
var controlDigit = kidNumber.charAt(kidNumber.length - 1);
isValid = parseInt(controlDigit, 10) === util.mod11(kidNumber) || parseInt(controlDigit, 10) === util.luhnValue(kidNumber);
} while (!isValid);
return kidNumber;
};
|
module.exports = function(grunt) {
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
concat: {
options: {
separator: ';'
},
dist: {
src: ['assets/magnific.js', 'assets/jquery-vimeothumb.js'],
dest: 'magnific_popup/blocks/magnific_popup/magnific/magnific-combined-1.0.0.js'
}
},
uglify: {
options: {
// the banner is inserted at the top of the output
banner: '/*! <%= pkg.name %> <%= grunt.template.today("dd-mm-yyyy") %> */\n'
},
dist: {
files: {
'magnific_popup/blocks/magnific_popup/magnific/magnific-combined-1.0.0.min.js': ['<%= concat.dist.dest %>']
}
}
},
});
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-contrib-concat');
grunt.registerTask('default', ['concat', 'uglify']);
};
|
'use strict';
// ==================================
//
// Load modules.
//
// ==================================
var config = require('../config.js');
var gulp = require('gulp');
// ==================================
//
// Fonts
//
// ==================================
gulp.task('fonts', function () {
gulp.src([config.fonts.src])
.pipe(gulp.dest(config.fonts.dest));
});
|
export default {
name: 'help-view',
data() {
return {
}
},
methods: {
}
}
|
var counter = require('mongodb-counter');
var s3redirect = require('./s3redirect');
module.exports = shortener;
module.exports.redis = require('./redisStore');
module.exports.mongodb = require('./mongoStore');
module.exports.s3 = s3redirect;
module.exports.counter = counter;
function shortener(options) {
var store = options.store || s3redirect(options);
var uniqueIdGenerator = options.uniqueIdGenerator || (options.counters || counter.createCounters(
_({}).assign(options).assign({collectionName: options.countersCollectionName}).value()
))(options.uniqueIdCounterName || 'shortener');
return {
shorten: shorten,
shortenUnique: shortenUnique,
unshorten: unshorten
};
function shorten(longUrl, done) {
getUniqueId(function (err, uniqueId) {
if (err) return done(err);
store.set(uniqueId, longUrl, finish);
function finish(err, path) { return done(null, options.shortUrlPrefix + uniqueId); }
});
}
function shortenUnique(longUrl, done) {
getUniqueId(function (err, uniqueId) {
if (err) return done(err);
store.getOrSet(uniqueId, longUrl, finish);
function finish(err, path) { return done(null, options.shortUrlPrefix + uniqueId); }
});
}
function unshorten(shortUrl, done) { store.get(shortUrl.replace(options.shortUrlPrefix, ''), done); }
function getUniqueId(done) {
if (typeof(uniqueIdGenerator) == 'function') return uniqueIdGenerator(complete);
return uniqueIdGenerator.getUniqueId(complete);
function complete(err, value) {
if (err) return done(err);
var prefix = config.uniqueIdPrefix || '';
if (typeof(value) == 'number') return done(null, prefix + value.toString(36));
return done(null, prefix + value.toString());
}
}
}
|
var todolist = require("./lib");
var assert = require("assert");
describe('findMarks', function() {
it('Find TODOs, NOTES, and FIXMEs', function() {
var result = todolist.findMarks("// TODO: This is a TODO\n// NOTE: This is a Note\n// FIXME: This is a fixme.\n");
assert.deepEqual(result,
[{
content: 'TODO: This is a TODO',
line: 0,
assignee: null,
type: 'TODOs'
},
{
content: 'NOTE: This is a Note',
line: 1,
assignee: null,
type: 'NOTEs'
},
{
content: 'FIXME: This is a fixme.',
line: 2,
assignee: null,
type: 'FIXMEs'
}]);
});
it('Case-insensitive matching', function() {
var result = todolist.findMarks("// todo: This is a TODO\n// note: This is a Note\n// fixme: This is a fixme.\n");
assert.deepEqual(result,
[{
content: 'todo: This is a TODO',
line: 0,
assignee: null,
type: 'TODOs'
},
{
content: 'note: This is a Note',
line: 1,
assignee: null,
type: 'NOTEs'
},
{
content: 'fixme: This is a fixme.',
line: 2,
assignee: null,
type: 'FIXMEs'
}]);
});
it('Parse the assignee of a task', function() {
var result = todolist.findMarks("// TODO(bob): This is a TODO assigned to bob.");
assert.deepEqual(result,
[{
content: 'TODO(bob): This is a TODO assigned to bob.',
line: 0,
assignee: 'bob',
type: 'TODOs'
}]);
});
});
|
import {
ADD_HISTORY_FILTER_EXCLUDE_TAG,
REMOVE_HISTORY_FILTER_EXCLUDE_TAG,
SAVE_HISTORY_FILTER_EXCLUDES_TAGS,
DISMISS_HISTORY_FILTER_EXCLUDES_TAGS,
} from 'app/configs+constants/ActionTypes';
export const saveTags = (tags = []) => ({
type: SAVE_HISTORY_FILTER_EXCLUDES_TAGS,
tags: tags,
});
export const dismissTags = () => ({ type: DISMISS_HISTORY_FILTER_EXCLUDES_TAGS });
export const cancelTags = () => ({ type: DISMISS_HISTORY_FILTER_EXCLUDES_TAGS });;
export const tappedPill = () => ({ type: REMOVE_HISTORY_FILTER_EXCLUDE_TAG });
export const addPill = () => ({ type: ADD_HISTORY_FILTER_EXCLUDE_TAG });
|
var Service = require("./../service.js");
function DistanceService(deviceId, serviceId) {
var distanceService = {}
, _characteristics = {
'distance' : 1
, 'unit' : 2
}
, _requests = {
'read-distance' : function () {
return {
packetType : 'read'
, packetData :[_characteristics['distance']]
}
}
, 'read-unit' : function () {
return {
packetType : 'read'
, packetData :[_characteristics['unit']]
}
}
, 'read-distance-with-unit' : function () {
return {
packetType : 'read'
, packetData :[_characteristics['distance'], _characteristics['unit']]
}
}
, 'set-unit' : function (unit) {
return {
packetType : 'write'
, packetData :[
{id : _characteristics['unit'], data : new Buffer(unit)}
]
}
}
}
, _responses = {};
_responses[_characteristics['distance']] = function (distanceBufer) {
var distance = distanceBufer.readUInt8(0, true);
return {
response : 'distance'
, data : "" + (distance === undefined ? 0 : distance)
};
};
_responses[_characteristics['unit']] = function (unitBuffer) {
return {
response : 'unit'
, data : unitBuffer.toString()
};
};
distanceService.__proto__ = Service(
deviceId
, serviceId
, _requests
, _responses
);
return distanceService;
}
module.exports = DistanceService;
(function(){
var assert = require("assert");
var ResponsePacket = require("../device-packets/response-packet");
var serviceId = 3
, distanceService = DistanceService("my-device-id", serviceId);
(function(){
console.log("Should process read distance json message.");
assert.deepEqual(
distanceService.processRequest(JSON.stringify(
{request: 'read-distance'}
)),
new Buffer([1, 1, 0, 0, 0, serviceId, 1, 1])
);
})();
(function(){
console.log("Should process read unit json message.");
assert.deepEqual(
distanceService.processRequest(JSON.stringify(
{request: 'read-unit'}
)),
new Buffer([1, 1, 0, 0, 0, serviceId, 1, 2])
);
})();
(function(){
console.log("Should process read distance with unit json message.");
assert.deepEqual(
distanceService.processRequest(JSON.stringify(
{request: 'read-distance-with-unit'}
)),
new Buffer([1, 1, 0, 0, 0, serviceId, 2, 1, 2])
);
})();
(function(){
console.log("Should process set unit json message.");
var unit = "cm"
, unitBuffer = new Buffer(unit);
assert.deepEqual(
distanceService.processRequest(JSON.stringify(
{request: 'set-unit', data: unit}
)),
Buffer.concat([
new Buffer([1, 2, 0, 0, 0, serviceId, 1, 2, unitBuffer.length])
, unitBuffer
])
);
})();
(function(){
console.log("Should process distance response packet.");
assert.deepEqual(
distanceService.processResponse(ResponsePacket(new Buffer([
1, 4, 0, 0, 0, serviceId, 1, 1, 1, 23
]))),
[{response: 'distance', data: 23}]
);
})();
(function(){
console.log("Should process unit response packet.");
var unit = "cm"
, unitBuffer = new Buffer(unit);
assert.deepEqual(
distanceService.processResponse(ResponsePacket(Buffer.concat([
new Buffer([1, 4, 0, 0, 0, serviceId, 1, 2, unitBuffer.length])
, unitBuffer
]))),
[{response: 'unit', data: 'cm'}]
);
})();
(function(){
console.log("Should process distance with unit response packet.");
var unit = "cm"
, unitBuffer = new Buffer(unit);
assert.deepEqual(
distanceService.processResponse(ResponsePacket(Buffer.concat([
new Buffer([1, 4, 0, 0, 0, serviceId, 2, 1, 1, 54, 2, unitBuffer.length])
, unitBuffer
]))),
[
{response: 'distance', data: '54'}
, {response: 'unit', data: 'cm'}
]
);
})();
})(this);
|
/**
* @summary Returns deep equality between objects
* {@link https://gist.github.com/egardner/efd34f270cc33db67c0246e837689cb9}
* @param obj1
* @param obj2
* @return {boolean}
* @private
*/
export function deepEqual(obj1, obj2) {
if (obj1 === obj2) {
return true;
}
else if (isObject(obj1) && isObject(obj2)) {
if (Object.keys(obj1).length !== Object.keys(obj2).length) {
return false;
}
for (const prop of Object.keys(obj1)) {
if (!deepEqual(obj1[prop], obj2[prop])) {
return false;
}
}
return true;
}
else {
return false;
}
}
function isObject(obj) {
return typeof obj === 'object' && obj != null;
}
|
define(['jquery','xing'],function($,xing) {
var $body = $('body'),
$progress = $($body.data('progressDisplay')),
$status = $($body.data('statusMessage')),
curPath = window.location.pathname,
baseDir = curPath.substring(0, curPath.lastIndexOf('/')),
sitePath = '//'+window.location.host+baseDir,
stackCount = 0,
stackCall = function() {
if( $progress.length > 0 ) {
$progress.show();
stackCount++;
}
},
unstackCall = function() {
if( --stackCount < 1 ) {
stackCount = 0;
$progress.hide();
}
},
getErrorHandler = function( callback, doUnstack ) {
return function( xhr ) {
if( doUnstack ) {
unstackCall();
}
callback($.parseJSON(xhr.response));
};
}
;
xing.http = {
BasePath : baseDir,
SitePath : sitePath,
redirect : function( path ) {
stackCall(); // show our processing loader when changing pages
window.location.href = path.replace('~',this.BasePath);
},
get : function( path, data, callback, stopLoadingIcon ) {
xing.http.ajax('GET',path,data,callback,stopLoadingIcon);
},
post : function( path, data, callback, stopLoadingIcon ) {
xing.http.ajax('POST',path,data,callback,stopLoadingIcon);
},
put : function( path, data, callback, stopLoadingIcon ) {
xing.http.ajax('PUT',path,data,callback,stopLoadingIcon);
},
ajax : function( type, path, data, callback, stopLoadingIcon ) {
stopLoadingIcon = stopLoadingIcon || false;
$.ajax( {
type : type,
url : path.replace('~',this.BasePath),
data : data,
success : stopLoadingIcon ? callback : function(response) { unstackCall(); callback(response); },
error : getErrorHandler(callback, !stopLoadingIcon)
} );
if( !stopLoadingIcon ) {
stackCall();
}
},
stackCall : stackCall,
unstackCall : unstackCall,
forceEndStack : function() {
stackCount = 0;
unstackCall();
},
message : function( msg, isError, timeoutSecs, callback ) {
if( $status.length ) {
$status.find('.content').html(msg);
$status.toggleClass('error',!!isError).show('fast'); // force isError to boolean with !!
setTimeout( function() {
$status.hide('fast');
if( callback ) { callback(); }
}, typeof timeoutSecs == 'undefined' ? 1400 : (timeoutSecs * 1000));
}
}
};
return xing.http;
});
|
var present = require('present-express');
var Base = require('./base');
module.exports = present.extend(Base, function(data) {
if (data.title) {
this.data.title = data.title;
}
})
|
'use strict';
var isA = require("Espresso/oop").isA;
var oop = require("Espresso/oop").oop;
var init = require("Espresso/oop").init;
var trim = require("Espresso/trim").trim;
var isA = require("Espresso/oop").isA;
var oop = require("Espresso/oop").oop;
var ScalarNode = require("Espresso/Config/Definition/ScalarNode");
var InvalidTypeException = require("Espresso/Config/Definition/Exception/InvalidTypeException");
var format = require("util").format;
function BooleanNode(name,parent){
init(this,ScalarNode,name,parent);
oop(this,"Espresso/Config/Definition/BooleanNode");
}
/**
* {@inheritdoc}
*/
function validateType($value)
{
if ( typeof $value !== 'boolean') {
var $ex = new InvalidTypeException(format(
'Invalid type for path "%s". Expected boolean, but got %s.',
this.getPath(),
getClass($value)
));
var $hint = this.getInfo();
if ($hint) {
$ex.addHint($hint);
}
$ex.setPath(this.getPath());
throw $ex;
}
}
/**
* {@inheritdoc}
*/
function isValueEmpty($value)
{
// a boolean value cannot be empty
return false;
}
BooleanNode.prototype = Object.create( ScalarNode.prototype );
BooleanNode.prototype.validateType = validateType;
BooleanNode.prototype.isValueEmpty = isValueEmpty;
module.exports = BooleanNode;
|
/**
* COMMON WEBPACK CONFIGURATION
*/
const path = require('path');
const webpack = require('webpack');
module.exports = (options) => ({
entry: options.entry,
output: Object.assign({ // Compile into js/build.js
path: path.resolve(process.cwd(), 'build'),
publicPath: '/',
}, options.output), // Merge with env dependent settings
module: {
loaders: [{
test: /\.js$/, // Transform all .js files required somewhere with Babel
loader: 'babel',
exclude: /node_modules/,
query: options.babelQuery,
}, {
// Do not transform vendor's CSS with CSS-modules
// The point is that they remain in global scope.
// Since we require these CSS files in our JS or CSS files,
// they will be a part of our compilation either way.
// So, no need for ExtractTextPlugin here.
test: /\.css$/,
include: /node_modules/,
loaders: ['style-loader', 'css-loader'],
}, {
test: /\.(eot|svg|ttf|woff|woff2)$/,
loader: 'file-loader',
}, {
test: /\.(jpg|png|gif)$/,
loaders: [
'file-loader',
{
loader: 'image-webpack',
query: {
progressive: true,
optimizationLevel: 7,
interlaced: false,
pngquant: {
quality: '65-90',
speed: 4,
},
},
},
],
}, {
test: /\.html$/,
loader: 'html-loader',
}, {
test: /\.json$/,
loader: 'json-loader',
}, {
test: /\.(mp4|webm)$/,
loader: 'url-loader',
query: {
limit: 10000,
},
}],
},
plugins: options.plugins.concat([
new webpack.ProvidePlugin({
// make fetch available
fetch: 'exports?self.fetch!whatwg-fetch',
}),
// Always expose NODE_ENV to webpack, in order to use `process.env.NODE_ENV`
// inside your code for any environment checks; UglifyJS will automatically
// drop any unreachable code.
new webpack.DefinePlugin({
'process.env': {
NODE_ENV: JSON.stringify(process.env.NODE_ENV),
},
}),
new webpack.NamedModulesPlugin(),
]),
resolve: {
modules: ['app', 'node_modules'],
extensions: [
'.js',
'.jsx',
'.react.js',
],
mainFields: [
'browser',
'jsnext:main',
'main',
],
},
devtool: options.devtool,
target: 'web', // Make web variables accessible to webpack, e.g. window
});
|
// All material copyright ESRI, All Rights Reserved, unless otherwise specified.
// See https://js.arcgis.com/4.16/esri/copyright.txt for details.
//>>built
define({widgetLabel:"Altl\u0131k haritay\u0131 a\u00e7/kapa"});
|
"use strict"
const process = require(`process`)
const fs = require(`fs`)
const path = require(`path`)
const js2xmlparser = require(`js2xmlparser`)
const abbrevJson = require(`../abbrevJson`)
const asset = require(`../asset.js`)
const loadMappoMap = require(`../loadMappoMap`)
const mapFilename = process.argv[2]
const mappoMap = loadMappoMap({mapFilename})
console.log(abbrevJson(mappoMap))
const tileset = mappoMap.tileset
const tileWidth = tileset.tileWidth
const tileHeight = tileset.tileHeight
const vspFilename = path.basename(tileset.imageFilename)
const tileColumns = 20
const tileRows = ~~((tileset.tileCount + 19) / 20)
const vspPngWidth = tileWidth * tileColumns
const vspPngHeight = tileHeight * tileRows
const obj = {
'@': {
version: `1.0`,
orientation: `orthogonal`,
width: mappoMap.tileLayers[0].width,
height: mappoMap.tileLayers[0].height,
tilewidth: tileWidth,
tileheight: tileHeight,
},
tileset: {
'@': {
firstgid: 1,
name: vspFilename,
tilewidth: tileWidth,
tileheight: tileHeight,
spacing: 0,
margin: 0,
tilecount: tileset.tileCount,
columns: tileColumns,
},
image: {
'@': {
source: vspFilename,
width: vspPngWidth,
height: vspPngHeight,
}
},
}
}
obj.layer = mappoMap.mapLayerOrder.map(layerIndex => {
const tileLayer = mappoMap.tileLayers[layerIndex]
return {
'@': {
name: tileLayer.description,
width: tileLayer.width,
height: tileLayer.height,
},
data: {
'@': {
encoding: `csv`,
},
'#': tileLayer.tileIndexGrid.map(v => ++v).join(`,`),
}
}
})
const targetFilename = mapFilename + `.tmx`
const xml = js2xmlparser.parse(`map`, obj)
fs.writeFileSync(targetFilename, xml)
console.log(`converted`, mapFilename, `to`, targetFilename)
|
/*
*
* LoginContainer constants
*
*/
export const LOGIN_REQUEST = 'app/LoginContainer/LOGIN_REQUEST';
export const LOGIN_SUCCESS = 'app/LoginContainer/LOGIN_SUCCESS';
export const LOGIN_FAILURE = 'app/LoginContainer/LOGIN_FAILURE';
|
'use strict';
/**
* data-set module
* @module data-set
* @see module:index
*/
const _ = require('lodash');
const try2get = require('try2get');
const Connector = require('../connector/base');
const util = require('../util/index');
function isValidDataSet(dataSet) {
/**
* Simply check the data structure of the data set.
* @function isValidDataSet
* @param {Array} data
* @return {Boolean}
* @example
* // a valid data structure should be like this:
* // `schema` is not strictly required.
* {
* data: [
* {genre: 'Sports', sold: 275},
* {genre: 'Strategy', sold: 115},
* {genre: 'Action', sold: 120},
* {genre: 'Shooter', sold: 350},
* {genre: 'Other', sold: 150}
* ],
* schema: [
* {name: 'genre', comments: '种类'},
* {name: 'sold', comments: '销量', formatter: '', type: 'number'}
* ]
* }
* @example
* isValidDataSet(dataSet);
*/
if (!_.isPlainObject(dataSet)) {
return false;
}
const data = dataSet.data;
if (!_.isArray(data)) {
return false;
}
if (data.length && _.some(data, row => !_.isPlainObject(row))) {
return false;
}
for (let i = 1; i < data.length; i++) {
if (data[i] && !util.containsSameItems(_.keys(data[i]), _.keys(data[i - 1]))) {
return false;
}
}
return true;
}
class DataSet {
constructor(source) {
source = source || [];
const me = this;
if (source.constructor === me.constructor) {
return source;
}
if (_.isArray(source)) {
return new DataSet({
data: source,
});
}
if (!isValidDataSet(source)) {
throw new TypeError('new DataSet(source): invalid data set');
}
me.data = source.data;
me.schema = source.schema || [];
return me.processData();
}
processData() {
const me = this;
const data = me.data;
/*
* schema info of every column:
* [
* {
* name,
* index,
* comments,
* }
* ]
*/
if (!me.schema.length) {
if (data.length) {
const keys = _.keys(data[0]);
me.schema = _.map(keys, (name, index) => ({
index,
name,
}));
}
}
// comments (default is name)
_.each(me.schema, (colInfo) => {
if (!_.has(colInfo, 'comments')) {
colInfo.comments = colInfo.displayName || colInfo.name;
}
});
// 整理schema和data
const currentSchemaNames = _.map(me.schema, item => item.name);
_.each(me.data, (row) => {
_.forIn(row, (value, key) => {
if (!_.includes(currentSchemaNames, key)) {
// 补全schema
me.schema.push({
name: key,
comments: key,
index: currentSchemaNames.length,
});
currentSchemaNames.push(key);
}
});
});
_.each(me.data, (row) => {
_.each(currentSchemaNames, (name) => {
if (!_.has(row, name)) {
// 补全data
row[name] = '';
}
});
});
// flatten rows
me.flattenRows = _.map(me.data, (row) => {
const resultRow = [];
_.each(me.schema, (colInfo, index) => {
colInfo.index = index;
resultRow.push(row[colInfo.name]);
});
return resultRow;
});
// colValuesByName
me.colValuesByName = {};
_.each(me.data, (row) => {
_.forIn(row, (value, key) => {
me.colValuesByName[key] = me.colValuesByName[key] || [];
me.colValuesByName[key].push(value);
});
});
// type (by guessing or pre-defined)
// colNames by type
// col by name
// cols by type
// unique column values rate
me.colNamesByType = {
string: [],
number: [],
};
me.colsByType = {};
me.colByName = {};
_.each(me.schema, (colInfo) => {
const name = colInfo.name;
const colValues = me.colValuesByName[name];
colInfo.values = colValues; // add values
const type = colInfo.type = colInfo.type || util.guessItemsTypes(colValues);
if (!me.colNamesByType[type]) {
me.colNamesByType[type] = [];
}
if (!me.colsByType[type]) {
me.colsByType[type] = [];
}
if (colValues.length) {
colInfo.uniqueRate = _.uniq(colValues).length / colValues.length;
} else {
colInfo.uniqueRate = 0;
}
me.colNamesByType[type].push(colInfo.name);
me.colsByType[type].push(colInfo);
me.colByName[colInfo.name] = colInfo;
});
// alias
me.cols = me.schema;
// rows and cols info
me.rowsCount = data.length;
me.colsCount = me.cols.length;
return me;
}
isEmpty() {
const me = this;
if (me.rowsCount === 0 && me.colsCount === 0) {
return true;
}
return false;
}
}
// connectors
const connectors = [];
_.assign(DataSet, {
registerConnector(connector) {
if (connector instanceof Connector) {
connectors.push(connector);
} else {
try {
connectors.push(new Connector(connector));
} catch (e) {
}
}
connectors.sort((a, b) => (b.priority - a.priority));
},
registerConnectors(cs) {
_.each(cs, (connector) => {
DataSet.registerConnector(connector);
});
},
try2init(source) {
// the default DataSet is an empty DataSet
return try2get.one(_.map(connectors, connector => () => connector.toDataSet(source)));
},
});
require('../connector/csv')(DataSet);
require('../connector/default')(DataSet);
require('../connector/flatten-data')(DataSet);
require('../connector/mock')(DataSet);
module.exports = DataSet;
|
'use strict';
module.exports = function(grunt) {
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
banner: [
'/**',
' * <%= pkg.name %> <%= pkg.version %>',
' * Copyright (C) <%= grunt.template.today("yyyy") %> <%= pkg.author %>',
' * Licensed under the MIT license.',
' * <%= _.pluck(pkg.licenses, "url").join(", ") %>',
' */\n'
].join('\n'),
clean: {
all: [ 'dist', 'tmp' ]
},
jshint: {
all: [ '*.js', 'lib/**/*.js', 'test/**/*.js', 'benchmark/**/*.js', 'tasks/**/*.js' ],
options: {
force: true,
jshintrc: true
}
},
browserify: {
dist: {
src: 'index.js',
dest: 'dist/<%= pkg.name %>-<%= pkg.version %>.js'
},
test: {
src: 'test/unit/**/*.js',
dest: 'tmp/test-browser.js',
options: {
transform: [ 'espowerify' ]
}
},
'benchmark-equip': {
src: 'benchmark/equip-simu.js',
dest: 'tmp/benchmark/equip-simu.js'
},
'benchmark-deco': {
src: 'benchmark/deco-simu.js',
dest: 'tmp/benchmark/deco-simu.js'
},
'benchmark-util': {
src: 'benchmark/util.js',
dest: 'tmp/benchmark/util.js'
}
},
usebanner: {
dist: {
options: {
position: 'top',
banner: '<%= banner %>',
linebreak: false
},
files: {
src: [ '<%= browserify.dist.dest %>' ]
}
}
},
uglify: {
options: {
banner: '<%= banner %>',
report: 'min'
},
js: {
src: '<%= browserify.dist.dest %>',
dest: 'dist/<%= pkg.name %>-<%= pkg.version %>.min.js'
}
},
testdata: {
mh4: {
dest: 'tmp/testdata.js',
urls: {
'equip_head' : 'http://sakusimu.net/data/mh4/equip_head.json',
'equip_body' : 'http://sakusimu.net/data/mh4/equip_body.json',
'equip_arm' : 'http://sakusimu.net/data/mh4/equip_arm.json',
'equip_waist': 'http://sakusimu.net/data/mh4/equip_waist.json',
'equip_leg' : 'http://sakusimu.net/data/mh4/equip_leg.json',
'deco' : 'http://sakusimu.net/data/mh4/deco.json',
'skill': 'http://sakusimu.net/data/mh4/skill.json'
}
}
},
espower: {
test: {
files: [
{ expand: true,
cwd: 'test/unit',
src: [ '**/*.js' ],
dest: 'tmp/espowered/',
ext: '.js' }
]
}
},
mochaTest: {
test: {
options: {
reporter: 'spec'
},
src: [ 'tmp/espowered/**/*.js' ]
}
},
karma: {
test: {
configFile: 'test/karma-conf.js',
singleRun: true,
options: {
files: [
'<%= testdata.mh4.dest %>',
'<%= browserify.test.dest %>'
]
}
}
}
});
require('load-grunt-tasks')(grunt);
grunt.loadTasks('tasks');
grunt.registerTask('default', [ 'clean:all', 'test', 'dist' ]);
grunt.registerTask('dist', [ 'browserify:dist', 'usebanner:dist', 'uglify' ]);
grunt.registerTask('test', function (type, file) {
switch (type) {
case 'browser':
grunt.task.run([ 'browserify:test', 'karma:test' ]);
break;
case 'node':
var files = grunt.config.data.mochaTest.test.src;
if (file) {
file = file.replace('test/unit/', 'tmp/espowered/');
files.splice(-1, 1, file);
}
grunt.task.run([ 'jshint', 'espower:test', 'mochaTest:test' ]);
/* falls through */
default:
}
});
grunt.registerTask('benchmark', [
'browserify:benchmark-equip',
'browserify:benchmark-deco',
'browserify:benchmark-util'
]);
};
|
function(){
var db = $$(this).app.db,
term = $(this).val(),
nonce = Math.random();
$$($(this)).nonce = nonce;
db.view("icd9lookup/by_code", {
startkey : term,
endkey : term+"\u9999", //I don't know why only \u9999 works, not \uFFFF
limit : 100,
success : function(names){
if($$($(this)).nonce = nonce){
$("#results").html(
"<tr><th>ICD-9 Code</th><th>Long Description</th><th>Short Description</th></tr>"+
names.rows.map(function(r){
return '<tr><td>'+r.value.icd9code+'</td><td>'+r.value.long_description+'</td><td>'+r.value.short_description+'</td></tr>';
}).join(""));
}}});
}
|
import cx from 'classnames'
import _ from 'lodash'
import React, { PropTypes } from 'react'
import {
createShorthandFactory,
customPropTypes,
getElementType,
getUnhandledProps,
META,
} from '../../lib'
/**
* A message can contain a header.
*/
function MessageHeader(props) {
const { children, className, content } = props
const classes = cx('header', className)
const rest = getUnhandledProps(MessageHeader, props)
const ElementType = getElementType(MessageHeader, props)
return (
<ElementType {...rest} className={classes}>
{_.isNil(children) ? content : children}
</ElementType>
)
}
MessageHeader._meta = {
name: 'MessageHeader',
parent: 'Message',
type: META.TYPES.COLLECTION,
}
MessageHeader.propTypes = {
/** An element type to render as (string or function). */
as: customPropTypes.as,
/** Primary content. */
children: PropTypes.node,
/** Additional classes. */
className: PropTypes.string,
/** Shorthand for primary content. */
content: customPropTypes.itemShorthand,
}
MessageHeader.create = createShorthandFactory(MessageHeader, val => ({ content: val }))
export default MessageHeader
|
export default {
userData: {},
isAuthenticated: false,
registrationMode: false,
registrationFailed: false,
attemptFailed: false,
reviewData: []
}
|
import Ember from 'ember';
const $ = Ember.$;
import layout from './template';
import styles from './styles';
/*
* Turn header transparent after scrolling
* down a few pixels:
*/
const HEADER_OFFSET = 60;
export default Ember.Component.extend({
layout,
styles,
tagName: 'nav',
localClassNames: 'nav',
localClassNameBindings: [
'isSmall',
'invert',
'showComponents',
],
isSmall: false,
componentsTitle: "More components",
showComponents: false,
invertLogoColors: Ember.computed('isSmall', 'invert', function() {
return !this.get('isSmall') && !this.get('invert');
}),
githubURL: Ember.computed('config', function() {
return this.get('config.githubURL');
}),
_scrollListener: null,
didInsertElement() {
this._scrollListener = Ember.run.bind(this, this.didScroll);
$(window).on('scroll', this._scrollListener);
},
willDestroyElement() {
if (this._scrollListener) {
$(window).off('scroll', this._scrollListener);
}
},
didScroll() {
let scrollPos = $(window).scrollTop();
let reachedOffset = (scrollPos > HEADER_OFFSET);
this.set('isSmall', reachedOffset);
},
/*
* Determine if the user is on a touch device:
*/
hasTouch: Ember.computed(function() {
return (('ontouchstart' in window) || window.DocumentTouch);
}),
actions: {
toggleComponents(value, e) {
if (e && e.stopPropagation) {
e.stopPropagation();
}
if (value !== null && value !== undefined) {
this.set('showComponents', value);
} else {
this.toggleProperty('showComponents');
}
},
},
});
|
'use strict';
// Configuring the Articles module
angular.module('states').run(['Menus',
function(Menus) {
// Set top bar menu items
Menus.addMenuItem('topbar', 'States', 'states', 'dropdown', '/states(/create)?');
Menus.addSubMenuItem('topbar', 'states', 'List States', 'states');
Menus.addSubMenuItem('topbar', 'states', 'New State', 'states/create');
}
]);
|
console.log('----加载开始----');
module.exports = (num) => {
return num + 1;
}
console.log('----加载结束----');
|
const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
function FileBlock() {}
FileBlock.prototype = {
appDir: null,
profileDir: null,
tempDir: null,
// List of domains for the whitelist
whitelist: [],
// Chrome pages that should not be shown
chromeBlacklist: ["browser", "mozapps", "marionette", "specialpowers",
"branding", "alerts"],
initialize: function() {
this.appDir = Services.io.newFileURI(Services.dirsvc.get("CurProcD", Ci.nsIFile)).spec;
var profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile);
this.profileDir = Services.io.newFileURI(profileDir).spec
this.tempDir = Services.io.newFileURI(Services.dirsvc.get("TmpD", Ci.nsIFile)).spec;
try {
var whitelist = Services.prefs.getCharPref("extensions.webconverger.whitelist");
this.whitelist = whitelist.split(",");
for (var i=0; i < this.whitelist.length; i++) {
this.whitelist[i] = this.whitelist[i].trim();
}
} catch(e) {}
var whitelistFile = profileDir.clone();
whitelistFile.append("webconverger.whitelist");
if (!whitelistFile.exists()) {
return;
}
var stream = Cc["@mozilla.org/network/file-input-stream;1"]
.createInstance(Ci.nsIFileInputStream);
stream.init(whitelist, 0x01, 0644, 0);
var lis = stream.QueryInterface(Components.interfaces.nsILineInputStream);
var line = {value:null};
do {
var more = lis.readLine(line);
try {
var file = Cc["@mozilla.org/file/local;1"]
.createInstance(Ci.nsILocalFile);
file.initWithPath(line.value);
this.whitelist.push(ioService.newFileURI(file).spec.toLowerCase());
} catch (ex) {
/* Invalid path */
}
} while (more);
stream.close();
},
shouldLoad: function(aContentType, aContentLocation, aRequestOrigin, aContext, aMimeTypeGuess, aExtra) {
if (!this.appDir) {
this.initialize();
}
// We need to allow access to any files in the profile directory,
// application directory or the temporary directory. Without these,
// Firefox won't start
if (aContentLocation.spec.match(this.profileDir) ||
aContentLocation.spec.match(this.appDir) ||
aContentLocation.spec.match(this.tempDir)) {
return Ci.nsIContentPolicy.ACCEPT;
}
// Allow everything on the whitelist first
if (aContentLocation.scheme == "http" ||
aContentLocation.scheme == "https") {
for (var i=0; i< this.whitelist.length; i++) {
if (aContentLocation.host == this.whitelist[i] ||
aContentLocation.host.substr(aContentLocation.host.length - this.whitelist[i].length - 1) == "." + this.whitelist[i]) {
return Ci.nsIContentPolicy.ACCEPT;
}
}
}
if (aContentLocation.scheme == "chrome") {
// This prevents loading of chrome files into the browser window
if (aRequestOrigin &&
(aRequestOrigin.spec == "chrome://browser/content/browser.xul" ||
aRequestOrigin.scheme == "moz-nullprincipal")) {
for (var i=0; i < this.chromeBlacklist.length; i++) {
if (aContentLocation.host == this.chromeBlacklist[i]) {
return Ci.nsIContentPolicy.REJECT_REQUEST;
}
}
}
// All chrome requests come through here, so we have to allow them
// (Like loading the main browser window for instance)
return Ci.nsIContentPolicy.ACCEPT;
}
// Prevent the loading of resource files into the main browser window
if (aContentLocation.scheme == "resource") {
if (aRequestOrigin && aRequestOrigin.scheme == "moz-nullprincipal") {
return Ci.nsIContentPolicy.REJECT_REQUEST;
}
return Ci.nsIContentPolicy.ACCEPT;
}
// Only allow these three about URLs
if (aContentLocation.scheme == "about") {
if (aContentLocation.spec == "about:" ||
/^about:certerror/.test(aContentLocation.spec) ||
/^about:neterror/.test(aContentLocation.spec) ||
/^about:buildconfig/.test(aContentLocation.spec) ||
/^about:credits/.test(aContentLocation.spec) ||
/^about:license/.test(aContentLocation.spec) ||
// /^about:srcdoc/.test(aContentLocation.spec) || // Needed for Australis
// /^about:customizing/.test(aContentLocation.spec) || // Needed for Australis
/^about:blank/.test(aContentLocation.spec)) {
return Ci.nsIContentPolicy.ACCEPT;
}
return Ci.nsIContentPolicy.REJECT_REQUEST;
}
// We allow all javascript and data URLs
if (aContentLocation.scheme == "data" ||
aContentLocation.scheme == "javascript") {
return Ci.nsIContentPolicy.ACCEPT;
}
// Deny all files
if (aContentLocation.scheme == "file") {
return Ci.nsIContentPolicy.REJECT_REQUEST;
}
// Allow view source
// if (aContentLocation.scheme == "view-source") {
// return Ci.nsIContentPolicy.ACCEPT;
// }
// If we had a whitelist, reject everything else
if (this.whitelist.length > 0) {
if (aContentType == Ci.nsIContentPolicy.TYPE_DOCUMENT) {
// Services.prompt.alert(null, "Webconverger", "Not allowed, whitelist only permits: " + this.whitelist.join(", "));
return Ci.nsIContentPolicy.REJECT_REQUEST;
}
}
// If there is no whitelist, allow everything (because we denied file URLs)
return Ci.nsIContentPolicy.ACCEPT;
},
shouldProcess: function(aContentType, aContentLocation, aRequestOrigin, aContext, aMimeTypeGuess, aExtra) {
return Ci.nsIContentPolicy.ACCEPT;
},
classDescription: "Webconverger FileBlock Service",
contractID: "@webconverger.com/fileblock-service;1",
classID: Components.ID('{607c1749-dc0a-463c-96cf-8ec6c3901319}'),
QueryInterface: XPCOMUtils.generateQI([Ci.nsIContentPolicy])
}
var NSGetFactory = XPCOMUtils.generateNSGetFactory([FileBlock]);
|
var watchers = Object.create(null);
var wait = function (linkid, callback) {
watchers[linkid] = cross("options", "/:care-" + linkid).success(function (res) {
if (watchers[linkid]) wait(linkid, callback);
var a = JSAM.parse(res.responseText);
if (isFunction(callback)) a.forEach(b => callback(b));
}).error(function () {
if (watchers[linkid]) wait(linkid, callback);
});
};
var kill = function (linkid) {
var r = watchers[linkid];
delete watchers[linkid];
if (r) r.abort();
};
var block_size = 1024;
var cast = function (linkid, data) {
data = encode(data);
var inc = 0, size = block_size;
return new Promise(function (ok, oh) {
var run = function () {
if (inc > data.length) return ok();
cross("options", "/:cast-" + linkid + "?" + data.slice(inc, inc + size)).success(run).error(oh);
inc += size;
};
run();
}).then(function () {
if (inc === data.length) {
return cast(linkid, '');
}
});
};
var encode = function (data) {
var str = encodeURIComponent(data.replace(/\-/g, '--')).replace(/%/g, '-');
return str;
};
var decode = function (params) {
params = params.replace(/\-\-|\-/g, a => a === '-' ? '%' : '-');
params = decodeURIComponent(params);
return params;
};
function serve(listener) {
return new Promise(function (ok, oh) {
cross("options", "/:link").success(function (res) {
var responseText = res.responseText;
wait(responseText, listener);
ok(responseText);
}).error(oh);
})
}
function servd(getdata) {
return serve(function (linkid) {
cast(linkid, JSAM.stringify(getdata()));
});
}
function servp(linkto) {
return new Promise(function (ok, oh) {
var blocks = [], _linkid;
serve(function (block) {
blocks.push(block);
if (block.length < block_size) {
var data = decode(blocks.join(''));
ok(JSAM.parse(data));
kill(_linkid);
}
}).then(function (linkid) {
cast(linkto, linkid);
_linkid = linkid;
}, oh);
});
}
serve.servd = servd;
serve.servp = servp;
serve.kill = kill;
|
/**
* This cli.js test file tests the `gnode` wrapper executable via
* `child_process.spawn()`. Generator syntax is *NOT* enabled for these
* test cases.
*/
var path = require('path');
var assert = require('assert');
var semver = require('semver');
var spawn = require('child_process').spawn;
// node executable
var node = process.execPath || process.argv[0];
var gnode = path.resolve(__dirname, '..', 'bin', 'gnode');
// chdir() to the "test" dir, so that relative test filenames work as expected
process.chdir(path.resolve(__dirname, 'cli'));
describe('command line interface', function () {
this.slow(1000);
this.timeout(2000);
cli([ '-v' ], 'should output the version number', function (child, done) {
buffer(child.stdout, function (err, data) {
assert(semver.valid(data.trim()));
done();
});
});
cli([ '--help' ], 'should output the "help" display', function (child, done) {
buffer(child.stdout, function (err, data) {
assert(/^Usage\: (node|iojs)/.test(data));
done();
});
});
cli([ 'check.js' ], 'should quit with a SUCCESS exit code', function (child, done) {
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
done();
});
});
cli([ 'nonexistant.js' ], 'should quit with a FAILURE exit code', function (child, done) {
child.on('exit', function (code) {
assert(code != 0, 'gnode quit with exit code: ' + code);
done();
});
});
cli([ 'argv.js', '1', 'foo' ], 'should have a matching `process.argv`', function (child, done) {
buffer(child.stdout, function (err, data) {
if (err) return done(err);
data = JSON.parse(data);
assert('argv.js' == path.basename(data[1]));
assert('1' == data[2]);
assert('foo' == data[3]);
done();
});
});
cli([ '--harmony_generators', 'check.js' ], 'should not output the "unrecognized flag" warning', function (child, done) {
var async = 2;
buffer(child.stderr, function (err, data) {
if (err) return done(err);
assert(!/unrecognized flag/.test(data), 'got stderr data: ' + JSON.stringify(data));
--async || done();
});
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
--async || done();
});
});
cli([], 'should work properly over stdin', function (child, done) {
child.stdin.end(
'var assert = require("assert");' +
'function *test () {};' +
'var t = test();' +
'assert("function" == typeof t.next);' +
'assert("function" == typeof t.throw);'
);
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
done();
});
});
if (!/^v0.8/.test(process.version)) cli(['-p', 'function *test () {yield 3}; test().next().value;'], 'should print result with -p', function (child, done) {
var async = 2
buffer(child.stdout, function (err, data) {
if (err) return done(err);
assert('3' == data.trim(), 'gnode printed ' + data);
--async || done();
});
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
--async || done();
});
});
cli(['-e', 'function *test () {yield 3}; console.log(test().next().value);'], 'should print result with -e', function (child, done) {
var async = 2
buffer(child.stdout, function (err, data) {
if (err) return done(err);
assert('3' == data.trim(), 'expected 3, got: ' + data);
--async || done();
});
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
--async || done();
});
});
cli(['--harmony_generators', '-e', 'function *test () {yield 3}; console.log(test().next().value);'], 'should print result with -e', function (child, done) {
var async = 2
buffer(child.stdout, function (err, data) {
if (err) return done(err);
assert('3' == data.trim(), 'gnode printed ' + data);
--async || done();
});
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
--async || done();
});
});
cli(['-e', 'console.log(JSON.stringify(process.argv))', 'a', 'b', 'c'], 'should pass additional arguments after -e', function (child, done) {
var async = 2
buffer(child.stdout, function (err, data) {
if (err) return done(err);
data = JSON.parse(data)
assert.deepEqual(['a', 'b', 'c'], data.slice(2))
--async || done();
});
child.on('exit', function (code) {
assert(code == 0, 'gnode quit with exit code: ' + code);
--async || done();
});
});
});
function cli (argv, name, fn) {
describe('gnode ' + argv.join(' '), function () {
it(name, function (done) {
var child = spawn(node, [ gnode ].concat(argv));
fn(child, done);
});
});
}
function buffer (stream, fn) {
var buffers = '';
stream.setEncoding('utf8');
stream.on('data', ondata);
stream.on('end', onend);
stream.on('error', onerror);
function ondata (b) {
buffers += b;
}
function onend () {
stream.removeListener('error', onerror);
fn(null, buffers);
}
function onerror (err) {
fn(err);
}
}
|
var group___s_t_m32_f4xx___h_a_l___driver =
[
[ "CRC", "group___c_r_c.html", "group___c_r_c" ],
[ "GPIOEx", "group___g_p_i_o_ex.html", "group___g_p_i_o_ex" ],
[ "AHB3 Peripheral Clock Enable Disable", "group___r_c_c_ex___a_h_b3___clock___enable___disable.html", null ],
[ "HAL", "group___h_a_l.html", "group___h_a_l" ],
[ "ADC", "group___a_d_c.html", "group___a_d_c" ],
[ "ADCEx", "group___a_d_c_ex.html", "group___a_d_c_ex" ],
[ "CORTEX", "group___c_o_r_t_e_x.html", "group___c_o_r_t_e_x" ],
[ "DMA", "group___d_m_a.html", "group___d_m_a" ],
[ "DMAEx", "group___d_m_a_ex.html", "group___d_m_a_ex" ],
[ "FLASH", "group___f_l_a_s_h.html", "group___f_l_a_s_h" ],
[ "FLASHEx", "group___f_l_a_s_h_ex.html", "group___f_l_a_s_h_ex" ],
[ "GPIO", "group___g_p_i_o.html", "group___g_p_i_o" ],
[ "I2C", "group___i2_c.html", "group___i2_c" ],
[ "I2S", "group___i2_s.html", "group___i2_s" ],
[ "I2SEx", "group___i2_s_ex.html", "group___i2_s_ex" ],
[ "IRDA", "group___i_r_d_a.html", "group___i_r_d_a" ],
[ "IWDG", "group___i_w_d_g.html", "group___i_w_d_g" ],
[ "NAND", "group___n_a_n_d.html", null ],
[ "NOR", "group___n_o_r.html", null ],
[ "PWR", "group___p_w_r.html", "group___p_w_r" ],
[ "PWREx", "group___p_w_r_ex.html", "group___p_w_r_ex" ],
[ "RCC", "group___r_c_c.html", "group___r_c_c" ],
[ "RCCEx", "group___r_c_c_ex.html", "group___r_c_c_ex" ],
[ "RTC", "group___r_t_c.html", "group___r_t_c" ],
[ "RTCEx", "group___r_t_c_ex.html", "group___r_t_c_ex" ],
[ "SAI", "group___s_a_i.html", "group___s_a_i" ],
[ "SAIEx", "group___s_a_i_ex.html", "group___s_a_i_ex" ],
[ "SMARTCARD", "group___s_m_a_r_t_c_a_r_d.html", "group___s_m_a_r_t_c_a_r_d" ],
[ "SPI", "group___s_p_i.html", "group___s_p_i" ],
[ "TIM", "group___t_i_m.html", "group___t_i_m" ],
[ "TIMEx", "group___t_i_m_ex.html", "group___t_i_m_ex" ],
[ "UART", "group___u_a_r_t.html", "group___u_a_r_t" ],
[ "USART", "group___u_s_a_r_t.html", "group___u_s_a_r_t" ],
[ "WWDG", "group___w_w_d_g.html", "group___w_w_d_g" ],
[ "FMC_LL", "group___f_m_c___l_l.html", "group___f_m_c___l_l" ],
[ "FSMC_LL", "group___f_s_m_c___l_l.html", null ]
];
|
import React from 'react'
import { compose } from 'redux'
import { connect } from 'react-redux'
import { Field, FieldArray, reduxForm } from 'redux-form'
import { amount, autocomplete, debitCredit } from './Fields'
import { Button, FontIcon } from 'react-toolbox'
import { getAutocomplete } from 'modules/autocomplete'
import { create } from 'modules/entities/journalEntryCreatedEvents'
import classes from './JournalEntryForm.scss'
import { fetch as fetchLedgers } from 'modules/entities/ledgers'
const validate = (values) => {
const errors = {}
return errors
}
const renderRecords = ({ fields, meta: { touched, error, submitFailed }, ledgers, financialFactId }) => (
<div>
<div>
<Button onClick={() => fields.push({})}> <FontIcon value='add' /></Button>
{(touched || submitFailed) && error && <span>{error}</span>}
</div>
<div className={classes.recordsList}>
{fields.map((record, index) =>
<div key={index}>
<Button
onClick={() => fields.remove(index)}> <FontIcon value='remove' /></Button>
<div className={classes.journalEntryField}>
<Field name={`${record}.ledger`}
component={autocomplete}
label='Ledger'
source={ledgers}
multiple={false}
/>
</div>
<div className={classes.journalEntryField}>
<Field
name={`${record}.debitCredit`}
component={debitCredit}
label='Debit/credit' />
</div>
<div className={classes.journalEntryField}>
<Field
name={`${record}.amount`}
component={amount}
label='Amount' />
</div>
</div>
)}
</div>
</div>
)
const JournalEntryForm = (props) => {
const { ledgers, handleSubmit, submitting, reset } = props
return (
<div className={classes.journalEntryForm}>
<form onSubmit={handleSubmit}>
<FieldArray name='records' component={renderRecords} ledgers={ledgers} />
<Button type='submit' disabled={submitting}>Submit</Button>
<Button type='button' disabled={submitting} onClick={reset}>Clear</Button>
</form>
</div>
)
}
const onSubmit = (values) => {
return create({
values: {
...values
}
})
}
const mapDispatchToProps = {
onSubmit,
fetchLedgers
}
const mapStateToProps = (state) => {
return {
ledgers: getAutocomplete(state, 'ledgers')
}
}
export default compose(
connect(mapStateToProps, mapDispatchToProps),
reduxForm({
form: 'JournalEntryForm',
validate
}))(JournalEntryForm)
|
var _ = require('lodash');
var localConfig = {};
try {
localConfig = require('./config.local');
} catch (e) {
console.log(e.code === 'MODULE_NOT_FOUND');
if (e.code !== 'MODULE_NOT_FOUND' || e.message.indexOf('config.local') < 0) {
//config.local module is broken, rethrow the exception
throw e;
}
}
var path = require('path');
var defaultConfig = {
dataSources: [
{
type: 'local',
base: 'tmp/',
endpoints: ['nodes.json', 'graph.json'],
interval: 3000
}
// {
// type: 'remote',
// base: 'http://example.com/ffmap/',
// endpoints: ['nodes.json', 'graph.json'],
// interval: 30000
// },
],
frontend: {
path: path.join(__dirname, 'public')
},
database: {
host: 'rethinkdb',
port: '28015',
db: 'ffmap'
},
port: 8000
};
module.exports = _.defaults({
defaults: defaultConfig
}, localConfig, defaultConfig);
|
const frisby = require('frisby')
const config = require('config')
const URL = 'http://localhost:3000'
let blueprint
for (const product of config.get('products')) {
if (product.fileForRetrieveBlueprintChallenge) {
blueprint = product.fileForRetrieveBlueprintChallenge
break
}
}
describe('Server', () => {
it('GET responds with index.html when visiting application URL', done => {
frisby.get(URL)
.expect('status', 200)
.expect('header', 'content-type', /text\/html/)
.expect('bodyContains', 'dist/juice-shop.min.js')
.done(done)
})
it('GET responds with index.html when visiting application URL with any path', done => {
frisby.get(URL + '/whatever')
.expect('status', 200)
.expect('header', 'content-type', /text\/html/)
.expect('bodyContains', 'dist/juice-shop.min.js')
.done(done)
})
it('GET a restricted file directly from file system path on server via Directory Traversal attack loads index.html instead', done => {
frisby.get(URL + '/public/images/../../ftp/eastere.gg')
.expect('status', 200)
.expect('bodyContains', '<meta name="description" content="An intentionally insecure JavaScript Web Application">')
.done(done)
})
it('GET a restricted file directly from file system path on server via URL-encoded Directory Traversal attack loads index.html instead', done => {
frisby.get(URL + '/public/images/%2e%2e%2f%2e%2e%2fftp/eastere.gg')
.expect('status', 200)
.expect('bodyContains', '<meta name="description" content="An intentionally insecure JavaScript Web Application">')
.done(done)
})
})
describe('/public/images/tracking', () => {
it('GET tracking image for "Score Board" page access challenge', done => {
frisby.get(URL + '/public/images/tracking/scoreboard.png')
.expect('status', 200)
.expect('header', 'content-type', 'image/png')
.done(done)
})
it('GET tracking image for "Administration" page access challenge', done => {
frisby.get(URL + '/public/images/tracking/administration.png')
.expect('status', 200)
.expect('header', 'content-type', 'image/png')
.done(done)
})
it('GET tracking background image for "Geocities Theme" challenge', done => {
frisby.get(URL + '/public/images/tracking/microfab.gif')
.expect('status', 200)
.expect('header', 'content-type', 'image/gif')
.done(done)
})
})
describe('/encryptionkeys', () => {
it('GET serves a directory listing', done => {
frisby.get(URL + '/encryptionkeys')
.expect('status', 200)
.expect('header', 'content-type', /text\/html/)
.expect('bodyContains', '<title>listing directory /encryptionkeys</title>')
.done(done)
})
it('GET a non-existing file in will return a 404 error', done => {
frisby.get(URL + '/encryptionkeys/doesnotexist.md')
.expect('status', 404)
.done(done)
})
it('GET the Premium Content AES key', done => {
frisby.get(URL + '/encryptionkeys/premium.key')
.expect('status', 200)
.done(done)
})
it('GET a key file whose name contains a "/" fails with a 403 error', done => {
frisby.fetch(URL + '/encryptionkeys/%2fetc%2fos-release%2500.md', {}, { urlEncode: false })
.expect('status', 403)
.expect('bodyContains', 'Error: File names cannot contain forward slashes!')
.done(done)
})
})
describe('Hidden URL', () => {
it('GET the second easter egg by visiting the Base64>ROT13-decrypted URL', done => {
frisby.get(URL + '/the/devs/are/so/funny/they/hid/an/easter/egg/within/the/easter/egg')
.expect('status', 200)
.expect('header', 'content-type', /text\/html/)
.expect('bodyContains', '<title>Welcome to Planet Orangeuze</title>')
.done(done)
})
it('GET the premium content by visiting the ROT5>Base64>z85>ROT5-decrypted URL', done => {
frisby.get(URL + '/this/page/is/hidden/behind/an/incredibly/high/paywall/that/could/only/be/unlocked/by/sending/1btc/to/us')
.expect('status', 200)
.expect('header', 'content-type', 'image/gif')
.done(done)
})
it('GET Geocities theme CSS is accessible directly from file system path', done => {
frisby.get(URL + '/css/geo-bootstrap/swatch/bootstrap.css')
.expect('status', 200)
.expect('bodyContains', 'Designed and built with all the love in the world @twitter by @mdo and @fat.')
.done(done)
})
it('GET Klingon translation file for "Extra Language" challenge', done => {
frisby.get(URL + '/i18n/tlh_AA.json')
.expect('status', 200)
.expect('header', 'content-type', /application\/json/)
.done(done)
})
it('GET blueprint file for "Retrieve Blueprint" challenge', done => {
frisby.get(URL + '/public/images/products/' + blueprint)
.expect('status', 200)
.done(done)
})
})
|
import React from 'react';
import withStyles from 'isomorphic-style-loader/lib/withStyles';
import s from './Navigation.css';
import Link from '../Link';
class Navigation extends React.Component {
render() {
return (
<div className={s.root} role="navigation">
<Link className={s.link} to="/catalog">Каталог продукції</Link>
<Link className={s.link} to="/about">Про нас</Link>
<Link className={s.link} to="/catalog">Наші роботи</Link>
</div>
);
}
}
export default withStyles(s)(Navigation);
|
/* */
'use strict';
Object.defineProperty(exports, "__esModule", {value: true});
var _react = require('react');
var _react2 = _interopRequireDefault(_react);
var _reactAddonsPureRenderMixin = require('react-addons-pure-render-mixin');
var _reactAddonsPureRenderMixin2 = _interopRequireDefault(_reactAddonsPureRenderMixin);
var _svgIcon = require('../../svg-icon');
var _svgIcon2 = _interopRequireDefault(_svgIcon);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {default: obj};
}
var HardwarePhonelinkOff = _react2.default.createClass({
displayName: 'HardwarePhonelinkOff',
mixins: [_reactAddonsPureRenderMixin2.default],
render: function render() {
return _react2.default.createElement(_svgIcon2.default, this.props, _react2.default.createElement('path', {d: 'M22 6V4H6.82l2 2H22zM1.92 1.65L.65 2.92l1.82 1.82C2.18 5.08 2 5.52 2 6v11H0v3h17.73l2.35 2.35 1.27-1.27L3.89 3.62 1.92 1.65zM4 6.27L14.73 17H4V6.27zM23 8h-6c-.55 0-1 .45-1 1v4.18l2 2V10h4v7h-2.18l3 3H23c.55 0 1-.45 1-1V9c0-.55-.45-1-1-1z'}));
}
});
exports.default = HardwarePhonelinkOff;
module.exports = exports['default'];
|
define(function(require, exports) {
'use strict';
var Backbone = require('backbone')
, global = require('global');
var teamColours = [
'#FFBBBB', '#FFE1BA', '#FDFFBA', '#D6FFBA',
'#BAFFCE', '#BAFFFD', '#BAE6FF', '#BAC8FF',
'#D3BAFF', '#EBBAFF', '#E4E0FF', '#BAFCE1',
'#FCC6BB', '#E3F3CE', '#EEEEEE', '#D8FFF4'
];
exports.Problem = Backbone.Model.extend({});
exports.Team = Backbone.Model.extend({
colour: function() {
return teamColours[this.id % teamColours.length];
}
});
exports.Stage = Backbone.Model.extend({
glyphs: {
1: 'remove',
2: 'ok',
3: 'forward'
},
glyph: function() {
return this.glyphs[this.get('state')];
}
});
});
|
'use strict';
// Setting up route
angular.module('socialevents').config(['$stateProvider',
function($stateProvider) {
// SocialEvents state routing
$stateProvider.
state('listSocialEvents', {
url: '/socialevents',
templateUrl: 'modules/socialevents/views/list-socialevents.client.view.html'
}).
state('createSocialEvent', {
url: '/socialevents/create',
templateUrl: 'modules/socialevents/views/create-socialevent.client.view.html'
}).
state('viewSocialEvent', {
url: '/socialevents/:socialeventId',
templateUrl: 'modules/socialevents/views/view-socialevent.client.view.html'
}).
state('editSocialEvent', {
url: '/socialevents/:socialeventId/edit',
templateUrl: 'modules/socialevents/views/edit-socialevent.client.view.html'
});
}
]);
|
// Copyright 2009 the Sputnik authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* @name: S15.10.2.15_A1_T8;
* @section: 15.10.2.15;
* @assertion: The internal helper function CharacterRange takes two CharSet parameters A and B and performs the
* following:
* If A does not contain exactly one character or B does not contain exactly one character then throw
* a SyntaxError exception;
* @description: Checking if execution of "/[\Wb-G]/.exec("a")" leads to throwing the correct exception;
*/
//CHECK#1
try {
$ERROR('#1.1: /[\\Wb-G]/.exec("a") throw SyntaxError. Actual: ' + (/[\Wb-G]/.exec("a")));
} catch (e) {
if((e instanceof SyntaxError) !== true){
$ERROR('#1.2: /[\\Wb-G]/.exec("a") throw SyntaxError. Actual: ' + (e));
}
}
|
const autoprefixer = require('autoprefixer');
const precss = require('precss');
const stylelint = require('stylelint');
const fontMagician = require('postcss-font-magician')({
// this is required due to a weird bug where if we let PFM use the `//` protocol Webpack style-loader
// thinks it's a relative URL and won't load the font when sourceMaps are also enabled
protocol: 'https:',
display: 'swap',
});
module.exports = {
plugins: [stylelint, fontMagician, precss, autoprefixer],
};
|
(function(window, document){
var chart;
var pressure_chart;
var lasttime;
function drawCurrent(data)
{
var tempDHT, tempBMP;
if (data.count_dht022 > 0)
{
lasttime = data.humidity[data.count_dht022-1][0];
tempDHT = data.temperature_dht022[data.count_dht022-1][1];
document.querySelector("span#humidityDHT022").innerHTML = data.humidity[data.count_dht022-1][1];
var date = new Date(lasttime);
document.querySelector("span#time").innerHTML = date.toTimeString();
}
if (data.count_bmp180 > 0)
{
lasttime = data.temperature_bmp180[data.count_bmp180-1][0];
tempBMP = data.temperature_bmp180[data.count_bmp180-1][1];
document.querySelector("span#pressureBMP180").innerHTML = data.pressure[data.count_bmp180-1][1] + 'mm hg (' + (data.pressure[data.count_bmp180-1][1] / 7.50061561303).toFixed(2) + ' kPa)' ;
var date = new Date(lasttime);
document.querySelector("span#time").innerHTML = date.toTimeString();
}
document.querySelector("span#temperature").innerHTML = '<abbr title="BMP180 ' + tempBMP + ', DHT022 ' + tempDHT + '">' + ((tempDHT + tempBMP)/2).toFixed(1) + '</abbr>';
document.querySelector("span#lastupdate").innerHTML = new Date().toTimeString();
}
function requestDelta()
{
$.ajax({
url: 'weather_new.php?mode=delta&delta='+lasttime,
datatype: "json",
success: function(data)
{
var i;
if (data.count > 0) {
for(i=0; i<data.count_dht022;i++)
chart.series[0].addPoint(data.temperature_dht022[i], false, true);
for(i=0; i<data.count_dht022;i++)
chart.series[1].addPoint(data.humidity[i], false, true);
for(i=0; i<data.count_bmp180;i++)
chart.series[0].addPoint(data.temperature_bmp180[i], false, true);
for(i=0; i<data.count_bmp180;i++)
pressure_chart.series[0].addPoint(data.pressure[i], false, true);
chart.redraw();
pressure_chart.redraw();
}
drawCurrent(data);
}
});
}
function requestData()
{
var daterange = document.querySelector("select#daterange").value;
if (!daterange)
daterange = "today";
$.ajax({
url: 'weather_new.php?mode='+daterange,
datatype: "json",
success: function(data)
{
chart.series[0].setData(data.temperature_dht022);
chart.series[1].setData(data.humidity);
chart.series[2].setData(data.temperature_bmp180);
pressure_chart.series[0].setData(data.pressure);
drawCurrent(data);
setInterval(requestDelta, 5 * 60 * 1000);
}
});
}
$(document).ready(function() {
Highcharts.setOptions({
global: {
useUTC: false
}
});
chart = new Highcharts.Chart({
chart: {
renderTo: 'graph',
type: 'spline',
events: {
load: requestData
}
},
title: {
text: 'Monitoring'
},
tooltip: {
shared: true
},
xAxis: {
type: 'datetime',
maxZoom: 20 * 1000
},
yAxis: {
min: 10,
minPadding: 0.2,
maxPadding: 0.2,
title: {
text: 'Temperature/Humidity',
margin: 80
}
},
series: [{
name: 'Temperature DHT022',
data: []
},
{
name: 'Humidity',
data: []
},
{
name: 'Temperature BMP180',
data: []
}]
});
pressure_chart = new Highcharts.Chart({
chart: {
renderTo: 'pressure_graph',
type: 'spline',
events: {
load: requestData
}
},
title: {
text: 'Pressure monitoring'
},
tooltip: {
shared: true
},
xAxis: {
type: 'datetime',
maxZoom: 20 * 1000
},
yAxis: {
min: 700,
minPadding: 0.2,
maxPadding: 0.2,
title: {
text: 'Pressure',
margin: 80
}
},
series: [{
name: 'Pressure',
data: []
}]
});
$('select#daterange').change(function() {requestData();});
});
})(window, document)
|
'use strict';
//Translations service used for translations REST endpoint
angular.module('mean.translations').factory('deleteTranslations', ['$resource',
function($resource) {
return $resource('deleteTranslations/:translationId', {
translationId: '@_id'
}, {
update: {
method: 'PUT'
}
});
}
]);
|
/**
* @flow
*/
import React from 'react';
import {storiesOf} from '@kadira/storybook';
import Textarea from './Textarea';
storiesOf('<Textarea />', module)
.add('Default state', () => <Textarea />)
.add('Error state', () => <Textarea error />)
.add('Disabled state', () => <Textarea disabled />)
.add('No border variant', () => <Textarea noBorder />);
|
/* jshint node:true */
// var RSVP = require('rsvp');
// For details on each option run `ember help release`
module.exports = {
// local: true,
// remote: 'some_remote',
// annotation: "Release %@",
// message: "Bumped version to %@",
manifest: [ 'package.json', 'package-lock.json']
// publish: true,
// strategy: 'date',
// format: 'YYYY-MM-DD',
// timezone: 'America/Los_Angeles',
//
// beforeCommit: function(project, versions) {
// return new RSVP.Promise(function(resolve, reject) {
// // Do custom things here...
// });
// }
};
|
module.exports = function(player, playerSpec) {
return ('data:image/svg+xml;utf-8,' +
encodeURIComponent(
`<svg width="${playerSpec.width}" height="${playerSpec.height}" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${playerSpec.width} ${playerSpec.height}" version="1.1" class="mapSvg"> \
<circle cx="${playerSpec.width/2}" cy="${playerSpec.height/2}" r="${playerSpec.height/4}" class="mapSvg__player" stroke="${playerSpec[player].color}" fill="${playerSpec[player].color}"/> \
</svg>`
)
);
};
|
"use strict";
var chai = require('chai'),
should = chai.should(),
expect = chai.expect,
XMLGrammers = require('../').XMLGrammers,
Parameters = require('../').Parameters;
describe('FMServerConstants', function(){
describe('XMLGrammers', function(){
it('should be frozen', function(){
expect(function(){
XMLGrammers.a = 1;
}).to.throw("Can't add property a, object is not extensible");
});
});
describe('Parameters', function() {
it('should be frozen', function () {
expect(function () {
Parameters.a = 1;
}).to.throw("Can't add property a, object is not extensible");
})
})
})
|
define(
[
'Magento_Checkout/js/model/error-processor',
'Magento_Checkout/js/model/full-screen-loader',
'Magento_Checkout/js/model/url-builder'
],
function (
errorProcessor,
fullScreenLoader,
urlBuilder
) {
'use strict';
const RETURN_URL = '/orders/:order_id/omise-offsite';
return {
/**
* Get return URL for Magento (based on order id)
*
* @return {string}
*/
getMagentoReturnUrl: function (order_id) {
return urlBuilder.createUrl(
RETURN_URL,
{ order_id }
);
},
/**
* Get payment method code
*
* @return {string}
*/
getCode: function() {
return this.code;
},
/**
* Is method available to display
*
* @return {boolean}
*/
isActive: function() {
if (this.restrictedToCurrencies && this.restrictedToCurrencies.length) {
let orderCurrency = this.getOrderCurrency();
return (this.getStoreCurrency() == orderCurrency) && this.restrictedToCurrencies.includes(orderCurrency);
} else {
return true;
}
},
/**
* Get order currency
*
* @return {string}
*/
getOrderCurrency: function () {
return window.checkoutConfig.quoteData.quote_currency_code.toLowerCase();
},
/**
* Get store currency
*
* @return {string}
*/
getStoreCurrency: function () {
return window.checkoutConfig.quoteData.store_currency_code.toLowerCase();
},
/**
* Checks if sandbox is turned on
*
* @return {boolean}
*/
isSandboxOn: function () {
return window.checkoutConfig.isOmiseSandboxOn;
},
/**
* Creates a fail handler for given context
*
* @return {boolean}
*/
buildFailHandler(context) {
return function (response) {
errorProcessor.process(response, context.messageContainer);
fullScreenLoader.stopLoader();
context.isPlaceOrderActionAllowed(true);
}
}
};
}
);
|
// Parts of this source are modified from npm and lerna:
// npm: https://github.com/npm/npm/blob/master/LICENSE
// lerna: https://github.com/lerna/lerna/blob/master/LICENSE
// @flow
import fs from 'fs';
import path from 'path';
import _cmdShim from 'cmd-shim';
import _readCmdShim from 'read-cmd-shim';
import promisify from 'typeable-promisify';
import makeDir from 'make-dir';
import _rimraf from 'rimraf';
export function readFile(filePath: string): Promise<string> {
return promisify(cb => fs.readFile(filePath, cb));
}
export function writeFile(
filePath: string,
fileContents: string
): Promise<string> {
return promisify(cb => fs.writeFile(filePath, fileContents, cb));
}
export function mkdirp(filePath: string): Promise<void> {
return makeDir(filePath);
}
export function rimraf(filePath: string): Promise<void> {
return promisify(cb => _rimraf(filePath, cb));
}
export function stat(filePath: string) {
return promisify(cb => fs.stat(filePath, cb));
}
export function lstat(filePath: string) {
return promisify(cb => fs.lstat(filePath, cb));
}
function unlink(filePath: string) {
return promisify(cb => fs.unlink(filePath, cb));
}
export function realpath(filePath: string) {
return promisify(cb => fs.realpath(filePath, cb));
}
function _symlink(src: string, dest: string, type: string) {
return promisify(cb => fs.symlink(src, dest, type, cb));
}
function stripExtension(filePath: string) {
return path.join(
path.dirname(filePath),
path.basename(filePath, path.extname(filePath))
);
}
async function cmdShim(src: string, dest: string) {
// If not a symlink we default to the actual src file
// https://github.com/npm/npm/blob/d081cc6c8d73f2aa698aab36605377c95e916224/lib/utils/gently-rm.js#L273
let relativeShimTarget = await readlink(src);
let currentShimTarget = relativeShimTarget
? path.resolve(path.dirname(src), relativeShimTarget)
: src;
await promisify(cb => _cmdShim(currentShimTarget, stripExtension(dest), cb));
}
async function createSymbolicLink(src, dest, type) {
try {
await lstat(dest);
await rimraf(dest);
} catch (err) {
if (err.code === 'EPERM') throw err;
}
await _symlink(src, dest, type);
}
async function createPosixSymlink(origin, dest, type) {
if (type === 'exec') {
type = 'file';
}
let src = path.relative(path.dirname(dest), origin);
return await createSymbolicLink(src, dest, type);
}
async function createWindowsSymlink(src, dest, type) {
if (type === 'exec') {
return await cmdShim(src, dest);
} else {
return await createSymbolicLink(src, dest, type);
}
}
export async function symlink(
src: string,
dest: string,
type: 'exec' | 'junction'
) {
if (dest.includes(path.sep)) {
await mkdirp(path.dirname(dest));
}
if (process.platform === 'win32') {
return await createWindowsSymlink(src, dest, type);
} else {
return await createPosixSymlink(src, dest, type);
}
}
export async function readdir(dir: string) {
return promisify(cb => fs.readdir(dir, cb));
}
// Return an empty array if a directory doesnt exist (but still throw if errof if dir is a file)
export async function readdirSafe(dir: string) {
return stat(dir)
.catch(err => Promise.resolve([]))
.then(statsOrArray => {
if (statsOrArray instanceof Array) return statsOrArray;
if (!statsOrArray.isDirectory())
throw new Error(dir + ' is not a directory');
return readdir(dir);
});
}
function readCmdShim(filePath: string) {
return promisify(cb => _readCmdShim(filePath, cb));
}
function _readlink(filePath: string) {
return promisify(cb => fs.readlink(filePath, cb));
}
// Copied from:
// https://github.com/npm/npm/blob/d081cc6c8d73f2aa698aab36605377c95e916224/lib/utils/gently-rm.js#L280-L297
export async function readlink(filePath: string) {
let stat = await lstat(filePath);
let result = null;
if (stat.isSymbolicLink()) {
result = await _readlink(filePath);
} else {
try {
result = await readCmdShim(filePath);
} catch (err) {
if (err.code !== 'ENOTASHIM' && err.code !== 'EISDIR') {
throw err;
}
}
}
return result;
}
export async function dirExists(dir: string) {
try {
let _stat = await stat(dir);
return _stat.isDirectory();
} catch (err) {
return false;
}
}
export async function symlinkExists(filePath: string) {
try {
let stat = await lstat(filePath);
return stat.isSymbolicLink();
} catch (err) {
return false;
}
}
|
module.exports = IpfsUtil;
var fs = require('fs');
var formstream = require('formstream');
var http = require('http');
var request = require('request');
function IpfsUtil() {
}
IpfsUtil.prototype.init = function (config) {
this.__host = config.ipfs.host;
this.__port = config.ipfs.port;
};
IpfsUtil.prototype.getTar = function (key, toFile, callback) {
var self = this;
var uri = 'http://' + self.__host + ':' + self.__port + '/api/v0/tar/cat?arg=' + key;
console.log(uri);
request
.get(uri)
.on('end', function () {
console.log('GET request ended....');
callback();
}).on('error', function (err) {
console.log('ERROR: ', err);
return callback(err);
})
.pipe(fs.createWriteStream(toFile));
};
IpfsUtil.prototype.uploadTar = function (filePath, callback) {
var self = this;
var form = formstream();
form.file('file', filePath);
var options = {
method: 'POST',
host: self.__host,
port: self.__port,
path: '/api/v0/tar/add',
headers: form.headers()
};
console.log(options);
var req = http.request(options, function (res) {
res.on('data', function (data) {
console.log(data);
callback(null, (JSON.parse(data)).Hash);
});
//res.on('end', function () {
// console.log('Request ended...');
// callback();
//});
res.on('error', function (err) {
console.log(err);
return callback(err);
})
});
form.pipe(req);
};
|
import {observable} from 'mobx';
export default class SessionDocumentModel {
@observable id;
@observable sessionID;
@observable studentID;
@observable filename;
@observable CreatorId;
@observable archived;
constructor(value) {
this.id = id;
this.sessionID = sessionID;
this.studentID = studentID;
this.filename = filename;
this.CreatorId = CreatorId;
this.archived = archived;
}
}
|
'use babel';
//import reddit from './api/reddit';
import giphy from './api/giphy';
import ohMaGif from './api/oh-ma-gif';
import reactionGifs from './api/reaction-gifs';
const apis = [
//reddit,
giphy,
ohMaGif,
reactionGifs
];
export default function getRndThumbnail() {
const apiFn = apis[Math.floor(Math.random() * apis.length)];
return apiFn().catch(err => {
// Show error notification
atom.notifications.addError(err, {
dismissable: true
});
});
}
|
var dropzoneOverlay = document.querySelector('.dropzone-overlay');
function getDataTransferFiles(event) {
var dataTransferItemsList = [];
if (event.dataTransfer) {
var dt = event.dataTransfer;
if (dt.files && dt.files.length) {
dataTransferItemsList = dt.files;
} else if (dt.items && dt.items.length) {
// During the drag even the dataTransfer.files is null
// but Chrome implements some drag store, which is accesible via dataTransfer.items
dataTransferItemsList = dt.items;
}
} else if (event.target && event.target.files) {
dataTransferItemsList = event.target.files;
}
if (dataTransferItemsList.length > 0) {
dataTransferItemsList = [dataTransferItemsList[0]];
}
// Convert from DataTransferItemsList to the native Array
return Array.prototype.slice.call(dataTransferItemsList);
}
function showDragFocus() {
dropzoneOverlay.className = 'dropzone-overlay active';
}
function hideDragFocus() {
dropzoneOverlay.className = 'dropzone-overlay';
}
function onFileDragEnter(ev) {
ev.preventDefault();
showDragFocus();
}
function onFileDragOver(ev) {
ev.preventDefault();
}
function onFileDrop(ev) {
ev.preventDefault();
hideDragFocus();
var fileList = getDataTransferFiles(ev);
updateStickerImage(fileList[0]);
return null;
}
function onFileDragLeave(ev) {
ev.preventDefault();
console.log(ev.target)
if (ev.target !== document.body) {
return;
}
hideDragFocus();
}
function drawImage(canvas, imageBitmap) {
var ctx = canvas.getContext('2d');
ctx.drawImage(file, 0, 0);
}
function updateStickerImage(file) {
var reader = new FileReader();
reader.onload = function(ev) {
var dataURL = ev.target.result;
document.querySelectorAll('.sticker-img').forEach(function(img) {
img.style = 'background-image: url(' + dataURL + ')';
});
}
reader.readAsDataURL(file);
}
document.body.ondragenter = onFileDragEnter;
document.body.ondragover = onFileDragOver;
document.body.ondragleave = onFileDragLeave;
document.body.ondrop = onFileDrop;
|
'use strict';
import React from 'react';
import { external_url_map } from "../components/globals";
/**
* Method to display either mode of inheritance with adjective,
* or just mode of inheritance if no adjective
* @param {object} object - A GDM or Interpretation object
*/
export function renderSelectedModeInheritance(object) {
let moi = '', moiAdjective = '';
if (object && object.modeInheritance) {
moi = object.modeInheritance;
if (object.modeInheritanceAdjective) {
moiAdjective = object.modeInheritanceAdjective;
}
}
return (
<span>{moi && moi.length ? renderModeInheritanceLink(moi, moiAdjective) : 'None'}</span>
);
}
/**
* Method to construct mode of inheritance linkout
*/
function renderModeInheritanceLink(modeInheritance, modeInheritanceAdjective) {
if (modeInheritance) {
let start = modeInheritance.indexOf('(');
let end = modeInheritance.indexOf(')');
let hpoNumber;
let adjective = modeInheritanceAdjective && modeInheritanceAdjective.length ? ' (' + modeInheritanceAdjective.match(/^(.*?)(?: \(HP:[0-9]*?\)){0,1}$/)[1] + ')' : '';
if (start && end) {
hpoNumber = modeInheritance.substring(start+1, end);
}
if (hpoNumber && hpoNumber.indexOf('HP:') > -1) {
let hpoLink = external_url_map['HPO'] + hpoNumber;
return (
<span><a href={hpoLink} target="_blank">{modeInheritance.match(/^(.*?)(?: \(HP:[0-9]*?\)){0,1}$/)[1]}</a>{adjective}</span>
);
} else {
return (
<span>{modeInheritance + adjective}</span>
);
}
}
}
|
"use strict";
var echo = require('echo'),
Authorization = require('./auth.js'),
Packer = require('./packer.js'),
Request = require('./request.js'),
RequestOptions = require('./req-options.js'),
portMatch = /:(\d+)$/,
parse = function (host, port) {
var out = {
"host": "localhost",
"port": 80
},
match = portMatch.exec(host);
if (match) {
if (isNaN(port)) {
port = match[1];
}
host = host.slice(0, match.index);
}
if (host) {
out.host = host;
}
if (!isNaN(port)) {
out.port = Number(port);
}
return out;
},
secs = function (ms) {
var secs = ms / 1000;
return '(' + secs.toFixed(3) + ' sec)';
};
function Client() {
this.host = undefined;
this.port = undefined;
this.auth = undefined;
this.timeout = undefined;
this.verbose = undefined;
}
Client.prototype = {
"request": function (options, data, done, fail) {
var self = this,
auth = self.auth,
verbose = self.verbose,
target = self.toString(options),
req,
authStr;
if (auth) {
authStr = auth.toString(options);
}
req = Request.create(options, authStr);
req.on('response', function (res, options) {
var code = res.statusCode,
failed = function (msg) {
if (msg && verbose) {
echo(msg);
}
if (fail) {
fail(code, options, res);
} else {
res._dump();
}
};
if (verbose) {
echo(target, 'returned', code, secs(options.duration));
}
if (code === 401) {
if (auth) {
if (authStr) {
failed('Invalid credentials.');
} else {
auth.parse(res.headers);
res._dump();
self.request(options, data, done, fail);
}
} else {
failed('Credentials required.');
}
} else if (Math.floor(code / 100) === 2) {
if (done) {
done(res, options);
}
} else {
failed();
}
});
req.on('timeout', function (seconds) {
var sec = '(' + seconds + ' seconds)';
if (verbose) {
echo(target, 'timed out.', sec);
}
auth.clear();
if (fail) {
fail('ETIMEDOUT', options);
}
});
req.on('error', function (code, options) {
if (verbose) {
echo(target, code);
}
if (fail) {
fail(code, options);
}
});
if (verbose) {
echo(target);
}
req.send(data, self.timeout);
},
"get": function (path, done, fail) {
var options = RequestOptions.createGET(this.host, this.port, path);
this.request(options, undefined, done, fail);
},
"postEmpty": function (path, done, fail) {
var options = RequestOptions.createPOSTEmpty(this.host, this.port, path);
this.request(options, undefined, done, fail);
},
"post": function (path, mime, str, done, fail) {
var options = RequestOptions.createPOSTAs(this.host, this.port, path, mime, str);
this.request(options, str, done, fail);
},
"postString": function (path, str, done, fail) {
var options = RequestOptions.createPOSTString(this.host, this.port, path, str);
this.request(options, str, done, fail);
},
"postJSON": function (path, json, done, fail) {
var data = JSON.stringify(json),
options = RequestOptions.createPOSTJSON(this.host, this.port, path, data);
this.request(options, data, done, fail);
},
"postXML": function (path, xml, done, fail) {
var data = Packer.packXML(xml),
options = RequestOptions.createPOSTXML(this.host, this.port, path, data);
this.request(options, data, done, fail);
},
"toString": function (options) {
var host = this.host + ':' + this.port,
str = options.method + ' ' + host + options.path,
max = 60;
if (str.length > max) {
return str.slice(0, max) + '...';
}
return str;
}
};
module.exports = {
"create": function (info) {
var client = new Client(),
parsed;
if (!info) {
info = {};
}
parsed = parse(info.host, info.port);
client.host = parsed.host;
client.port = parsed.port;
if (info.user) {
client.auth = Authorization.create(info.user, info.pass);
}
client.timeout = info.timeout || 180;
client.verbose = info.verbose;
return client;
}
};
|
var searchData=
[
['database',['Database',['../namespace_pontikis_1_1_database.html',1,'Pontikis']]],
['pg_5fsequence_5fname_5fauto',['PG_SEQUENCE_NAME_AUTO',['../class_pontikis_1_1_database_1_1_dacapo.html#aef46219ed4c7133e99979e0d3aa5cd86',1,'Pontikis::Database::Dacapo']]],
['pontikis',['Pontikis',['../namespace_pontikis.html',1,'']]],
['prepared_5fstatements_5fnumbered',['PREPARED_STATEMENTS_NUMBERED',['../class_pontikis_1_1_database_1_1_dacapo.html#a963df8efcdd80ba37064e3cde0c8809a',1,'Pontikis::Database::Dacapo']]],
['prepared_5fstatements_5fquestion_5fmark',['PREPARED_STATEMENTS_QUESTION_MARK',['../class_pontikis_1_1_database_1_1_dacapo.html#a63dd2d4d612585c42c7e53e9b66caf24',1,'Pontikis::Database::Dacapo']]]
];
|
import test from 'ava';
import debounce from 'lodash.debounce';
import webpack from 'webpack';
import 'babel-core/register';
import helper from './_helper';
import expected from './basic/expected.json';
test.beforeEach(t => {
const config = helper.getSuiteConfig('basic');
t.context.config = config
t.context.extractOpts = helper.getExtractOptions(config);
t.end();
})
test('basic', t => {
t.plan(1);
const callback = (err, stats) => {
err = err || (stats.hasErrors() ? new Error(stats.toString()) : null)
if (err) { t.fail(err); t.end(); }
setTimeout(() => {
const output = require(t.context.extractOpts.outputFile);
t.same(output, expected);
t.end();
}, t.context.extractOpts.writeDebounceMs);
}
webpack(t.context.config, callback);
})
test('basic (onOutput)', t => {
t.plan(1);
const onOutput = debounce((filename, blob, total) => {
t.same(total, expected);
t.end();
}, t.context.extractOpts.writeDebounceMs);
const config = Object.assign({}, t.context.config, {
extractCssModuleClassnames: { onOutput }
});
const callback = (err, stats) => {
err = err || (stats.hasErrors() ? new Error(stats.toString()) : null)
if (err) { t.fail(err); t.end(); }
}
webpack(config, callback);
});
|
/**
* 对Storage的封装
* Author : smohan
* Website : https://smohan.net
* Date: 2017/10/12
* 参数1：布尔值， true : sessionStorage, 无论get,delete,set都得申明
* 参数1：string key 名
* 参数2：null,用作删除，其他用作设置
* 参数3：string，用于设置键名前缀
* 如果是sessionStorage，即参数1是个布尔值，且为true，
* 无论设置/删除/获取都应该指明，而localStorage无需指明
*/
const MEMORY_CACHE = Object.create(null)
export default function () {
let isSession = false,
name, value, prefix
let args = arguments
if (typeof args[0] === 'boolean') {
isSession = args[0]
args = [].slice.call(args, 1)
}
name = args[0]
value = args[1]
prefix = args[2] === undefined ? '_mo_data_' : args[2]
const Storage = isSession ? window.sessionStorage : window.localStorage
if (!name || typeof name !== 'string') {
throw new Error('name must be a string')
}
let cacheKey = (prefix && typeof prefix === 'string') ? (prefix + name) : name
if (value === null) { //remove
delete MEMORY_CACHE[cacheKey]
return Storage.removeItem(cacheKey)
} else if (!value && value !== 0) { //get
if (MEMORY_CACHE[cacheKey]) {
return MEMORY_CACHE[cacheKey]
}
let _value = undefined
try {
_value = JSON.parse(Storage.getItem(cacheKey))
} catch (e) {}
return _value
} else { //set
MEMORY_CACHE[cacheKey] = value
return Storage.setItem(cacheKey, JSON.stringify(value))
}
}
|
/*
*
* UI reducer
*
*/
import { fromJS } from 'immutable';
import {
SET_PRODUCT_QUANTITY_SELECTOR,
} from './constants';
const initialState = fromJS({
product: {
quantitySelected: 1,
},
});
function uiReducer(state = initialState, action) {
switch (action.type) {
case SET_PRODUCT_QUANTITY_SELECTOR:
return state.setIn(['product', 'quantitySelected'], action.quantity);
default:
return state;
}
}
export default uiReducer;
|
var async = require('async');
var settings = require('../settings/settings.js');
var Post = require('../models/post.js');
var List = require('../models/list.js');
module.exports = function(app){
app.get('/getArchive',function(req,res,next){
if(req.sessionID){
var list = new List({
pageIndex:1,
pageSize:settings.pageSize,
queryObj:{}
});
list.getArchive(function(err,archiveArray){
if(!(err)&&archiveArray){
res.json(archiveArray);
res.end();
}else{
res.json({status:404,message:''});
res.end();
}
});
}else{
res.end();
}
});
app.get('/getPageCount',function(req,res,next){
if(req.sessionID){
var list = new List({
pageIndex:1,
pageSize:settings.pageSize,
queryObj:{}
});
list.getCount(function(err,count){
if(!(err)&&(count!=0)){
res.json(Math.ceil(count/settings.pageSize));
res.end();
}else{
res.json({status:404,message:''});
res.end();
}
});
}else{
res.end();
}
});
app.get('/',function(req,res,next){
if(req.sessionID){
var list = new List({
pageIndex:1,
pageSize:settings.pageSize,
queryObj:{}
});
list.getList(function(err,docs){
if(!(err)&&docs){
res.json(docs);
res.end();
}else{
res.json({status:404,message:''});
res.end();
}
});
}else{
res.end();
}
});
}
|
module('Item');
test('.setOptions()', function() {
var item = new Item({
name: 'Name',
category: 'Category',
icon: 'Icon',
value: 'Value',
flavor: 'Flavor',
rarity: 'Rare',
});
item.code = 'Code';
equal(item.getName(),'Name');
equal(item.getCategory(),'Category');
equal(item.getIcon(),'Icon');
equal(item.getValue(),'Value');
equal(item.getFlavor(),'Flavor');
equal(item.getRarity(),'Rare');
equal(item.getCode(),'Code');
equal(item.isEquipment(),false);
});
test('Rarity Classes', function() {
var item = Factories.buildItem({});
equal(item.getRarity(),'Common');
equal(item.getClassName(),'highlight-item-common');
item.rarity = 'Uncommon';
equal(item.getClassName(),'highlight-item-uncommon');
item.rarity = 'Rare';
equal(item.getClassName(),'highlight-item-rare');
item.rarity = 'Epic';
equal(item.getClassName(),'highlight-item-epic');
});
|
(function (angular) {
// Create all modules and define dependencies to make sure they exist
// and are loaded in the correct order to satisfy dependency injection
// before all nested files are concatenated by Gulp
// Config
angular
.module('jackalMqtt.config', [])
.value('jackalMqtt.config', {
debug: true
});
// Modules
angular
.module('jackalMqtt.services', []);
angular
.module('jackalMqtt', [
'jackalMqtt.config',
'jackalMqtt.services'
]);
})(angular);
angular
.module('jackalMqtt.services')
.factory('mqttService', MqttService)
.factory('dataService', DataService);
DataService.$inject = [ ];
function DataService () {
var service = {
data: { }
};
return service;
}
MqttService.$inject = ['$rootScope', 'dataService'];
function MqttService ($rootScope, dataService) {
var mqttc;
var Paho = Paho;
var callbacks = { };
function addCallback(chanel, callbackName, dataName) {
callbacks[chanel] = [callbackName, dataName];
}
function deleteCallback(chanel){
delete callbacks[chanel];
}
function chanelMatch(chanel, destination) {
var reg = '^';
destination += '/';
var levels = chanel.split('/');
for (var ind = 0; ind < levels.length; ind++){
var lvl = levels[ind];
if(lvl === '+'){
reg = '([a-z]|[0-9])+/';
}else if(lvl === '#'){
reg += '(([a-z]|[0-9])|/)*';
}else{
reg += (lvl + '/');
}
}
reg += '$';
reg = new RegExp(reg);
if(reg.test(destination)){
return true;
}
return false;
}
function onConnect() {
$rootScope.$broadcast('connected');
}
function onConnectionLost(responseObject) {
if(responseObject.errorCode !== 0){
$rootScope.$broadcast('connectionLost');
}
}
function onMessageArrived(message) {
var payload = message.payloadString;
var destination = message.destinationName;
for(var key in callbacks) {
if(callbacks.hasOwnProperty(key)) {
var match = chanelMatch(key, destination);
if(match) {
dataService.data[callbacks[key][1]] = payload;
$rootScope.$broadcast(callbacks[key][0]);
}
}
}
}
function connect(host, port, options) {
mqttc = new Paho.MQTT.Client(host, Number(port), 'web_client_' + Math.round(Math.random() * 1000));
mqttc.onConnectionLost = onConnectionLost;
mqttc.onMessageArrived = onMessageArrived;
options['onSuccess'] = onConnect;
mqttc.connect(options);
}
function disconnect() {
mqttc.disconnect();
}
function subscribe(chanel, callbackName, dataName) {
mqttc.subscribe(chanel);
addCallback(chanel, callbackName, dataName);
}
function unsubscribe(chanel) {
mqttc.unsubscribe(chanel);
deleteCallback(chanel);
}
function publish(chanel, message, retained) {
var payload = JSON.stringify(message);
var mqttMessage = new Paho.MQTT.Message(payload);
mqttMessage.retained = retained;
mqttMessage.detinationName = chanel;
mqttc.send(mqttMessage);
}
return {
connect: connect,
disconnect: disconnect,
subscribe: subscribe,
unsubscribe: unsubscribe,
publish: publish,
/** TEST CODE **/
_addCallback: addCallback,
_deleteCallback: deleteCallback,
_chanelMatch: chanelMatch,
_callbacks: callbacks
/** TEST CODE **/
};
}
|
import TheWalletView from '@/views/TheWalletView';
import Dashboard from '@/views/layouts-wallet/TheDashboardLayout';
import Send from '@/views/layouts-wallet/TheSendTransactionLayout';
import NftManager from '@/views/layouts-wallet/TheNFTManagerLayout';
import Swap from '@/views/layouts-wallet/TheSwapLayout';
import InteractContract from '@/views/layouts-wallet/TheInteractContractLayout';
import DeployContract from '@/views/layouts-wallet/TheDeployContractLayout';
import SignMessage from '@/views/layouts-wallet/TheSignMessageLayout';
import VerifyMessage from '@/views/layouts-wallet/TheVerifyMessageLayout';
import Dapps from '@/views/layouts-wallet/TheDappCenterLayout.vue';
import DappRoutes from '@/dapps/routes-dapps.js';
import Settings from '@/modules/settings/ModuleSettings';
import NftManagerSend from '@/modules/nft-manager/components/NftManagerSend';
// import Notifications from '@/modules/notifications/ModuleNotifications';
import Network from '@/modules/network/ModuleNetwork';
import { swapProps, swapRouterGuard } from './helpers';
import { ROUTES_WALLET } from '../configs/configRoutes';
export default {
path: '/wallet',
component: TheWalletView,
props: true,
children: [
{
path: ROUTES_WALLET.WALLETS.PATH,
name: ROUTES_WALLET.WALLETS.NAME,
component: Dashboard,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.DASHBOARD.PATH,
name: ROUTES_WALLET.DASHBOARD.NAME,
component: Dashboard,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.SETTINGS.PATH,
name: ROUTES_WALLET.SETTINGS.NAME,
component: Settings,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.SEND_TX.PATH,
name: ROUTES_WALLET.SEND_TX.NAME,
component: Send,
props: true,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.NFT_MANAGER.PATH,
name: ROUTES_WALLET.NFT_MANAGER.NAME,
component: NftManager,
children: [
{
path: ROUTES_WALLET.NFT_MANAGER_SEND.PATH,
name: ROUTES_WALLET.NFT_MANAGER_SEND.NAME,
component: NftManagerSend,
meta: {
noAuth: false
}
}
],
meta: {
noAuth: false
}
},
// {
// path: ROUTES_WALLET.NOTIFICATIONS.PATH,
// name: ROUTES_WALLET.NOTIFICATIONS.NAME,
// component: Notifications,
// meta: {
// noAuth: false
// }
// },
{
path: ROUTES_WALLET.NETWORK.PATH,
name: ROUTES_WALLET.NETWORK.NAME,
component: Network,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.SWAP.PATH,
name: ROUTES_WALLET.SWAP.NAME,
component: Swap,
props: swapProps,
beforeEnter: swapRouterGuard,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.DAPPS.PATH,
component: Dapps,
children: DappRoutes,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.DEPLOY_CONTRACT.PATH,
name: ROUTES_WALLET.DEPLOY_CONTRACT.NAME,
component: DeployContract,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.INTERACT_WITH_CONTRACT.PATH,
name: ROUTES_WALLET.INTERACT_WITH_CONTRACT.NAME,
component: InteractContract,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.SIGN_MESSAGE.PATH,
name: ROUTES_WALLET.SIGN_MESSAGE.NAME,
component: SignMessage,
meta: {
noAuth: false
}
},
{
path: ROUTES_WALLET.VERIFY_MESSAGE.PATH,
name: ROUTES_WALLET.VERIFY_MESSAGE.NAME,
component: VerifyMessage,
meta: {
noAuth: false
}
}
]
};
|
/**
* Created by ozgur on 24.07.2017.
*/
var assert = require('assert');
var fs = require("fs");
var path = require("path");
var LineCounter = require("../lib/LineCounter");
var ExtensionsFactory = require("../lib/Extensions");
var Rules = require("../lib/Rules");
describe("LineCounter", function(){
before(function(){
var dir = __dirname;
fs.mkdirSync(path.join(dir, "dir"));
fs.mkdirSync(path.join(dir, "dir", "dir2"));
fs.mkdirSync(path.join(dir, "dir", "dir3"));
fs.writeFileSync(path.join(dir, "dir", "file1.java"), "line1\nline2");
fs.writeFileSync(path.join(dir, "dir", "file1.js"), "line1\nline2\nline3");
fs.writeFileSync(path.join(dir, "dir", "dir2", "file3.php"), "line1\nline2");
fs.writeFileSync(path.join(dir, "dir", "dir2", "file4.swift"), "line1\nline2");
fs.writeFileSync(path.join(dir, "dir", "dir3", "file5.java"), "line1\nline2");
fs.writeFileSync(path.join(dir, "dir", "dir3", "file6.js"), "line1\nline2");
});
describe("#resolveTargetFiles()", function(){
it("should return allowed extensions", function(){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
lc.setExtensions(ExtensionsFactory.from("js"));
var result = lc.resolveTargetFiles();
var expected = [ path.join(__dirname, "dir", "dir3", "file6.js"), path.join(__dirname, "dir", "file1.js") ];
for( var i = 0; i < expected.length; i++ ){
assert.equal(expected[i], result[i].getPath());
}
});
it("should return all except disallowed ones", function(){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
lc.setExtensions(ExtensionsFactory.except("java, swift, php"));
var result = lc.resolveTargetFiles();
var expected = [ path.join(__dirname, "dir", "dir3", "file6.js"), path.join(__dirname, "dir", "file1.js") ];
for( var i = 0; i < expected.length; i++ ){
assert.equal(expected[i], result[i].getPath());
}
});
it("should return all", function(){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
var result = lc.resolveTargetFiles();
var expected = [ path.join(__dirname, "dir", "dir2", "file3.php"), path.join(__dirname, "dir", "dir2", "file4.swift"),
path.join(__dirname, "dir", "dir3", "file5.java"), path.join(__dirname, "dir", "dir3", "file6.js"),
path.join(__dirname, "dir", "file1.java"), path.join(__dirname, "dir", "file1.js")];
for( var i = 0; i < expected.length; i++ ){
assert.equal(expected[i], result[i].getPath());
}
});
});
describe("#getLines()", function(){
it("should count all files correctly", function(done){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
lc.getLines(function(result){
assert.equal(6, result.files);
assert.equal(13, result.lines);
done();
});
});
it("should count only js files", function(done){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
lc.setExtensions(ExtensionsFactory.from("js"));
lc.getLines(function(result){
assert.equal(2, result.files);
assert.equal(5, result.lines);
done();
});
});
});
describe("#addRule()", function(){
it("should return only the files starts with file1", function(){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
lc.addRule(Rules.filePrefix, "file1");
var result = lc.resolveTargetFiles();
var expected = [ path.join(__dirname, "dir", "file1.java"), path.join(__dirname, "dir", "file1.js") ];
for( var i = 0; i < expected.length; i++ ){
assert.equal(expected[i], result[i].getPath());
}
});
it("should ignore dir2 and dir3 directories", function(){
var lc = new LineCounter();
lc.setPath(path.join(__dirname, "dir"));
lc.addRule(Rules.ignoreDir, "dir2");
lc.addRule(Rules.ignoreDir, "dir3");
var result = lc.resolveTargetFiles();
var expected = [ path.join(__dirname, "dir", "file1.java"), path.join(__dirname, "dir", "file1.js") ];
for( var i = 0; i < expected.length; i++ ){
assert.equal(expected[i], result[i].getPath());
}
});
});
after(function(){
var dir = __dirname;
fs.unlinkSync(path.join(dir, "dir", "dir3", "file6.js"));
fs.unlinkSync(path.join(dir, "dir", "dir3", "file5.java"));
fs.unlinkSync(path.join(dir, "dir", "dir2", "file4.swift"));
fs.unlinkSync(path.join(dir, "dir", "dir2", "file3.php"));
fs.unlinkSync(path.join(dir, "dir", "file1.js"));
fs.unlinkSync(path.join(dir, "dir", "file1.java"));
fs.rmdirSync(path.join(dir, "dir", "dir2"));
fs.rmdirSync(path.join(dir, "dir", "dir3"));
fs.rmdirSync(path.join(dir, "dir"));
});
});
|
define(['./Suite','./SuiteView','./Spy', './Verify'],function (Suite,SuiteView,Spy,Verify) {
var itchCork = {
Suite: Suite,
suiteView: new SuiteView(),
Spy: Spy,
Verify: Verify
};
itchCork.Suite.prototype.linkView(itchCork.suiteView);
window._bTestResults = {};
return itchCork;
});
|
'use strict';
function A() {
this._va = 0;
console.log('A');
}
A.prototype = {
va: 1,
fa: function() {
console.log('A->fa()');
}
};
function B() {
this._vb = 0;
console.log('B');
}
B.prototype = {
vb: 1,
fb: function() {
console.log('B->fb()');
}
};
function C() {
this._vc = 0;
console.log('C');
}
C.prototype = {
vc: 1,
fc: function() {
console.log('C->fc()');
}
};
function D(){
this._vd = 0;
console.log('D');
}
D.prototype = {
vd: 1,
fd: function() {
this.fa();
this.fb();
this.fc();
console.log('D->fd()');
}
};
var mixin = require('../mixin');
D = mixin(D, A);
D = mixin(D, B);
D = mixin(D, C);
var d = new D();
console.log(d);
console.log(d.constructor.name);
d.fd();
var a = new A();
console.log(a);
console.log(a.__proto__);
console.log(a.va);
|
export { default } from 'ember-transformer/transforms/array';
|
var mongodb = require('mongodb'),
ObjectId = mongodb.ObjectId;
/**
* Quips Quarantine
**/
var quips_quarantine = function ( app ) {
/**
* Return a list of all (for now) quips in quips_quarantine
**/
app.get('/v1/quips_quarantine', function ( req, res ) {
app.mdbConnect(function ( err, db ) {
db.collection('quips_quarantine').find().toArray(function ( err, results ) {
if (err) { throw err; }
if (results) {
res.setHeader('Content-Type', 'application/json');
res.send(JSON.stringify( results ));
}
db.close();
});
});
});
app.get('/v1/quips_quarantine/:id', function ( req, res ) {
app.mdbConnect(function ( err, db ) {
if (err) { throw err; }
db.collection('quips_quarantine').findOne({ "_id": new ObjectId( req.params.id ) }, function ( err, doc ) {
if (err) { throw err; }
if (doc) {
res.setHeader('Content-Type', 'application/json');
res.send(JSON.stringify( doc ));
}
db.close();
});
});
});
app.get('/v1/quips_quarantine/:id/approve', function ( req, res ) {
app.mdbConnect(function ( err, db ) {
if (err) { throw err; }
db.collection('quips_quarantine').findOne({ "_id": new ObjectId( req.params.id ) }, function ( err, doc ) {
if (err) { throw err; }
if (doc) {
db.collection('quips').insert( doc );
db.collection('quips_quarantine').remove( doc );
res.send(JSON.stringify( doc ));
}
db.close();
});
});
});
app.get('/v1/quips_quarantine/:id/reject', function ( req, res ) {
app.mdbConnect(function ( err, db ) {
if (err) { throw err; }
// db.collection('quips_quarantine').findOne({ "_id": new ObjectId( req.params.id ) }, function ( err, doc ) {
// if (err) { throw err; }
// if (doc) {
// db.collection('quips_quarantine').remove( doc );
// res.send(JSON.stringify( doc ));
// }
// db.close();
// });
});
});
};
module.exports = quips_quarantine;
|
/*jshint esversion: 6 */
import './flowtext.js';
|
var ig = {};
// !!! USE YOUR OWN TOKEN
ig.token = '43619676.1677ed0.5ca7163640fc4a7f89ca21dc02475134';
ig.init = function() {
$('.instagram').each(function(i) {
var args = {};
args.container = $(this);
args.userid = args.container.data('userid');
args.limit = args.container.data('limit');
args.feedurl = 'https://api.instagram.com/v1/users/'+args.userid+'/media/recent/?access_token='+ig.token+'&count='+args.limit+'&callback=?';
args.html = '';
// PASS ARGS TO QUERY
ig.query(args);
});
}
ig.query = function(args) {
$.getJSON(args.feedurl, {}, function(data) {
// PASS QUERY DATA TO BUILDER
ig.build(data, args);
});
}
ig.build = function(data, args) {
$.each(data.data,function (i,item) {
console.log(item);
if (item.caption) var caption = item.caption.text;
var thumb = item.images.low_resolution.url;
var img = item.images.standard_resolution.url;
//get 1280 size photo [hack until avail in api]
var hires = img.replace('s640x640', '1080x1080');
args.html += '<a class="image" style="background-image: url('+thumb+');" data-img="'+hires+'">';
if (caption) args.html += '<span class="caption">'+caption+'</span>';
args.html += '</a>';
// PASS TO OUTPUT
ig.output(args);
});
}
ig.output = function(args) {
args.container.html(args.html);
}
ig.view = {
viewer: $('.igviewer'),
image: $('.igviewer img'),
open: function(img) {
ig.view.viewer.removeClass('hidden');
ig.view.image.attr('src', img);
},
close: function() {
ig.view.viewer.addClass('hidden');
ig.view.image.attr('src', '');
}
}
ig.init();
//Listeners
$('.instagram').on('click', '.image', function(){
var img = this.dataset.img;
ig.view.open(img);
});
$('.igviewer').on('click', function(){
ig.view.close();
});
|
var Chat = function(socket) {
this.socket = socket;
};
// function to send chat messages
Chat.prototype.sendMessage = function(room, text) {
var message = {
room: room,
text: text
};
this.socket.emit('message', message);
};
// function to change rooms
Chat.prototype.changeRoom = function(room) {
this.socket.emit('join', {
newRoom: room
});
};
// processing chat commands
Chat.prototype.processCommand = function(command) {
var words = command.split(' ');
var command = words[0]
.substring(1, words[0].length)
.toLowerCase(); // parse command from first word
var message = false;
switch(command) {
case 'join':
words.shift();
var room = words.join(' ');
this.changeRoom(room); // handle room changing/creating
break;
case 'nick':
words.shift();
var name = words.join(' ');
this.socket.emit('nameAttempt', name); // handle name-change attempts
break;
default:
message = 'Unrecognized command.'; // return error message if command isn't Unrecognized
break;
}
return message;
};
|
import Ember from 'ember';
import layout from '../templates/components/ons-back-button';
export default Ember.Component.extend({
layout,
tagName: 'ons-back-button',
attributeBindings: ['modifier']
});
|
"use strict";
var chai = require('chai');
var chaiHttp = require('chai-http');
var expect = require('chai').expect;
var app = require('../app');
var port = 3001;
var user1 = {
username: 'Laura',
password: 'tiger',
address: {
street: '123 Main St',
city: 'Beaverton',
state: 'OR',
zip: 97007,
},
_id: '',
};
chai.use(chaiHttp);
function chaiRequest() {
return chai.request(`localhost:${port}`);
}
describe('Single Resource REST API', function() {
before(function(done) {
app.listen(port, done);
});
it('POST /users request should add a user to DB', function(done) {
chaiRequest()
.post('/users')
.send(user1)
.end(function(err, res) {
expect(res).to.have.status(200);
//expect(res.text).to.have.string('Welcome to');
expect(res.body).to.have.property('_id');
user1._id = res.body._id;
expect(res.body.username).to.equal(user1.username);
done();
});
});
it('GET /users/:id request for user1 ID should user1 from DB', function(done) {
chaiRequest()
.get('/users/' + user1._id)
.end(function(err, res) {
expect(res).to.have.status(200);
expect(res.body._id).to.equal(user1._id);
expect(res.body.username).to.equal(user1.username);
done();
});
});
it('GET /users request should return all users from DB', function(done) {
chaiRequest()
.get('/users')
.end(function(err, res) {
expect(res).to.have.status(200);
expect(res.body.length).to.be.above(0);
done();
});
});
it('GET /users/:id request for INVALID ID should return empty object', function(done) {
chaiRequest()
.get('/users/999999')
.end(function(err, res) {
expect(res.body).to.be.empty;
done();
});
});
// it('PUT /users/:id request for user1 ID should update user1 password in DB', function(done) {
// chaiRequest()
// .put('/users/' + user1._id)
// .send({password: 'NewPassword'})
// .end(function(err, res) {
// console.log(res.redirects);
// expect(res).to.have.status(200);
// expect(res.body._id).to.equal(user1._id);
// expect(res.body.password).to.equal('NewPassword');
// done();
// });
// });
it('DELETE /users/:id should delete user1 from DB', function(done) {
chaiRequest()
.del('/users/' + user1._id)
.end(function(err, res) {
expect(err).to.be.null;
expect(res).to.have.status(200);
expect(res).to.be.json;
expect(res.body.message).to.equal('ID: ' + user1._id + ' deleted from DB');
done();
});
});
});
|
/**
* Clone a copy of the object passed as parameter using JQuery extension
* @param {object} o
* @return {object} copy of the parameter object
*/
function clone(o) {
return jQuery.extend({}, o);
}
function disableZoomHandlers(map) {
map.touchZoom.disable();
map.doubleClickZoom.disable();
map.scrollWheelZoom.disable();
if (map.tap) map.tap.disable();
}
// on('click') => changeColor
function changeColor(e) {
for (var i = 0; i < geoJson.length; i++) {
geoJson[i].properties['marker-color'] =
geoJson[i].properties['old-color'] || geoJson[i].properties['marker-color'];
}
addImages(e);
e.layer.feature.properties['old-color'] = e.layer.feature.properties['marker-color'];
e.layer.feature.properties['marker-color'] = '#ff8888';
myLayer.setGeoJSON(geoJson);
}
// on('click') => centerOnMarker
function centerOnMarker(e) {
goo = clone(e.layer.getLatLng());
goo["lat"] += 3.3;
map.panTo(goo);
}
// map button - onclick => hideQuotes
function hideQuotes() {
$('#quotes').fadeTo(2000, 0.0, function() {
// get focus on the map again
$('#quotes').hide();
});
$('#map').fadeTo(2000, 1.0);
}
// quotes button - onclick => hideQuotes
function showQuotes() {
$('#quotes').fadeTo(2000, 1.0);
$('#map').fadeTo(2000, 0.3);
}
// on('layeradd') => addImages
function addImages(e) {
var marker = e.layer;
var feature = marker.feature;
var images = feature.properties.images
var slideshowContent = '';
for(var i = 0; i < images.length; i++) {
var img = images[i];
slideshowContent +=
'<div class="image' + (i === 0 ? ' active' : '') + '">' +
'<img src="' + img[0] + '" />';
if (img[1]) {
slideshowContent +=
'<div class="caption">' +
img[1] +
'</div>';
}
slideshowContent += '</div>';
}
var popupContent =
'<div id="' + feature.properties.id + '" class="popup">' +
'<h2>' + feature.properties.title + '</h2>' +
'<div class="slideshow">' +
slideshowContent +
'</div>' +
'<div class="cycle">' +
'<a href="#" class="prev">«</a>' +
'<a href="#" class="next">»</a>' +
'</div>'
'</div>';
var popUpOpt = {closeButton: false, minWidth: 320};
marker.bindPopup(popupContent, popUpOpt);
}
// on('ready') => addLines
function addLines() {
var polyline = newLine();
polyline.addTo(map);
myLayer.eachLayer(function(l) {
if (mustDraw(l.feature.properties)) {
polyline.addLatLng(l.getLatLng());
}
});
}
function newLine() {
var lineOpt = {weight: 5, color: "#fff", opacity: 0.7, clickable: false};
return L.polyline([], lineOpt);
}
// draw a line between large markers only
function mustDraw(properties) {
return properties["marker-size"] == "large";
}
// on('click') => createPopUpHTML
function createPopUpHTML() {
var $slideshow = $('.slideshow'),
$newSlide;
if ($(this).hasClass('prev')) {
$newSlide = $slideshow.find('.active').prev();
if ($newSlide.index() < 0) {
$newSlide = $('.image').last();
}
} else {
$newSlide = $slideshow.find('.active').next();
if ($newSlide.index() < 0) {
$newSlide = $('.image').first();
}
}
$slideshow.find('.active').removeClass('active').hide();
$newSlide.addClass('active').show();
return false;
}
/**
* Menu mouse over position
* Stackoverflow: 19618103
* http://jsfiddle.net/ravikumaranantha/Wtfpx/2/
*/
var mouse_position;
var animating = false;
$(document).mousemove(function (e) {
if (animating) {return;}
mouse_position = e.clientX;
if (mouse_position <= 100) {
animating = true;
$('#cms_bar').animate({left: 0, opacity: 0.9}, 200, function () {
animating = false;
});
} else if (mouse_position > 100) {
animating = true;
$('#cms_bar').animate({left: -80, opacity: 0.7}, 500, function () {
animating = false;
});
}
});
|
module("funcunit-syn integration")
test("Type and slow Click", function(){
S.open("//funcunit/test/myapp.html", null, 10000);
S("#typehere").type("javascriptmvc", function(){
equals(S("#seewhatyoutyped").text(), "typed javascriptmvc","typing");
})
S("#copy").click(function(){
equals(S("#seewhatyoutyped").text(), "copied javascriptmvc","copy");
});
})
test("Nested actions", function(){
S.open("//funcunit/test/myapp.html", null, 10000);
S("#typehere").exists(function(){
this.type("javascriptmvc", function(){
equals(S("#seewhatyoutyped").text(), "typed javascriptmvc","typing");
})
S("#copy").click(function(){
equals(S("#seewhatyoutyped").text(), "copied javascriptmvc","copy");
});
})
})
test("Move To", function(){
S.open("//funcunit/test/drag.html", null, 10000);
S("#start").move("#end")
S("#typer").visible().type("javascriptmvc",function(){
equals(S("#typer").val(), "javascriptmvc","move test worked correctly");
})
})
test("Drag To", function(){
S.open("//funcunit/test/drag.html", null, 10000);
S("#drag").drag("#drop")
S("#clicker").click(function(){
equals(S(".status").text(), "dragged", 'drag worked correctly')
})
})
test("RightClick", function(){
S.open("//funcunit/test/myapp.html", null, 10000);
S("#rightclick").rightClick()
S(".rightclickResult").text("Right Clicked")
})
|
frappe.provide("frappe.ui");
frappe.provide("frappe.web_form");
import EventEmitterMixin from '../../frappe/event_emitter';
export default class WebForm extends frappe.ui.FieldGroup {
constructor(opts) {
super();
Object.assign(this, opts);
frappe.web_form = this;
frappe.web_form.events = {};
Object.assign(frappe.web_form.events, EventEmitterMixin);
}
prepare(web_form_doc, doc) {
Object.assign(this, web_form_doc);
this.fields = web_form_doc.web_form_fields;
this.doc = doc;
}
make() {
super.make();
this.set_field_values();
if (this.introduction_text) this.set_form_description(this.introduction_text);
if (this.allow_print && !this.is_new) this.setup_print_button();
if (this.allow_delete && !this.is_new) this.setup_delete_button();
if (this.is_new) this.setup_cancel_button();
this.setup_primary_action();
$(".link-btn").remove();
// webform client script
frappe.init_client_script && frappe.init_client_script();
frappe.web_form.events.trigger('after_load');
this.after_load && this.after_load();
}
on(fieldname, handler) {
let field = this.fields_dict[fieldname];
field.df.change = () => {
handler(field, field.value);
};
}
set_field_values() {
if (this.doc.name) this.set_values(this.doc);
else return;
}
set_default_values() {
let values = frappe.utils.get_query_params();
delete values.new;
this.set_values(values);
}
set_form_description(intro) {
let intro_wrapper = document.getElementById('introduction');
intro_wrapper.innerHTML = intro;
}
add_button(name, type, action, wrapper_class=".web-form-actions") {
const button = document.createElement("button");
button.classList.add("btn", "btn-" + type, "btn-sm", "ml-2");
button.innerHTML = name;
button.onclick = action;
document.querySelector(wrapper_class).appendChild(button);
}
add_button_to_footer(name, type, action) {
this.add_button(name, type, action, '.web-form-footer');
}
add_button_to_header(name, type, action) {
this.add_button(name, type, action, '.web-form-actions');
}
setup_primary_action() {
this.add_button_to_header(this.button_label || "Save", "primary", () =>
this.save()
);
this.add_button_to_footer(this.button_label || "Save", "primary", () =>
this.save()
);
}
setup_cancel_button() {
this.add_button_to_header(__("Cancel"), "light", () => this.cancel());
}
setup_delete_button() {
this.add_button_to_header(
'<i class="fa fa-trash" aria-hidden="true"></i>',
"light",
() => this.delete()
);
}
setup_print_button() {
this.add_button_to_header(
'<i class="fa fa-print" aria-hidden="true"></i>',
"light",
() => this.print()
);
}
save() {
if (this.validate && !this.validate()) {
frappe.throw(__("Couldn't save, please check the data you have entered"), __("Validation Error"));
}
// validation hack: get_values will check for missing data
let doc_values = super.get_values(this.allow_incomplete);
if (!doc_values) return;
if (window.saving) return;
let for_payment = Boolean(this.accept_payment && !this.doc.paid);
Object.assign(this.doc, doc_values);
this.doc.doctype = this.doc_type;
this.doc.web_form_name = this.name;
// Save
window.saving = true;
frappe.form_dirty = false;
frappe.call({
type: "POST",
method: "frappe.website.doctype.web_form.web_form.accept",
args: {
data: this.doc,
web_form: this.name,
docname: this.doc.name,
for_payment
},
callback: response => {
// Check for any exception in response
if (!response.exc) {
// Success
this.handle_success(response.message);
frappe.web_form.events.trigger('after_save');
this.after_save && this.after_save();
}
},
always: function() {
window.saving = false;
}
});
return true;
}
delete() {
frappe.call({
type: "POST",
method: "frappe.website.doctype.web_form.web_form.delete",
args: {
web_form_name: this.name,
docname: this.doc.name
}
});
}
print() {
window.open(`/printview?
doctype=${this.doc_type}
&name=${this.doc.name}
&format=${this.print_format || "Standard"}`, '_blank');
}
cancel() {
window.location.href = window.location.pathname;
}
handle_success(data) {
if (this.accept_payment && !this.doc.paid) {
window.location.href = data;
}
const success_dialog = new frappe.ui.Dialog({
title: __("Saved Successfully"),
secondary_action: () => {
if (this.success_url) {
window.location.href = this.success_url;
} else if(this.login_required) {
window.location.href =
window.location.pathname + "?name=" + data.name;
}
}
});
success_dialog.show();
const success_message =
this.success_message || __("Your information has been submitted");
success_dialog.set_message(success_message);
}
}
|
var asyncplify = require('../dist/asyncplify');
var tests = require('asyncplify-tests');
describe('debounce', function () {
asyncplify
.interval(15)
.debounce(10)
.take(1)
.pipe(tests.itShouldClose())
.pipe(tests.itShouldEndAsync())
.pipe(tests.itShouldEmitValues([0]));
});
|
var http = require("http");
http.createServer(function(request, response) {
response.writeHead(200, {
"Content-Type": "application/json"
});
response.write(JSON.stringify({
"api": "data"
}));
response.end();
}).listen(3000);
|
module.exports = function (ctx, next) {
if (ctx.method === 'GET' && ctx.path === '/ping') {
ctx.body = 'pong'
}
}
|
'use strict';
var yeoman = require('yeoman-generator');
var chalk = require('chalk');
var yosay = require('yosay');
module.exports = yeoman.Base.extend({
prompting: function () {
this.log(yosay(
'Welcome to the ' + chalk.red('generator-react-app-boilerplate') + ' generator!'
));
var prompts = [{
type: 'input',
name: 'name',
message: 'Your project name',
//Defaults to the project's folder name if the input is skipped
default: this.appname
}];
return this.prompt(prompts).then(function (answers) {
this.props = answers;
this.log(answers.name);
}.bind(this));
},
writing: function () {
this.fs.copy(
this.templatePath('app'),
this.destinationPath(this.props.name+'/app')
);
this.fs.copy(
this.templatePath('configs'),
this.destinationPath(this.props.name+'/configs')
);
this.fs.copyTpl(
this.templatePath('_README'),
this.destinationPath(this.props.name+'/README.md'), {
name: this.props.name
}
);
this.fs.copy(
this.templatePath('babelrc'),
this.destinationPath(this.props.name+'/.babelrc')
);
this.fs.copy(
this.templatePath('eslintrc'),
this.destinationPath(this.props.name+'/.eslintrc')
);
this.fs.copy(
this.templatePath('gitignore'),
this.destinationPath(this.props.name+'/.gitignore')
);
this.fs.copyTpl(
this.templatePath('_package.json'),
this.destinationPath(this.props.name+'/package.json'), {
name: this.props.name
}
);
this.fs.copy(
this.templatePath('server.js'),
this.destinationPath(this.props.name+'/server.js')
);
this.fs.copy(
this.templatePath('user.yml.example'),
this.destinationPath(this.props.name+'/user.yml.example')
);
},
install: function () {
var elementDir = process.cwd() + '/' + this.props.name;
process.chdir(elementDir);
var prompts = [{
type: 'confirm',
name: 'install',
message: 'Would you like to enable install Dependencies?',
default: true
}];
return this.prompt(prompts).then(function (props) {
if(props.install){
this.installDependencies();
}
}.bind(this));
},
end: function() {
this.log("All Done!");
},
});
|
/**
* @module ngeo.routing.module
*/
import ngeoRoutingRoutingComponent from 'ngeo/routing/RoutingComponent.js';
import './routing.less';
/**
* @type {angular.Module}
*/
const exports = angular.module('ngeoRoutingModule', [
ngeoRoutingRoutingComponent.module.name
]);
export default exports;
|
const {suite} = require('suitape');
const snakeobj = require('./../index');
suite('snakeobj object', (test) => {
test('Returns same as input if input is not an object', (assert) => {
[1, 'hola', true, new Date()].forEach(input => {
const out = snakeobj(input);
assert('equal', out, input);
});
});
test('Snakeizes single property object', (assert) => {
const input = {lastName: 'last_name'};
const out = snakeobj(input);
Object.keys(out).forEach(key => assert('equal', key, out[key]));
});
test('Snakeizes multiple property object', (assert) => {
const input = {lastName: 'last_name', name: 'name', isFullName: 'is_full_name'};
const out = snakeobj(input);
Object.keys(out).forEach(key => assert('equal', key, out[key]));
});
test('Snakeizes nested objects', (assert) => {
const input = {person: {lastName: 'doe', job: {jobTitle: 'programmer'}}};
const out = snakeobj(input);
assert('equal', out.person.last_name, 'doe');
assert('equal', out.person.job.job_title, 'programmer');
});
test('Snakeizes nested in arrays objects', (assert) => {
const input = {persons: [{lastName: 'doe', job: {jobTitle: 'programmer'}}]};
const out = snakeobj(input);
assert('equal', out.persons[0].last_name, 'doe');
assert('equal', out.persons[0].job.job_title, 'programmer');
});
test('Snakeizes double nested in arrays objects', (assert) => {
const elem = {itemsInArray: [{item: 1}, {item: 2}]};
const elems = [Object.assign({}, elem), Object.assign({}, elem)];
const out = snakeobj({elems});
assert('equal', out.elems[0].items_in_array[0].item, 1);
assert('equal', out.elems[0].items_in_array[1].item, 2);
assert('equal', out.elems[1].items_in_array[0].item, 1);
assert('equal', out.elems[1].items_in_array[1].item, 2);
});
test('Snakeizes nested dot notation objects', (assert) => {
const input = {'person.lastName': 'doe'};
const out = snakeobj(input);
assert('equal', out['person.last_name'], 'doe');
});
test('Snakeizes all but excented keys', (assert) => {
const date = new Date();
const input = {person: {birthDate: {'$gt': date}}};
const out = snakeobj(input, ['$gt']);
assert('equal', out.person.birth_date['$gt'], date);
});
test('Snakeizes all but nested in arrays excented keys', (assert) => {
const date = new Date();
const input = {persons: [{birthDate: {$gt: date}}, {birthDate: {$lt: date}}]};
const out = snakeobj(input, ['$gt', '$lt']);
assert('equal', out.persons[0].birth_date['$gt'], date);
assert('equal', out.persons[1].birth_date['$lt'], date);
});
test('Snakeizes arrays', (assert) => {
const input = [{fooBar: 'baz'}, {hogeKage: 'piyo'}];
const out = snakeobj(input);
assert('equal', out[0].foo_bar, 'baz');
assert('equal', out[1].hoge_kage, 'piyo');
});
});
|
'use strict';var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
switch (arguments.length) {
case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var lang_1 = require('angular2/src/core/facade/lang');
var api_1 = require('angular2/src/core/render/api');
exports.ViewEncapsulation = api_1.ViewEncapsulation;
/**
* Declares the available HTML templates for an application.
*
* Each angular component requires a single `@Component` and at least one `@View` annotation. The
* `@View` annotation specifies the HTML template to use, and lists the directives that are active
* within the template.
*
* When a component is instantiated, the template is loaded into the component's shadow root, and
* the expressions and statements in the template are evaluated against the component.
*
* For details on the `@Component` annotation, see {@link ComponentMetadata}.
*
* ## Example
*
* ```
* @Component({
* selector: 'greet'
* })
* @View({
* template: 'Hello {{name}}!',
* directives: [GreetUser, Bold]
* })
* class Greet {
* name: string;
*
* constructor() {
* this.name = 'World';
* }
* }
* ```
*/
var ViewMetadata = (function () {
function ViewMetadata(_a) {
var _b = _a === void 0 ? {} : _a, templateUrl = _b.templateUrl, template = _b.template, directives = _b.directives, pipes = _b.pipes, encapsulation = _b.encapsulation, styles = _b.styles, styleUrls = _b.styleUrls;
this.templateUrl = templateUrl;
this.template = template;
this.styleUrls = styleUrls;
this.styles = styles;
this.directives = directives;
this.pipes = pipes;
this.encapsulation = encapsulation;
}
ViewMetadata = __decorate([
lang_1.CONST(),
__metadata('design:paramtypes', [Object])
], ViewMetadata);
return ViewMetadata;
})();
exports.ViewMetadata = ViewMetadata;
//# sourceMappingURL=view.js.map
|
document.write('<script src="js/goog/base.js"></script>');
document.write('<script src="js/deps.js"></script>');
document.write("<script>goog.require('AlignShop');</script>");
|
//================================================
// show_reply_thumbnails.js
// Author: @iihoshi
//================================================
(function ($, jn) {
var my_filename = 'show_reply_thumbnails.js';
// プラグイン情報 ここから
// プラグイン情報の初期化
if (!jn.pluginInfo)
jn.pluginInfo = {};
// プラグイン情報本体
jn.pluginInfo[my_filename.split('.')[0]] = {
'name' : {
'ja' : 'リプライサムネイル表示',
'en' : 'Show thumbnails in reply chain'
},
'author' : {
'en' : '@iihoshi'
},
'version' : '1.0.1',
'file' : my_filename,
'language' : ['en', 'ja'],
'last_update' : "2015/9/24",
'update_timezone' : '9',
'jnVersion' : '4.3.1.0',
'description' : {
'ja' : 'リプライにサムネイル画像があれば表示します。',
'en' : 'Shows thumbnails if a tweet in a reply chain has them.'
},
'updateinfo' : 'http://www.colorless-sight.jp/archives/JanetterPluginUpdateInfo.txt'
};
// プラグイン情報ここまで
if ((_Janetter_Window_Type != "main") && (_Janetter_Window_Type != "profile")) {
return;
}
function initForThumbnail() {
var orig_janetterThumbnail = $.fn.janetterThumbnail.toString();
var re_siblings = /_content\.siblings\('div\.tweet-thumb'\);$/m;
var re_find = /_content\.find\('div\.tweet-body /gm;
if (!re_siblings.test(orig_janetterThumbnail) ||
!re_find.test(orig_janetterThumbnail)) {
return false;
}
var replaced = orig_janetterThumbnail
.replace(re_siblings, "_content.children('div.tweet-thumb');")
.replace(re_find, "_content.find('div.tweet-reply-body ");
// console.log(replaced);
eval('$.fn.janetterThumbnailForReply = ' + replaced);
var tnMouseOverHandler = function () {
var $this = $(this),
tweet_reply = $this.parents('div.tweet-reply:first');
$this.unbind('mouseover', tnMouseOverHandler);
if (tweet_reply.length > 0) {
tweet_reply.janetterThumbnailForReply($this.attr('href'));
}
};
$.fn.janetterThumbnailForReplyEventSet = function () {
this.bind('mouseover', tnMouseOverHandler);
return this;
};
return true;
}
function initForExpandUrl() {
var orig_jn_expandUrl = jn.expandUrl.toString();
var re_tweet_content = /div\.tweet-content:first/m;
var re_janetterThumbnail = /\.janetterThumbnail(\W)/gm;
if (!re_tweet_content.test(orig_jn_expandUrl) ||
!re_janetterThumbnail.test(orig_jn_expandUrl)) {
return false;
}
var replaced = orig_jn_expandUrl
.replace(re_tweet_content, 'div.tweet-reply:first')
.replace(re_janetterThumbnail, '.janetterThumbnailForReply$1');
// console.log(replaced);
eval('var expandUrl = ' + replaced);
var euMouseOverHandler = function () {
var $this = $(this);
$this.unbind('mouseover', euMouseOverHandler);
expandUrl($this);
}
$.fn.janetterExpandUrlForReplyEventSet = function () {
this.bind('mouseover', euMouseOverHandler);
return this;
}
return true;
}
// 本プラグインの初期化処理（onInitializeDone 時）
function initOnInitialized() {
if (!initForThumbnail() || !initForExpandUrl()) {
new jn.msgdialog({
title: my_filename,
icon: '',
message: 'Sorry, ' + my_filename+ ' cannot be installed.',
buttons: [ janet.msg.ok ],
});
return;
}
var orig_generateReply = jn.generateReply;
jn.generateReply = function (item, is_default) {
var reply = orig_generateReply(item, is_default);
reply.append('<div class="tweet-thumb"/>');
var a = reply.find('.tweet-reply-body > p.text').children('a.link');
a.janetterExpandUrlForReplyEventSet();
if (jn.conf.disp_thumbnail == 'over')
a.janetterThumbnailForReplyEventSet();
else
reply.janetterThumbnailForReply(a);
return reply;
};
console.log(my_filename + ' has been initialized.');
}
if (jn.temp.initialized) {
// The original onInitializeDone() has already been called!
initOnInitialized();
} else {
var orig_onInitializeDone = jn.onInitializeDone;
jn.onInitializeDone = function () {
orig_onInitializeDone && orig_onInitializeDone.apply(this, arguments);
initOnInitialized();
};
}
})(jQuery, janet);
|
/**
* a tabbed pane based on a definition list
*/
var openmdao = (typeof openmdao === "undefined" || !openmdao ) ? {} : openmdao ;
openmdao.TabbedPane = function(id) {
jQuery("#"+id+" dl").css({
'margin': '0',
'width': '100%',
'position': 'relative'
});
jQuery("#"+id+" dt").css({
'top':'0',
'margin': '0',
'position': 'relative',
'float': 'left',
'display': 'block',
'width': '75px',
'height': '20px',
'text-align': 'center',
'border': '1px solid #222',
'background-color':'#6a6a6a',
'color': 'white',
'font-size': '14px'
});
jQuery("#"+id+" dd").css({
'margin': '0',
'position': 'absolute',
'left': '0',
'top': '25px',
'height': '100%',
'width': '100%',
'min-height': '400px',
'overflow' : 'auto'
});
jQuery("#"+id+" dd").hide();
jQuery("#"+id+" dt").click(function() {
var tgt = jQuery(this).attr("target");
jQuery("#"+id+" dd:visible").hide();
jQuery("#"+id+" dt.tab_here").removeClass("tab_here");
jQuery("#"+tgt).show();
jQuery(this).addClass("tab_here");
});
};
|
var mouseMoveControl = true;
function initializeChoropleth(data) {
var map = L.map('map2', {
center: [40, -120],
zoom: 4
})
createTileLayer(map)
var dataLayer = setEnumerationUnits(map, dataLayer, data)
return {
map: map,
dataLayer: dataLayer
// projection:projection,
// path:path,
}
}
function createTileLayer(map) {
var mapboxAccessToken = "pk.eyJ1IjoiY2F0aGVyaW5lc3RyZWlmZmVyIiwiYSI6ImNpa3BrOTVlaTEyNmZ0aWo3eDlyaThraGMifQ.bYUxm5s4cRD2iRGqvpNNBA"
L.tileLayer('https://api.tiles.mapbox.com/v4/{id}/{z}/{x}/{y}.png?access_token=' + mapboxAccessToken, {
id: 'mapbox.light',
attribution: '© <a href="http://mapbox.com/">Mapbox</a>; data source: Census Bureau'
}).addTo(map);
}
function setEnumerationUnits(map, dataLayer, data) {
var dataLayer = L.geoJson(data, {
className: "counties",
onEachFeature: function(feature, layer) {
layer.bindPopup(feature.properties.NAME + " County");
layer.on('mouseover', function(e) {
this.openPopup();
});
layer.on('mouseout', function(e) {
//this.closePopup();
});
}
}).addTo(map)
/*
//selection
var RADIUS = 500000;
var filterCircle = L.circle(L.latLng(40, -75), RADIUS, {
opacity: 1,
weight: 1,
fillOpacity: 0
}).addTo(map);
map.on('mousemove', function(e) {
filterCircle.setLatLng(e.latlng);
dataLayer.filter(function showAirport(feature) {
return e.latlng.distanceTo(L.latLng(
feature.geometry.coordinates[1],
feature.geometry.coordinates[0])) < RADIUS;
});
});
*/
dataLayer.setStyle(function(feature) {
return {
weight: .1,
color: 'black',
dashArray: '3',
opacity: 1,
fillOpacity: .7,
}
})
//var counties = map.selectAll()
// .attr("class","counties")
// .attr("fips", function(d){
// return d.properties.FIPS;
// })
// .attr("d", path)
// .style("fill", function(d){
// return choropleth(d.properties, bivariates);
// })
//add style descriptor to each path
//var desc = counties.append("desc")
// .text('{"stroke": "#000", "stroke-width": "0.5px"}');
return dataLayer
};
function updateChoropleth(choropleth, xTitle, yTitle, FIPSxData, xCol, FIPSyData, yCol, year, bivariate) {
errorControl01 = true;
colors = {}
colors[[-1, 1]] = window.getComputedStyle(document.getElementById("A1")).fill
colors[[0, 1]] = window.getComputedStyle(document.getElementById("B1")).fill
colors[[1, 1]] = window.getComputedStyle(document.getElementById("C1")).fill
colors[[-1, 0]] = window.getComputedStyle(document.getElementById("A2")).fill
colors[[0, 0]] = window.getComputedStyle(document.getElementById("B2")).fill
colors[[1, 0]] = window.getComputedStyle(document.getElementById("C2")).fill
colors[[-1, -1]] = window.getComputedStyle(document.getElementById("A3")).fill
colors[[0, -1]] = window.getComputedStyle(document.getElementById("B3")).fill
colors[[1, -1]] = window.getComputedStyle(document.getElementById("C3")).fill
choropleth.dataLayer.eachLayer(function(layer) {
xVal = FIPSxData[layer.feature.properties.FIPS]
yVal = FIPSyData[layer.feature.properties.FIPS]
lookupXCoord = -1 + (xVal >= xQuantile01) + (xVal >= xQuantile02)
lookupYCoord = -1 + (yVal >= yQuantile01) + (yVal >= yQuantile02)
layer.setStyle({
fillColor: colors[[lookupXCoord, lookupYCoord]]
});
layer.bindPopup(
"<p>"+layer.feature.properties.NAME + " County" + "</p><p>" + xTitle + ": " + xVal + "</p><p>" + yTitle + ": " + yVal + "</p> ");
})
}
|
/*
* To change this tealias: 'widget.listCompressorStopReason',mplate, choose Tools | Templates
* and open the template in the editor.
*/
Ext.define('sisprod.view.CompressorStopReason.ListCompressorStopReason', {
extend: 'sisprod.view.base.TabPanelGridItem',
alias: 'widget.listCompressorStopReason',
require: [
'sisprod.view.base.TabPanelGridItem'
],
options: {},
messages:{
idCompressorStopReasonHeader:"ID",
compressorStopReasonNameHeader:"Compressor Stop Reason",
compressorStopReasonAcronymHeader:"Acronym",
discountedHeader:"Is Discounted"
},
entityName: '',
title: '',
listTitle: 'Compressor Stop Reason List',
gridOptions: {
region: 'center'
},
initComponent: function(){
var me = this;
var storeName = sisprod.getApplication().getStoreName(me.entityName);
var modelName = sisprod.getApplication().getModelName(me.entityName);
me.gridOptions = {
title: me.listTitle,
entityName: me.entityName,
autoGenerationOptions:{
model: modelName,
autoGenerateColumns: true,
columnOptions: {
idCompressorStopReason:{header:me.messages.idCompressorStopReasonHeader},
compressorStopReasonName:{header:me.messages.compressorStopReasonNameHeader},
compressorStopReasonAcronym:{header:me.messages.compressorStopReasonAcronymHeader},
discounted:{header:me.messages.discountedHeader}
}
},
region: 'center',
store: me.controller.getStore(storeName)
};
me.callParent(arguments);
}
});
|
'use strict';
var seleniumServerJar =
'/usr/local/lib/node_modules/protractor' +
'/selenium/selenium-server-standalone-2.41.0.jar';
// A reference configuration file.
exports.config = {
// ----- How to setup Selenium -----
//
// There are three ways to specify how to use Selenium. Specify one of the
// following:
//
// 1. seleniumServerJar - to start Selenium Standalone locally.
// 2. seleniumAddress - to connect to a Selenium server which is already
// running.
// 3. sauceUser/sauceKey - to use remote Selenium servers via SauceLabs.
//
// If the chromeOnly option is specified, no Selenium server will be started,
// and chromeDriver will be used directly (from the location specified in
// chromeDriver)
// The location of the selenium standalone server .jar file, relative
// to the location of this config. If no other method of starting selenium
// is found, this will default to
// node_modules/protractor/selenium/selenium-server...
seleniumServerJar: seleniumServerJar,
// The port to start the selenium server on, or null if the server should
// find its own unused port.
seleniumPort: null,
// Chromedriver location is used to help the selenium standalone server
// find chromedriver. This will be passed to the selenium jar as
// the system property webdriver.chrome.driver. If null, selenium will
// attempt to find chromedriver using PATH.
chromeDriver: './selenium/chromedriver',
// If true, only chromedriver will be started, not a standalone selenium.
// Tests for browsers other than chrome will not run.
chromeOnly: false,
// Additional command line options to pass to selenium. For example,
// if you need to change the browser timeout, use
// seleniumArgs: ['-browserTimeout=60'],
seleniumArgs: [],
// The address of a running selenium server. If specified, Protractor will
// connect to an already running instance of selenium. This usually looks like
// seleniumAddress: 'http://localhost:4444/wd/hub'
seleniumAddress: null,
// The timeout for each script run on the browser. This should be longer
// than the maximum time your application needs to stabilize between tasks.
allScriptsTimeout: 11000,
// ----- What tests to run -----
//
// Spec patterns are relative to the location of this config.
specs: [
'test/e2e/*-spec.js'
],
// Patterns to exclude.
exclude: [],
// ----- Capabilities to be passed to the webdriver instance ----
//
// For a full list of available capabilities, see
// https://code.google.com/p/selenium/wiki/DesiredCapabilities and
// https://code.google.com/p/selenium/source/browse/javascript/
// webdriver/capabilities.js
capabilities: {
'browserName': 'chrome'
},
// If you would like to run more than one instance of webdriver on the same
// tests, use multiCapabilities, which takes an array of capabilities.
// If this is specified, capabilities will be ignored.
multiCapabilities: [],
// ----- More information for your tests ----
//
// A base URL for your application under test. Calls to protractor.get()
// with relative paths will be prepended with this.
//baseUrl: 'http://localhost:3000',
baseUrl: 'http://localhost:3000',
// Selector for the element housing the angular app - this defaults to
// body, but is necessary if ng-app is on a descendant of <body>
rootElement: 'body',
// A callback function called once protractor is ready and available, and
// before the specs are executed
// You can specify a file containing code to run by setting onPrepare to
// the filename string.
onPrepare: function() {
// At this point, global 'protractor' object will be set up, and jasmine
// will be available. For example, you can add a Jasmine reporter with:
// jasmine.getEnv().addReporter(new jasmine.JUnitXmlReporter(
// 'outputdir/', true, true));
},
// ----- The test framework -----
//
// Jasmine and Cucumber are fully supported as a test and assertion framework.
// Mocha has limited beta support. You will need to include your own
// assertion framework if working with mocha.
framework: 'jasmine',
// ----- Options to be passed to minijasminenode -----
//
// See the full list at https://github.com/juliemr/minijasminenode
jasmineNodeOpts: {
// onComplete will be called just before the driver quits.
onComplete: null,
// If true, display spec names.
isVerbose: false,
// If true, print colors to the terminal.
showColors: true,
// If true, include stack traces in failures.
includeStackTrace: true,
// Default time to wait in ms before a test fails.
defaultTimeoutInterval: 30000
}
};
|
const path = require('path')
const HtmlWebpackPlugin = require('html-webpack-plugin')
module.exports = {
context: path.resolve(__dirname, '../src'),
entry: './index.js',
output: {
path: path.resolve(__dirname, '../dist'),
filename: 'index.js'
},
module: {
rules: [
{
test: /\.san$/,
use: 'san-loader'
},
{
test: /\.js$/,
use: 'babel-loader',
exclude: /node_modules/
},
{
test: /\.css$/,
use: ['style-loader', 'css-loader']
},
{
test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,
use: 'url-loader'
},
{
test: /\.(woff2?|eot|ttf)(\?.*)?$/,
use: 'url-loader'
}
]
},
resolve: {
alias: {
'@': path.resolve(__dirname, '../src')
}
},
plugins: [
new HtmlWebpackPlugin({
template: path.resolve(__dirname, '../src/template.html')
})
]
}
|
var install = function () {
var step = $('body').find('[data-step]').first();
var progress = $('.progress');
var label = $('#label');
label.text(step.data('step'));
$.ajax({
url: step.data('action'),
success: function () {
step.remove();
if ($('body').find('[data-step]').length) {
progress.attr('value', step.data('progress'));
install();
} else {
progress.attr('value', '100');
label.text('Almost done...');
window.location = APPLICATION_URL + '/installer/finish'
}
},
error: function () {
progress.addClass('progress-danger');
label.addClass('text-danger').text('There was an error. Please check your error logs.');
}
});
};
$(document).ready(function () {
install();
});
;
|
import { BINARY_COLOR_SAND_90 } from 'binary-ui-styles';
import styled from 'styled-components/native';
export default styled.View`
align-items: center;
border-bottom-color: ${BINARY_COLOR_SAND_90};
border-bottom-width: 1px;
height: 50px;
justify-content: center;
overflow: hidden;
width: 100%;
`;
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var chai = require("chai");
var Q = require("q");
var Defer = require("ts-promises/Defer");
var Tasks = require("../task/Tasks");
var TaskSet = require("../task/TaskSet");
var asr = chai.assert;
suite("TaskSet", function TaskSetTest() {
function createTaskRes1(res) {
return Q.resolve(res);
}
function createTaskRes2(res, waitMillis) {
var dfd = Q.defer();
setTimeout(function () { return dfd.resolve(res); }, waitMillis);
return dfd.promise;
}
function createTaskErr1(res) {
return Q.reject(res);
}
function createTaskErr2(res, waitMillis) {
var dfd = Q.defer();
setTimeout(function () { return dfd.reject(res); }, waitMillis);
return dfd.promise;
}
function startTasks(taskSet, namePrefix, resMsgPrefix, count) {
var tasks = [];
for (var i = 0; i < count; i++) {
var rr = Math.random() < 0.5 ? createTaskRes1(resMsgPrefix + i) : createTaskRes2(resMsgPrefix + i, Math.round(Math.random() * 10));
var t = taskSet.startTask(namePrefix + i, rr);
tasks.push(t);
}
return tasks;
}
test("README-example", function README_exampleTest(done) {
var taskSet = new TaskSet(null, function (name) { return console.log("success:", name); }, function (name) { return console.log("failure:", name); });
taskSet.startTask("task-1", Tasks.startTask("a", createTaskRes1("result a")).getPromise());
taskSet.startTask("task-2", createTaskRes1("result b"));
taskSet.startTask("task-3", createTaskRes1("error c"));
Q.all(taskSet.getPromises())
.then(function (results) { console.log("done:", results); done(); }, function (err) { console.error("error:", err); done(); });
});
test("task-set-function-and-promise-task-mix", function taskSetFunctionAndPromiseTaskMixTest(done) {
var taskSet = new TaskSet(null, null, null);
taskSet.startTask("task-1", createTaskRes1("result a"));
taskSet.startTask("task-2", Tasks.startTask("b", createTaskRes1("result b")).getPromise());
taskSet.startTask("task-3", createTaskRes1("result c"));
taskSet.startTask("task-4", createTaskErr1("error d"));
asr.equal(taskSet.getTasks().size, 4);
asr.equal(taskSet.getPromises().length, taskSet.getTasks().size);
Q.all(taskSet.getPromises()).done(function (results) {
done("unexpected success");
}, function (err) {
Q.all(taskSet.getPromises()).done(function (results) {
var allResults = taskSet.getCompletedTasks().map(function (t) { return t.task.getResult(); });
asr.deepEqual(allResults.sort(), ["result a", "result b", "result c"]);
asr.equal(err, "error d");
done();
}, function (err2) {
done("unexpected 2nd error");
});
});
});
test("task-set-success", function taskSetSuccessTest(done) {
// test success
var taskSet = new TaskSet();
var task1 = taskSet.startTask("task-res-1", createTaskRes1("success-1"));
var task2 = taskSet.startTask("task-res-2", createTaskRes2("success-2", 10));
Defer.when(taskSet.getPromises()).then(function (res) {
asr.deepEqual(res.sort(), ["success-1", "success-2"]);
asr.equal(task1.getResult(), "success-1");
asr.equal(task1.state, "COMPLETED");
asr.equal(task2.getResult(), "success-2");
asr.equal(task2.state, "COMPLETED");
done();
}, function (err) {
done("unexpected error");
});
});
test("task-set-failure", function taskSetFailureTest(done) {
// test success
var taskSet = new TaskSet();
var task1 = taskSet.startTask("task-res-1", createTaskRes1("success-1"));
var task2 = taskSet.startTask("task-res-2", createTaskRes2("success-2", 10));
var task3 = taskSet.startTask("task-err-1", createTaskErr1("error-1"));
var task4 = taskSet.startTask("task-err-2", createTaskErr2("error-2", 10));
Defer.when(taskSet.getPromises()).then(function (res) {
done("unexpected success");
}, function (err) {
asr.isTrue(err == "error-1" || err == "error-2");
done();
});
});
test("task-drop-completed", function taskSetDropCompleted(done) {
var taskSet = new TaskSet();
// test 4 tasks, limit 3, drop 25%
taskSet.maxCompletedTasks = 3;
taskSet.dropCompletedTasksPercentage = 0.25;
startTasks(taskSet, "task-res-", "success-", 4);
Defer.when(taskSet.getPromises()).then(function (res) {
asr.equal(taskSet.getCompletedTasks().length, 2);
taskSet.clearCompletedTasks();
}).then(function () {
// test 6 tasks, limit 5, drop 60%
taskSet.maxCompletedTasks = 5;
taskSet.dropCompletedTasksPercentage = 0.6;
startTasks(taskSet, "task-res-", "success-", 6);
return Defer.when(taskSet.getPromises());
}).then(function (res) {
asr.equal(taskSet.getCompletedTasks().length, 2);
taskSet.clearCompletedTasks();
done();
}, function (err) {
done("unexpected error");
});
});
});
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.