text
stringlengths 2
6.14k
|
|---|
// Copyright (c) 2012 Ecma International. All rights reserved.
// Ecma International makes this code available under the terms and conditions set
// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the
// "Use Terms"). Any redistribution of this code must retain the above
// copyright and this notice and otherwise comply with the Use Terms.
/*---
es5id: 15.2.3.5-4-134
description: >
Object.create - 'configurable' property of one property in
'Properties' is a negative number (8.10.5 step 4.b)
includes: [runTestCase.js]
---*/
function testcase() {
var newObj = Object.create({}, {
prop: {
configurable: -123
}
});
var beforeDeleted = newObj.hasOwnProperty("prop");
delete newObj.prop;
var afterDeleted = newObj.hasOwnProperty("prop");
return beforeDeleted === true && afterDeleted === false;
}
runTestCase(testcase);
|
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
//Schema Definition
var solarSystemSchema = new Schema({
_id: Number,
name: String,
imgUrl: String
});
//Expose (export) the model
module.exports = mongoose.model('SolarSystem', solarSystemSchema);
|
'use strict';
import '../../util/polyfill.js';
import expect from 'expect';
import subject from '../subject';
// ***
// *** all subjects tests ...
// ***
describe('subject tests', () => {
describe('academicGroups() tests', () => {
it('Array Check', () => {
expect(subject.academicGroups())
.toBeA('array');
});
it('Expected academicGroup: Engineering', () => {
expect(subject.academicGroups())
.toInclude('Engineering');
});
});
describe('academicGroupExists() tests', () => {
it('NON-EXIST-GROUP', () => {
expect(subject.academicGroupExists('NON-EXIST-GROUP'))
.toEqual(false);
});
it('Expected Group: Engineering', () => {
expect(subject.academicGroupExists('Engineering'))
.toEqual(true);
});
});
describe('academicGroupForSubject() tests', () => {
it('Bad Subject', () => {
expect( () => { subject.academicGroupForSubject('NON-EXIST-SUBJ') })
.toThrow(/non-existent subject/);
});
it('Expected Group', () => {
expect(subject.academicGroupForSubject('CS'))
.toEqual('Engineering');
});
it('Non Expected Group', () => {
expect(subject.academicGroupForSubject('MUSIC'))
.toNotEqual('Engineering');
});
});
describe('subjects() tests', () => {
it('Array Check', () => {
expect(subject.subjects())
.toBeA('array');
});
it('Expected subject: CS', () => {
expect(subject.subjects())
.toInclude('CS');
});
});
describe('subjectExists() tests', () => {
it('NON-EXIST-SUBJ', () => {
expect(subject.subjectExists('NON-EXIST-SUBJ'))
.toEqual(false);
});
it('Expected Subject: CS', () => {
expect(subject.subjectExists('CS'))
.toEqual(true);
});
});
describe('subjectsForAcademicGroup() tests', () => {
it('Bad Group', () => {
expect( () => { subject.subjectsForAcademicGroup('NON-EXIST-GROUP') })
.toThrow(/non-existent academicGroup/);
});
it('Expected Subject', () => {
expect(subject.subjectsForAcademicGroup('Engineering'))
.toInclude('CS');
});
it('Non Expected Subject', () => {
expect(subject.subjectsForAcademicGroup('Engineering'))
.toExclude('MUSIC');
});
});
});
|
var express = require('express');
var date = require('date.js');
var Timeline = require('pebble-api');
var app = express();
app.set('port', (process.env.PORT || 5000));
// create a new Timeline object with our API key keys passed as an enviornment variable
var timeline = new Timeline({
apiKey: process.env.PEBBLE_TIMELINE_API_KEY
});
var topic = 'GameOfThrones';
var currentPeopleWatching = 0;
// create the pin
var pin = new Timeline.Pin({
id: topic + '-S05E00',
time: date('tomorrow at 9pm'),
layout: new Timeline.Pin.Layout({
type: Timeline.Pin.LayoutType.GENERIC_PIN,
tinyIcon: Timeline.Pin.Icon.PIN,
title: 'Game of Thrones',
body: 'People currently watching: ' + currentPeopleWatching
})
});
// add actions to the pin
pin.addAction(new Timeline.Pin.Action({
type: Timeline.Pin.ActionType.OPEN_WATCH_APP,
title: 'Start Watching',
launchCode: 1
})).addAction(new Timeline.Pin.Action({
type: Timeline.Pin.ActionType.OPEN_WATCH_APP,
title: 'Stop Watching',
launchCode: 2
}));
// handler for GET /
app.get('/', function (req, res) {
res.send('People currently watching: ' + currentPeopleWatching);
});
// handler for GET /:topic/start
app.get('/:topic/start', function (req, res, next) {
// increment currentPeopleWatching
currentPeopleWatching++;
// once done, continue to next handler so we don't duplicate code
next();
});
// handler for GET /:topic/stop
app.get('/:topic/stop', function (req, res, next) {
// decrement currentPeopleWatching but not less than 0
currentPeopleWatching--;
if (currentPeopleWatching < 0) {
currentPeopleWatching = 0;
}
// once done, continue to next handler so we don't duplicate code
next();
});
// handler for /:topic/*
app.get('/:topic/*', function (req, res) {
// update the pin time
pin.time = date('tomorrow at 9pm');
// update the pin body
pin.layout.body = 'People currently watching: ' + currentPeopleWatching;
// send the pin to everyone subscribed to it
timeline.sendSharedPin([topic], pin, function (err, body, resp) {
if (err) {
return console.error(err);
}
res.send('Status code: ' + resp.statusCode);
});
});
// start the webserver
var server = app.listen(app.get('port'), function () {
console.log('timeline-tv-tracker example app listening on port %s', app.get('port'));
});
|
/* global slug */
import { helper } from 'ember-helper'
export function stringToSlug(string, options) {
return slug(string, Object.assign({ lower: true }, options))
}
export default helper(stringToSlug)
|
// This is a manifest file that'll be compiled into application.js, which will include all the files
// listed below.
//
// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
//
// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
// compiled file.
//
// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
// about supported directives.
//
// app/assets/javascripts/application.js
//
//= require jquery
//= require jquery_ujs
//= require turbolinks
//= require bootstrap-sprockets
//= require d3
//= require_tree .
|
(function (Service, Persister, Adapter, Entity, Util) {
// Set the object namespace
Service.GetOrganizationsRepositories = {};
/**
* Function to combine an undefined list of repositories into a single array
* @return Entity.Repository[] List of repositories
*/
function combineRepositories(/* args */)
{
var repositories = [];
for (var i in arguments) {
repositories = repositories.concat(arguments[i]);
}
return repositories;
}
/**
* Function to load all the repositories from all the subscribed organizations
* @param Entity.Organization[] organizations List of organizations
* @param Entity.Account account Account to get the repositories
* @return Util.Promise Promise object
*/
function loadRepositories(organizations, account)
{
var promises = [];
organizations.forEach(function (organization) {
promises.push(Adapter.Repositories.findByOrganizationAndAccount(organization, account));
});
return promises.getCombinedPromise()
.done(combineRepositories)
;
}
/**
* Function to get a list of repositories
* @param Entity.Account account Account to get the repositories from
* @return Util.Promise Promise object
*/
Service.GetOrganizationsRepositories.findByAccount = function (account)
{
return Adapter.Organizations.findByAccount(account)
.done(function (organizations) {
return loadRepositories(organizations, account);
})
;
};
})(window.Service = window.Service || {}, window.Persister, window.Adapter, window.Entity, window.Util);
|
$(document).ready(function(){
var board = [[0,0,0],[0,0,0],[0,0,0]];
var currentPlayer = "Red";
var finish = false;
$(".cell").click(function(){
var position = $(this).data("position").toString();
var xPos = position[0];
var yPos = position[1];
if(finish){
board = [[0,0,0],[0,0,0],[0,0,0]];
$(".cell").removeClass("Red Green");
finish = false;
$('#status').html(currentPlayer+" 's turn.");
}else{
//If selected square is already taken, display error message
if($(this).hasClass('Red') || $(this).hasClass('Green')){
$('#status').html("Square already taken. Choose another square. Still "+currentPlayer+" 's turn.");
}else{
//Change selected square to current player
board[xPos][yPos] = currentPlayer;
$(this).addClass(currentPlayer);
//Check winning conditions
//Check Row
if(board[0][yPos] === board[1][yPos] && board[1][yPos] === board[2][yPos]){
finish = true;
}
//Check Column
else if(board[xPos][0] === board[xPos][1] && board[xPos][1] === board[xPos][2]){
finish = true;
}
//Check Diagonals
else if(board[1][1] === currentPlayer){
if(board[0][0] === board[1][1] && board[1][1] === board[2][2]){
finish = true;
}
else if(board[0][2] === board[1][1] && board[1][1] === board[2][0]){
finish = true;
}
}
//Check to see if draw and reset if draw
var draw = true;
for(var i=0; i<3; i++){
for(var j=0; j<3; j++){
if(board[i][j] == 0){
draw = false;
break;
}
}
}
if(draw){
$('#status').html("It's a draw! Click on the board to play again.");
finish = true;
}else{
if(finish){
//If player won, display message
$('#status').html(currentPlayer+" Won! Click on board to play again.");
}else{
//Change to next player and display message
if(currentPlayer==="Red"){
currentPlayer = "Green";
}else{
currentPlayer = "Red";
}
$('#status').html(currentPlayer+" 's turn.");
}
}
}
}
});
});
|
'use strict';
var should = require('should'),
nsmockup = require('../../');
var base = __dirname + '/../_input-files';
/**
* Test Suites
*/
describe('<Unit Test - Netsuite Bundle Script>', function () {
this.timeout(5000);
before(done => {
nsmockup.init(done);
});
describe('SuiteScript - nlapiScheduleScript', () => {
it('bundle-script execute', done => {
nsmockup.createSchedule({
id: 'customscript_my_schedule',
files: [
[`${base}/scripts/my-require.js`, 'MockVarFake']
],
function: 'MockVarFake.legal',
exec: true
}, (context) => {
should(context.MockVarFake).be.ok();
return done();
});
});
});
after(done => {
nsmockup.destroy(done);
});
});
|
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
var fs = require('fs');
var path = require('path');
var shell = require('shelljs/global');
exports.execute = function (ctx, callback) {
//Verify ant is installed correctly
var antPath = which('ant');
if (!antPath) {
callback(new Error('Unable to find Ant. Verify it is installed correctly on the build agent: http://ant.apache.org/manual/install.html.'));
return;
}
ctx.verbose('Found Ant at: ' + antPath);
//Verify Ant build file is specified
var antBuildFile = ctx.inputs.antBuildFile;
if (!fs.existsSync(antBuildFile) || !fs.statSync(antBuildFile).isFile()) {
callback(new Error('Ant build file ' + antBuildFile + ' does not exist or is not a valid file'));
return;
}
ctx.verbose('Ant build file: ' + antBuildFile);
//Find Working directory to run Ant in. cwd is optional, we use directory of Ant build file as Working directory if not set.
var cwd = ctx.inputs.cwd;
if (!cwd || cwd.length == 0)
{
cwd = path.dirname(antBuildFile);
}
if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
callback(new Error('Working directory ' + cwd + ' does not exist or is not a valid directory'));
return;
}
cd(cwd);
ctx.verbose('Working directory: ' + cwd);
var antArguments = [];
antArguments = antArguments.concat("-buildfile");
antArguments = antArguments.concat(antBuildFile);
// options and targets are optional
var options = ctx.inputs.options;
if (options && options.length > 0) {
var optionsArgs = ctx.util.argStringToArray(options);
antArguments = antArguments.concat(optionsArgs);
}
var targets = ctx.inputs.targets;
if (targets && targets.length > 0) {
var targetsArgs = ctx.util.argStringToArray(targets);
antArguments = antArguments.concat(targetsArgs);
}
ctx.verbose("Ant arguments: " + antArguments.toString());
var ops = {
cwd: path.resolve(cwd),
env: process.env
};
// calling spawn instead of fork so we can easily capture output --> logs
ctx.info('Running Ant: ');
ctx.util.spawn(antPath, antArguments, ops, callback);
}
|
import template from './home.html';
export let HomeComponent = {
templateUrl: template,
selector: 'home',
bindings: {},
/* @ngInject */
controller: class HomeCtrl {
/* @ngInject */
constructor($state) {
// TODO - constructor arguments that should be available on "this"
// should be added to the assign object
Object.assign(this, { $state });
this.title = 'SuperNova';
this.note = 'Angular 1.5x, Es6, Karma, Jasmine & Webpack, ui-router';
}
}
};
|
/*
Copyright (c) 2003-2016, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'selectall', 'en-gb', {
toolbar: 'Select All'
} );
|
module.exports = {
root: true,
parser: '@typescript-eslint/parser',
parserOptions: {
ecmaVersion: 2018,
sourceType: 'module'
},
extends: [
'plugin:@typescript-eslint/recommended',
'prettier/@typescript-eslint',
'plugin:prettier/recommended'
],
env: {
browser: true
},
rules: {
'@typescript-eslint/no-use-before-define': ['off'],
'@typescript-eslint/explicit-function-return-type': ['off'],
'@typescript-eslint/explicit-member-accessibility': ['off'],
'@typescript-eslint/no-explicit-any': ['off'],
'@typescript-eslint/no-empty-function': ['off'],
'prefer-const': ['off'],
'prefer-spread': ['off']
},
overrides: [{
files: ['test/**/*.ts'],
rules: {
'@typescript-eslint/no-unused-vars': ['off']
}
}]
};
|
/**
* @type Header
* @description Header object for the request
* @param {String} name - name of the header
* @param {String} value - value of the header
*/
/**
* @name post
* @description Wrapper around the post object
* @param {Object} options - options for the request
* @param {String} options.url - url for the request
* @param {String} options.type - type of the request
* @param {Object} options.params - JSON for the post params
* @param {Array<Header>} options.headers - Array of headers for the request
* @return {Promise}
*/
export default function ({ url, type, params, headers }) {
return new Promise((resolve, reject) => {
const request = new XMLHttpRequest();
request.open(type, url, true);
//- Add optional headers if any
if (headers) {
headers.forEach(({ name, value }) => request.setRequestHeader(name, value));
}
//- Format params
const parameters = Object.keys(params).map(key => `${key}=${params[key]}`).join('&');
//- Add some handlers
request.onload = () => {
const handler = request.status === 200 ? resolve : reject;
// Safely parse JSON
try {
const response = JSON.parse(request.responseText);
handler(response);
} catch (err) {
reject(new Error('Invalid response'));
}
};
request.onerror = reject;
request.send(parameters);
});
}
|
/**
*
* This ProjectController module uses RequireJS to `define` a AngularJS constructor function
* with its dependencies.
*
* @author Joel Ray
* @date June, 2015
*/
(function( define ) {
"use strict";
/**
* Register the ProjectController class with RequireJS
*/
define( [ ], function ( ) {
/**
* Constructor function used by AngularJS to create instances of
* a service, factory, or controller.
*
* @constructor
*/
var ProjectController = function( $scope, $stateParams, $log, ProjectsService ) {
// INSTANCES
var _self = {};
// ==================================================================================================
// CONSTRUCTOR --------------------------------------------------------------------------------------
(function() {
$log = $log.getInstance( "ProjectController" );
$log.debug( "constructor() ");
var projectId = $stateParams['id'];
console.log('projectId ::', projectId);
// TODO: Validate project id, false returns should throw 404 errors
$scope.title = ProjectsService.getPageTitleByProjectID(projectId);
$scope.$parent.active = 'work-single-active';
})()
// ==================================================================================================
// PUBLIC INTERFACE ---------------------------------------------------------------------------------
_self.animateIn = function() {
console.log('animateIn()');
}
_self.animateOut = function() {
console.log('animateOut()');
}
// ==================================================================================================
// INTERNAL INTERFACE -------------------------------------------------------------------------------
// Return Public API
return _self;
};
// Register as global constructor function
return [ "$scope", "$stateParams", "$log", "ProjectsService", ProjectController ];
});
}( define ));
|
'use strict';
var dispatcher = require('../dispatcher/dispatcher');
var EventEmitter = require('events').EventEmitter;
var ObjectAssign = require('object-assign');
var actionConstants = require('../constants/actionConstants');
var _store = {
list: [],
error: [],
genres: [],
playlists: [],
playlist: []
}
var resultErrors = null;
var CHANGE_EVENT = 'change';
var SearchStore = ObjectAssign( {}, EventEmitter.prototype, {
getTrending: function() {
return _store;
},
getError: function() {
return _store;
},
addChangeListener: function(callback){
this.on(CHANGE_EVENT, callback);
},
removeListener: function(callback) {
this.removeListener(CHANGE_EVENT, callback);
},
getGenres: function() {
return _store;
},
getPlaylists: function() {
return _store;
},
getPlaylist: function(){
return _store;
}
});
dispatcher.register(function(action){
switch (action.actionType) {
/*case actionConstants.GET_TRENDING:
SearchStore.emit(actionConstants.GET_TRENDING);
break;*/
case actionConstants.TRENDING_RESULT:
action.results.map(function(item){
_store.list.push(item);
});
resultErrors = null;
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.SEARCH_RESULT:
_store.list = [];
action.results.map(function(item){
_store.list.push(item);
});
resultErrors = null;
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.ERROR:
results = null;
_store.error.push(action.error);
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.ADD_GENRE:
_store.genres.push(action.index);
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.REMOVE_GENRE:
_store.genres = _store.genres.filter(function(index){
return index !== action.index;
});
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.SAVE_PLAYLIST:
_store.playlists = [];
var playlists = {
"name": action.index,
};
_store.playlists.push(playlists);
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.ADD_TO_PLAYLIST:
console.log('added!');
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.GET_PLAYLISTS:
_store.playlists = [];
action.index.map(function(playlist){
var playlists = {
"name": playlist._name,
"id": playlist._id,
};
_store.playlists.push(playlists);
});
SearchStore.emit(CHANGE_EVENT);
break;
case actionConstants.GET_PLAYLIST:
_store.playlist = [];
action.items.items.map(function(movie){
_store.playlist.push(movie);
});
console.log(_store.playlist);
SearchStore.emit(CHANGE_EVENT);
break;
default:
//fgt
}
});
module.exports = SearchStore;
|
Ext.define('App.store.Cbcountries',{
extend: 'Ext.data.Store',
fields: [ 'id','name' ],
proxy: {
type: 'rest',
url: getApiUrl() +'/countries',
reader: {
type: 'json',
root: 'results',
totalProperty: 'total'
}
}
});
|
"use strict";
angular.module("myApp.add",["ngRoute"]).
config(["$routeProvider",function($routeProvider){
$routeProvider.when('/add',{
templateUrl:'add/add.html',
controller:"AddController"
})
}]).
controller('AddController',["$scope","$location","Recipe",function($scope,$location,Recipe){
$scope.recipe = new Recipe({
ingredients:[{}]
});
$scope.Add = function(){
$scope.recipe.$save(function(){
$location.path('/view/'+recipe.id)
});
}
}])
|
var gulp = require('gulp'),
rename = require('gulp-rename'),
babel = require('gulp-babel'),
prompt = require('gulp-prompt'),
git = require('gulp-git'),
bump = require('gulp-bump'),
filter = require('gulp-filter'),
tag_version = require('gulp-tag-version'),
shell = require('gulp-shell'),
argv = require('yargs').argv,
gulpif = require('gulp-if'),
uglify = require('gulp-uglify'),
sourcemaps = require('gulp-sourcemaps'),
source = require('vinyl-source-stream'),
buffer = require('vinyl-buffer'),
browserify = require('browserify'),
watchify = require('watchify'),
babelify = require('babelify'),
eslint = require('gulp-eslint'),
Server = require('karma').Server;
var pkg = require('./package.json');
var entry = 'i18next.js',
standaloneName = 'i18next',
output = 'index.js';
function compile(watch) {
var bundler = browserify('./src/' + entry, { debug: argv.debug, standalone: standaloneName }).transform(babelify);
if (watch) {
bundle = watchify(bundler);
}
function rebundle() {
return bundler.bundle()
.on('error', function(err) { console.error(err); this.emit('end'); })
.pipe(source(output))
.pipe(buffer())
.pipe(gulpif(!argv.debug, uglify()))
.pipe(gulpif(argv.debug, sourcemaps.init({ loadMaps: true })))
.pipe(gulpif(argv.debug, sourcemaps.write('./')))
.pipe(gulp.dest('./bin'));
}
if (watch) {
bundler.on('update', function() {
console.log('-> bundling...');
rebundle();
});
}
return rebundle();
}
gulp.task('eslint', function () {
return gulp.src(['src/**/*.js'])
.pipe(eslint({
useEslintrc: true
}))
.pipe(eslint.format())
.pipe(eslint.failAfterError());
});
gulp.task('test', function (done) {
new Server({
configFile: __dirname + '/karma.conf.js',
singleRun: true,
reporters: [ 'spec', 'coverage' ],
}, done).start();
});
gulp.task('test_forCI', function (done) {
new Server({
configFile: __dirname + '/karma.conf.js',
singleRun: true,
reporters: [ 'coverage', 'coveralls', 'spec' ],
}, done).start();
});
gulp.task('test_compat_ci', function (done) {
new Server({
configFile: __dirname + '/karma.backward.conf.js',
singleRun: true
}, done).start();
});
gulp.task('test_compat', function (done) {
new Server({
configFile: __dirname + '/karma.backward.conf.js'
}, done).start();
});
gulp.task('tdd', function (done) {
new Server({
configFile: __dirname + '/karma.conf.js'
}, done).start();
});
gulp.task('babel', function () {
return gulp.src('./src/**/*.js')
.pipe(babel())
.pipe(gulp.dest('./lib'));
});
gulp.task('rename', ['concat', 'babel'], function () {
return gulp
.src('./bin/index.js')
.pipe(rename('./' + standaloneName + '.min.js'))
.pipe(gulp.dest('./'));
});
function inc(version) {
if (!version) return;
var type, tag;
if (version.indexOf('.') < 0) {
if (version === 'major' || version === 'minor' || version === 'patch') {
type = version;
} else {
tag = version;
var parts = pkg.version.split('-');
if (parts.length > 1) {
var tagVersion = 0;
var p = parts[1].split('.');
if (p[0] === tag) tagVersion = parseInt(p[1], 10) + 1;
version = parts[0] + '-' + tag + '.' + tagVersion;
} else {
version = pkg.version + '-' + tag + '.0';
}
}
}
function cb(obj) {
var stream = new require('stream').Transform({objectMode: true});
stream._transform = function(file, unused, callback) {
obj();
callback(null, file);
};
return stream;
}
// get all the files to bump version in
return gulp.src(['./package.json', './bower.json'])
// bump the version number in those files
.pipe(type ? bump({type: type}) : bump({version: version}))
// save it back to filesystem
.pipe(gulp.dest('./'))
// commit change
.pipe(git.commit('bumps package version'))
// read only one file to get the version number
.pipe(filter('package.json'))
// **tag it in the repository**
.pipe(tag_version({prefix: ''}))
// push tag
.pipe(prompt.confirm({
message: 'Push tag ' + version + ' to github?',
default: false
}))
.pipe(cb(function() {
git.push('origin','master', {args: ' --tags --force'}, function (err) {
if (err) throw err;
});
}))
// npm publish
.pipe(prompt.confirm({
message: 'publish ' + version + ' to npm?',
default: false
}))
.pipe(shell([
'npm publish --tag ' + (tag ? tag : 'latest')
]));
}
function watch() {
return compile(true);
};
gulp.task('concat', function() { return compile(); });
gulp.task('watch', function() { return watch(); });
gulp.task('bump', function() { return inc(argv.v); });
gulp.task('default', ['watch']);
gulp.task('build', ['concat', 'babel', 'rename']);
gulp.task('publish', ['bump']);
gulp.task('test_ci', ['test_forCI']);
|
/*
* grunt-google-translate
* https://github.com/dolanmiu/grunt-google-translate
*
* Copyright (c) 2016 Dolan Miu
* Licensed under the MIT license.
*/
/*jslint node: true, nomen: true, regexp: true*/
'use strict';
var _ = require('lodash');
var Q = require('q');
var utility = require('../utility');
var angular = require('../utility/angular');
function translate(origJson, googleTranslate, source, target, destPath, grunt) {
var deferred = Q.defer(),
jsonReferenceArray = [],
sourceJson = _.cloneDeep(origJson);
utility.deepTraverseJson(sourceJson, function (parent, value, key) {
jsonReferenceArray.push({
parent: parent,
value: value,
key: key
});
});
grunt.log.writeln('Translating into: ' + target);
googleTranslate.translate(_.map(jsonReferenceArray, 'value'), source, target, function (err, translations) {
var i;
if (err) {
grunt.log.error('Failed to translate');
return deferred.reject(err);
}
// Result is an object (instead of Array) in case of translating one term only
if (jsonReferenceArray.length == 1 && translations.translatedText) {
jsonReferenceArray[0].parent[jsonReferenceArray[0].key] = translations.translatedText;
}
else {
for (i = 0; i < jsonReferenceArray.length; i += 1) {
jsonReferenceArray[i].parent[jsonReferenceArray[i].key] = translations[i].translatedText;
}
}
deferred.resolve({
dest: destPath,
json: sourceJson
});
});
return deferred.promise;
}
module.exports = function (grunt) {
var promises = [];
grunt.registerMultiTask('google_translate', 'A build task to translate JSON files to other languages using Google\'s Translation API. Pairs very well with angular-translate.', function () {
var done = this.async(),
defer = Q.defer(),
googleTranslate = require('google-translate')(this.options().googleApiKey);
this.files.forEach(function (file) {
file.prefix = file.prefix || '';
file.suffix = file.suffix || /.+(\..+)/.exec(file.src)[1];
var languageJson = JSON.parse(grunt.file.read(file.src)),
variableSafeJson = angular.createVariableSafeJson(languageJson);
file.targetLanguages.forEach(function (targetLanguage) {
var filePath = file.dest + file.prefix + targetLanguage + file.suffix;
promises.push(translate(variableSafeJson, googleTranslate, file.sourceLanguage, targetLanguage, filePath, grunt));
});
});
Q.all(promises).then(function (translatedJsons) {
grunt.log.writeln('Writing translated file');
translatedJsons.forEach(function (translatedJson) {
var revertedJson = angular.revertVariablesInJson(translatedJson.json);
grunt.file.write(translatedJson.dest, JSON.stringify(revertedJson, null, "\t"));
grunt.log.writeln('Wrote translated file: ' + translatedJson.dest);
});
done();
}, function (err) {
grunt.fail.fatal(err);
});
});
};
|
"use strict";
var Class = require('appolo-class'),
fs = require('fs'),
path = require('path'),
_ = require('lodash');
var FilesLoader = Class.define({
load:function(root, filesPath, callback){
if (!_.isArray(filesPath)) {
filesPath = [filesPath];
}
_.forEach(filesPath, function (filePath) {
this._loadFiles(path.join(root, filePath), callback);
},this)
},
_loadFiles:function(filePath, callback){
if (fs.existsSync(filePath)) {
fs.readdirSync(filePath).forEach(function (file) {
var newPath = path.join(filePath, file);
var stat = fs.statSync(newPath);
if (stat.isFile() && /(.*)\.(js)$/.test(file)) {
callback(newPath);
} else if (stat.isDirectory()) {
this._loadFiles(newPath, callback);
}
}.bind(this));
}
}
});
module.exports = new FilesLoader();
|
(function () {
'use strict';
// gulp
var gulp = require('gulp');
var options = gulp.options;
// other
var chalk = require('chalk');
var minimist = require('minimist');
var fs = require('fs');
var xml2js = require('xml2js');
gulp.task('config', function () {
var parser = new xml2js.Parser();
var builder = new xml2js.Builder({
renderOp: {
pretty: true,
indent: ' '
},
xmldec: {
version: '1.0',
encoding: 'utf-8'
}
});
// read & parse file
var xmlFile = fs.readFileSync('config.xml');
parser.parseString(xmlFile, function (err, result) {
// get values
if (options.getWidgetAttr) {
console.log(result.widget.$[options.getWidgetAttr]);
}
// update values
if (options.setWidgetAttr) {
var split = options.setWidgetAttr.split('=');
var key = split[0];
var value = split[1];
result.widget.$[key] = value;
}
if (options.setName) {
result.widget.name = options.setName;
}
if (options.setDescription) {
result.widget.description = options.setDescription;
}
if (options.setAuthor) {
var splits = options.setAuthor.split('---');
if (splits[0]) {
result.widget.author[0]._ = splits[0];
}
if (splits[1]) {
result.widget.author[0].$.email = splits[1];
}
if (splits[2]) {
result.widget.author[0].$.href = splits[2];
}
}
// write file
var xml = builder.buildObject(result);
fs.writeFileSync('config.xml', xml);
});
});
gulp.task('defaults', function () {
var filePath = './gulp/.gulp_settings.json';
var exists = fs.existsSync(filePath);
var fileContent = {};
if (exists) {
fileContent = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
}
var defaults = fileContent.defaults;
// set
if (options.set) {
if (typeof options.set !== 'string') {
console.log(chalk.red('Use like this: --set=\'<task-name> --flag1 --flag2=value\''));
return;
}
var newDefaults = minimist(options.set.split(' '));
if (!defaults) {
fileContent.defaults = defaults = {};
}
var setTask = newDefaults._[0];
delete newDefaults._;
defaults[setTask] = newDefaults;
console.log(chalk.green('set defaults for task \'' + setTask + '\': '), newDefaults);
}
// clear
else if (options.clear) {
var clearTask = options.clear;
if (typeof clearTask !== 'string') {
console.log(chalk.red('Use like this: --clear <task-name>'));
return;
}
if (!defaults || !defaults[clearTask]) {
console.log(chalk.yellow('Nothing to clear'));
return;
}
delete defaults[clearTask];
console.log(chalk.yellow('cleared defaults for task \'' + clearTask + '\''));
// last? -> delete defaults object
if (!Object.keys(defaults).length) {
delete fileContent.defaults;
}
}
// show
else {
if (defaults) {
console.log(chalk.green('defaults:'));
for (var key in defaults) {
console.log(chalk.green(key + ': '), defaults[key]);
}
}
else {
console.log(chalk.yellow('no defaults yet'));
}
}
// write changes to file
if (options.clear || options.set) {
fs.writeFileSync(filePath, JSON.stringify(fileContent, undefined, 2));
}
});
})();
|
import { SAY_HELLO } from '../actions/actions';
export default function(state = {message: ''}, action) {
switch (action.type) {
case SAY_HELLO:
return { message: action.message };
default:
return state;
}
};
|
var express = require('express');
var path = require('path');
var rewrite = require("connect-url-rewrite");
var app = express();
app.set('port', (process.env.PORT || 8000));
app.use(rewrite(["^\/[^\.]+$ /"]))
app.use(express.static(path.join(__dirname, 'build')));
app.get('/', function(request, response) {
response.sendFile('index.html', {root: __dirname})
});
app.listen(app.get('port'), function() {
console.log("Node app is running at localhost:" + app.get('port'))
});
|
module.exports = function(grunt) {
// Plugin Configuration goes here
grunt.initConfig({
sass: { // Task
dist: { // Target
options: { // Target options
style: 'expanded'
},
files: { // Dictionary of files
'dist/styles/main.css': 'sources/styles/main.scss', // 'destination': 'source'
}
}
},
watch: {
css: {
files: 'sources/styles/main.scss',
tasks: ['sass'],
options: {
livereload: true,
},
},
},
});
// Load plugins here
grunt.loadNpmTasks('grunt-contrib-sass');
grunt.loadNpmTasks('grunt-contrib-watch');
//Define your defualt tasks
grunt.registerTask('default', ['sass']);
grunt.registerTask('default', ['watch']);
};
|
/**!
* utility - test/polyfill.test.js
*
* Copyright(c) fengmk2 and other contributors.
* MIT Licensed
*
* Authors:
* fengmk2 <[email protected]> (http://fengmk2.github.com)
*/
'use strict';
/**
* Module dependencies.
*/
var utils = require('../');
describe('polyfill.test.js', function () {
describe('setImmediate()', function () {
it('should work', function (done) {
var count = 0;
utils.setImmediate(function () {
count.should.equal(1);
done();
});
count++;
});
it('should pass arguments work', function (done) {
var count = 0;
utils.setImmediate(function (arg) {
count.should.equal(1);
arg.should.equal(2);
done();
}, 2);
count++;
});
});
});
|
import React from 'react'
import Helmet from 'react-helmet'
import Link from 'gatsby-link'
class TagRoute extends React.Component {
render() {
const posts = this.props.data.allMarkdownRemark.edges
const postLinks = posts.map(post => (
<li key={post.node.fields.slug}>
<Link to={post.node.fields.slug}>
<h2 className="is-size-2">{post.node.frontmatter.title}</h2>
</Link>
</li>
))
const tag = this.props.pathContext.tag
const title = this.props.data.site.siteMetadata.title
const totalCount = this.props.data.allMarkdownRemark.totalCount
const tagHeader = `${totalCount} post${
totalCount === 1 ? '' : 's'
} tagged with “${tag}”`
return (
<section className="section">
<Helmet title={`${tag} | ${title}`} />
<div className="container content">
<div className="columns">
<div
className="column is-10 is-offset-1"
style={{ marginBottom: '6rem' }}
>
<h3 className="title is-size-4 is-bold-light">{tagHeader}</h3>
<ul className="taglist">{postLinks}</ul>
<p>
<Link to="/tags/">Browse all tags</Link>
</p>
</div>
</div>
</div>
</section>
)
}
}
export default TagRoute
export const tagPageQuery = graphql`
query TagPage($tag: String) {
site {
siteMetadata {
title
}
}
allMarkdownRemark(
limit: 1000
sort: { fields: [frontmatter___date], order: DESC }
filter: { frontmatter: { tags: { in: [$tag] } } }
) {
totalCount
edges {
node {
fields {
slug
}
frontmatter {
title
}
}
}
}
}
`
|
angular.module('app').directive('appPager', function(){
return {
restrict: 'E',
replace: true,
scope: {
page: '@',
pagesMax: '@',
select: '&'
},
templateUrl: 'app/directives/pager.html',
controller: ['$scope', function($scope){
$scope.selected = function(page){
return page == $scope.page ? true : false;
}
$scope.first = function(page){
return page == 0 ? true : false;
}
$scope.last = function(page){
return page == $scope.pagesMax - 1 ? true : false;
}
$scope.refreshPages = function(count){
if(count <= 1) {
$scope.pagesAvailable = false;
return false;
}
$scope.pages = count;
$scope.pagesAvailable = true;
return true;
}
$scope.calcPrevNext = function (page, count){
$scope.prevPage = page > 0 ? page-1 : 0;
$scope.nextPage = page < count - 1 ? page+1 : count - 1;
}
$scope.getPagesRange = function(){
var maxShowPages = 10;
var range = [];
var from = 0;
var to = $scope.pages > maxShowPages ? maxShowPages : $scope.pages;
if($scope.currentPage == $scope.pages - 1){
from = $scope.pages - maxShowPages - 1;
to = $scope.pages;
}else if($scope.currentPage + 1 > maxShowPages - 1){
from = $scope.currentPage - parseInt(maxShowPages / 2);
to = $scope.pages > from + maxShowPages ? from + maxShowPages : $scope.pages;
}
for (var i = from; i < to; i++)
range.push(i);
return range;
}
}],
link: function (scope, element, attrs) {
scope.pagesAvailable = false;
scope.currentPage = 0;
scope.prevPage = 0;
scope.nextPage = 0;
scope.$watch('page', function(newValue, oldValue) {
scope.currentPage = parseInt(newValue);
scope.calcPrevNext(scope.currentPage, scope.pages);
});
scope.$watch('pagesMax', function(newValue, oldValue) {
scope.refreshPages(parseInt(newValue));
scope.calcPrevNext(scope.currentPage, scope.pages);
});
}
}
})
|
import Header from './container';
export default Header;
|
// Generated by LiveScript 1.4.0
(function(){
var express, app, port;
express = require('express');
app = express();
app.use(express['static'](__dirname + "/dist"));
app.listen(port = process.env.port || 8088);
console.log("The web server has started... port:" + port);
}).call(this);
|
(function ($) {
$.fn.fullCalendar = function (options = {}) {
options = $.extend({}, options, $.fn.fullCalendar.options || {})
this.each(function () {
if (typeof this.fullCalendar === 'undefined') {
this.fullCalendar = new FullCalendar.Calendar(this, options)
this.fullCalendar.render();
}
});
if ($(this).length === 1) {
return this.get(0).fullCalendar;
}
return this;
}
})(jQuery);
|
/*
Template Name: Color Admin - Responsive Admin Dashboard Template build with Twitter Bootstrap 3.3.7
Version: 2.1.0
Author: Sean Ngu
Website: http://www.seantheme.com/color-admin-v2.1/admin/html/
*/var handleDataTableAutofill=function(){"use strict";0!==$("#data-table").length&&$("#data-table").DataTable({autoFill:!0,responsive:!0})},TableManageAutofill=function(){"use strict";return{init:function(){handleDataTableAutofill()}}}();
|
const toNumber = n => parseInt(n) || 0
export default function getMargin(style) {
return {
top: style ? toNumber(style.marginTop) : 0,
right: style ? toNumber(style.marginRight) : 0,
bottom: style ? toNumber(style.marginBottom) : 0,
left: style ? toNumber(style.marginLeft) : 0
}
}
|
// # Ghost Configuration
// Setup your Ghost install for various environments
// Documentation can be found at http://support.ghost.org/config/
var path = require('path'),
config;
config = {
// ### Production
// When running Ghost in the wild, use the production environment
// Configure your URL and mail settings here
production: {
url: 'http://guaver.info',
mail: {},
database: {
client: 'sqlite3',
connection: {
filename: path.join(__dirname, '/content/data/ghost.db')
},
debug: false
},
server: {
// Host to be passed to node's `net.Server#listen()`
host: '127.0.0.1',
// Port to be passed to node's `net.Server#listen()`, for iisnode set this to `process.env.PORT`
port: '2368'
}
},
// ### Development **(default)**
development: {
// The url to use when providing links to the site, E.g. in RSS and email.
// Change this to your Ghost blogs published URL.
url: 'http://guaver.info:2368',
// Example mail config
// Visit http://support.ghost.org/mail for instructions
// ```
// mail: {
// transport: 'SMTP',
// options: {
// service: 'Mailgun',
// auth: {
// user: '', // mailgun username
// pass: '' // mailgun password
// }
// }
// },
// ```
database: {
client: 'sqlite3',
connection: {
filename: path.join(__dirname, '/content/data/ghost-dev.db')
},
debug: false
},
server: {
// Host to be passed to node's `net.Server#listen()`
host: '127.0.0.1',
// Port to be passed to node's `net.Server#listen()`, for iisnode set this to `process.env.PORT`
port: '2368'
},
paths: {
contentPath: path.join(__dirname, '/content/')
}
},
// **Developers only need to edit below here**
// ### Testing
// Used when developing Ghost to run tests and check the health of Ghost
// Uses a different port number
testing: {
url: 'http://127.0.0.1:2369',
database: {
client: 'sqlite3',
connection: {
filename: path.join(__dirname, '/content/data/ghost-test.db')
}
},
server: {
host: '127.0.0.1',
port: '2369'
},
logging: false
},
// ### Testing MySQL
// Used by Travis - Automated testing run through GitHub
'testing-mysql': {
url: 'http://127.0.0.1:2369',
database: {
client: 'mysql',
connection: {
host : '127.0.0.1',
user : 'root',
password : '',
database : 'ghost_testing',
charset : 'utf8'
}
},
server: {
host: '127.0.0.1',
port: '2369'
},
logging: false
},
// ### Testing pg
// Used by Travis - Automated testing run through GitHub
'testing-pg': {
url: 'http://127.0.0.1:2369',
database: {
client: 'pg',
connection: {
host : '127.0.0.1',
user : 'postgres',
password : '',
database : 'ghost_testing',
charset : 'utf8'
}
},
server: {
host: '127.0.0.1',
port: '2369'
},
logging: false
}
};
// Export config
module.exports = config;
|
var Sequelize = require('Sequelize');
var config = require('config');
var sequelize = new Sequelize(config.sequelize.database,
config.sequelize.username,
config.sequelize.password,
{
host: config.sequelize.host,
dialect: 'sqlite',
storage: ':memory:',
logging: false
});
var db = {};
db.Sequelize = Sequelize;
db.sequelize = sequelize;
module.exports = db;
|
/**
* Created by MuyBien on 1/31/16.
*/
var data = require('../data.json');
var models = require('../models');
exports.view = function(req, res){
console.log('in my_journal js')
console.log(req.session.user);
var searchOption = {"name": req.session.user.name}
console.log(searchOption);
models.User.findOne(searchOption).populate('journals').sort({createdAt: -1}).exec(function (err, result) {
if (err) return console.error(err);
var list = result['journals'];
//console.log(list);
function compare(a, b) {
//console.log("compare:" )
//console.log(a.createdAt);
//console.log(b.createdAt);
//console.log(b.createdAt - a.createdAt);
//console.log();
return b.createdAt - a.createdAt;
}
//console.log();
//console.log();
//console.log();
list.sort(compare);
//console.log(list);
var isEmpty = result['journals'].length == 0;
res.render('my_journal', {
'journals': result['journals'], 'user': result, 'isEmpty' : isEmpty,
helpers: {
formatDate: function (datetime) {
var date = new Date(datetime);
var options = {
//weekday: "long",
year: "numeric",
month: "short",
day: "numeric",
//hour: "2-digit",
//minute: "2-digit"
}
return date.toLocaleDateString("en-US", options);
},
}
});
});
};
|
import React from 'react';
import createReactClass from 'create-react-class';
import PropTypes from 'prop-types';
import _ from 'lodash';
import { getState } from 'lore-hook-connect';
import PayloadStates from '../constants/PayloadStates';
import LoadMoreButton from './LoadMoreButton';
const styles = {
repositories: {
marginTop: '32px'
}
};
export default createReactClass({
displayName: 'InfiniteScrollingList',
propTypes: {
title: PropTypes.func.isRequired,
row: PropTypes.func.isRequired,
select: PropTypes.func.isRequired,
selectNextPage: PropTypes.func,
refresh: PropTypes.func,
selectOther: PropTypes.func,
exclude: PropTypes.func
},
getDefaultProps() {
return {
exclude: function(model) {
return false;
}
}
},
getInitialState() {
return {
other: null,
pages: []
};
},
// fetch first page
componentWillMount() {
const { select, selectOther } = this.props;
const nextState = this.state;
nextState.pages.push(select(getState));
if (selectOther) {
nextState.other = selectOther(getState);
}
this.setState(nextState);
},
// refresh data in all pages
componentWillReceiveProps(nextProps) {
const { refresh, selectOther } = this.props;
const { pages } = this.state;
const nextState = {};
if (refresh) {
nextState.pages = pages.map(function(page) {
return refresh(page, getState);
});
}
if (selectOther) {
nextState.other = selectOther(getState);
}
this.setState(nextState);
},
onLoadMore() {
const { selectNextPage } = this.props;
const { pages } = this.state;
const lastPage = pages[pages.length - 1];
pages.push(selectNextPage(lastPage, getState));
this.setState({
pages: pages
});
},
render() {
const { title, row, exclude, selectNextPage } = this.props;
const { pages, other } = this.state;
const numberOfPages = pages.length;
const firstPage = pages[0];
const lastPage = pages[pages.length - 1];
// if we only have one page, and it's fetching, then it's the initial
// page load so let the user know we're loading the data
if (numberOfPages === 1 && lastPage.state === PayloadStates.FETCHING) {
return title(pages);
}
// If the last page has an error, replace the whole list with the error
if(lastPage.state === PayloadStates.ERROR_FETCHING) {
return title(pages);
}
return (
<div>
{title(pages)}
<ul className="media-list" style={styles.repositories}>
{_.flatten(pages.map((models) => {
return _.filter(models.data, (model) => {
return !exclude(model);
}).map(row);
}))}
</ul>
{selectNextPage ? (
<LoadMoreButton
lastPage={lastPage}
onLoadMore={this.onLoadMore}
nextPageMetaField="nextPage"
/>
) : null}
</div>
);
}
});
|
'use strict';
const path = require('path');
const assert = require('yeoman-assert'); // eslint-disable-line
const helpers = require('yeoman-test'); // eslint-disable-line
const fs = require('fs-extra'); // eslint-disable-line
describe('react-webpack-redux:reducer', () => {
describe('When creating a new reducer', () => {
const generatorReducer = path.join(__dirname, '../../../generators/reducer');
const reducerSource = path.join(__dirname, '../../../generators/root/templates/reducer.js');
const appSource = path.join(__dirname, '../../../generators/root/templates/App.js');
let rootReducerPath = '';
let appPath = '';
/**
* Return a newly generated reducer with given name
* @param {String} name
* @param {Function} callback
*/
function createGeneratedReducer(name, callback) {
helpers.run(generatorReducer)
.inTmpDir((tmpDir) => {
rootReducerPath = path.join(tmpDir, 'src/reducers/index.js');
fs.copySync(reducerSource, rootReducerPath);
appPath = path.join(tmpDir, 'src/containers/App.js');
fs.copySync(appSource, appPath);
})
.withArguments([name])
.on('end', callback);
}
it('should create a reducer when invoked', (done) => {
createGeneratedReducer('test', () => {
assert.file([
'src/reducers/test.js'
]);
done();
});
});
it('should create the reducers unit test', (done) => {
createGeneratedReducer('test', () => {
assert.file([
'test/reducers/testTest.js'
]);
done();
});
});
it('should add the reducer to the root reducer', (done) => {
createGeneratedReducer('namespaced/test', () => {
assert.fileContent(rootReducerPath, '/* Populated by react-webpack-redux:reducer */');
assert.fileContent(rootReducerPath, 'import test from \'../reducers/namespaced/test.js\';');
assert.fileContent(rootReducerPath, 'const reducers = { test };');
done();
});
});
it('should add the reducer to App.js', (done) => {
createGeneratedReducer('test', () => {
assert.fileContent(appPath, '/* Populated by react-webpack-redux:reducer */');
assert.fileContent(appPath, 'test: state.test');
assert.fileContent(appPath, 'const {actions, test} = this.props;');
assert.fileContent(appPath, '<Main actions={actions} test={test}/>');
assert.fileContent(appPath, 'test: PropTypes.shape({})');
done();
});
});
});
});
|
'use strict';
angular.module('mean.tasks', []);
|
import React, { PropTypes } from 'react'
import { connectWithStore } from '../redux/connectWithStore';
import { store } from '../redux/store'
import Layout from '../components/layout';
import ProductItem from '../components/ProductItem'
import ProductsList from '../components/ProductList'
import { getVisibleProducts } from '../redux/reducers/products'
import { addToCart } from '../redux/actions'
import { getCartProducts } from '../redux/reducers'
class ProductListContainer extends React.Component {
renderProudctList(products, addToCart) {
return (
<ProductsList title="Products">
{products.map(product =>
<ProductItem
key={product.id}
product={product}
onAddToCartClicked={() => addToCart(product.id)} />
)}
</ProductsList>
)
}
render() {
const products = this.props.products;
const onAddToCart = this.props.onAddToCart;
const cartLength = this.props.cartLength
return (
<Layout cartLength={cartLength}>
<div>
{this.renderProudctList(products, onAddToCart)}
<br />
</div>
</Layout>
)
}
}
ProductListContainer.propTypes = {
products: PropTypes.arrayOf(PropTypes.shape({
id: PropTypes.string.isRequired,
title: PropTypes.string.isRequired,
price: PropTypes.number.isRequired,
inventory: PropTypes.number.isRequired
})).isRequired,
onAddToCart: PropTypes.func.isRequired
}
const mapStateToProps = state => ({
products: getVisibleProducts(state.products),
cartLength: getCartProducts(state).length
})
const mapDispatchToProps = (dispatch) => {
return {
onAddToCart: (productId) => {
dispatch(addToCart(productId))
}
}
};
export default connectWithStore(store, ProductListContainer, mapStateToProps, mapDispatchToProps);
|
(function () {
window.app('dom').extend({
on: function (elem, type, handler) {
if (elem.addEventListener) {
elem.addEventListener(type, handler, false);
} else {
elem.attachEvent('on' + type, handler);
}
},
off: function (elem, type, handler) {
if (elem.removeEventListener) {
elem.removeEventListener(type, handler, false);
} else {
elem.detachEvent('on' + type, handler);
}
}
});
})();
|
var path = require('path');
var fs = require('fs');
var nodeModules = {};
fs.readdirSync('node_modules')
.filter(function (x) {
return ['.bin'].indexOf(x) === -1;
})
.forEach(function (mod) {
nodeModules[mod] = 'commonjs ' + mod;
});
var config = {
externals: nodeModules,
target: 'node',
resolve: {
extensions: ['.ts', '.tsx', '.js', '.jsx'],
modules: [path.resolve(__dirname), 'node_modules', 'app', 'app/redux'],
},
entry: './src/server.tsx',
output: {
path: path.resolve('./build/public'),
filename: '../server.js',
publicPath: '/public/',
libraryTarget: 'commonjs2'
},
module: {
loaders: [{
test: /\.(jpe?g|png|gif)$/i,
loader: 'url-loader?limit=1000&name=images/[hash].[ext]'
},
{
test: /\.json$/,
loader: 'json-loader'
},
{
test: /\.jsx$/,
loader: 'babel-loader'
},
{
test: /\.tsx?$/,
loader: 'awesome-typescript-loader',
exclude: /node_modules/
},
{
test: /\.woff(2)?(\?v=[0-9]\.[0-9]\.[0-9])?$/,
loader: "url-loader?limit=10000&mimetype=application/font-woff"
},
{
test: /\.(ttf|eot|svg)(\?v=[0-9]\.[0-9]\.[0-9])?$/,
loader: "file-loader"
}
]
},
plugins: [],
node: {
console: false,
global: false,
process: false,
Buffer: false,
__filename: false,
__dirname: false
}
};
const copySync = (src, dest, overwrite) => {
if (overwrite && fs.existsSync(dest)) {
fs.unlinkSync(dest);
}
const data = fs.readFileSync(src);
fs.writeFileSync(dest, data);
}
const createIfDoesntExist = dest => {
if (!fs.existsSync(dest)) {
fs.mkdirSync(dest);
}
}
createIfDoesntExist('./build');
createIfDoesntExist('./build/public');
copySync('./src/favicon.ico', './build/public/favicon.ico', true);
module.exports = config;
|
/**
* @interface
*/
function TCPSocket() {}
/**
* @const
* @type {string}
*/
TCPSocket.prototype.host = '';
/**
* @const
* @type {number}
*/
TCPSocket.prototype.port = 0;
/**
* @const
* @type {boolean}
*/
TCPSocket.prototype.ssl = false;
/**
* @const
* @type {number}
*/
TCPSocket.prototype.bufferedAmount = 0;
/**
* arraybuffer|string
*
* @const
* @type {string}
*/
TCPSocket.prototype.binaryType = '';
/**
* connecting|open|closing|closed
*
* @const
* @type {string}
*/
TCPSocket.prototype.readyState = '';
/**
* @type {function(TCPSocketEvent)}
*/
TCPSocket.prototype.onopen = null;
/**
* @type {function(TCPSocketEvent)}
*/
TCPSocket.prototype.ondrain = null;
/**
* @type {function(TCPSocketEvent)}
*/
TCPSocket.prototype.onerror = null;
/**
* @type {function(TCPSocketEvent)}
*/
TCPSocket.prototype.ondata = null;
/**
* @type {function(TCPSocketEvent)}
*/
TCPSocket.prototype.onclose = null;
/**
* @type {function()}
*/
TCPSocket.prototype.close = function () {};
/**
* @param {string} host
* @param {number} port
* @param {{useSecureTransport?: boolean, binaryType?: string}} [options]
* @returns {TCPSocket}
*/
TCPSocket.prototype.open = function (host, port, options) {};
/**
* @param {number} port
* @param {{binaryType: string}} [options]
* @param {number} [backlog]
* @returns {TCPServerSocket}
* @since v1.2
*/
TCPSocket.prototype.listen = function (port, options, backlog) {};
/**
* @type {function()}
*/
TCPSocket.prototype.resume = function () {};
/**
* @param {string|ArrayBuffer} data
* @param {number} [byteOffset]
* @param {number} [byteLength]
* @returns {boolean}
*/
TCPSocket.prototype.send = function (data, byteOffset, byteLength) {};
/**
* @type {function()}
*/
TCPSocket.prototype.suspend = function () {};
/**
* @type {function()}
*/
TCPSocket.prototype.upgradeToSecure = function () {};
|
var http = require('http'),
url = require('url'),
fs = require('fs'),
glob = require('glob'),
ActionStore = require('./actionstore.js'),
bodyParser = require('body-parser'),
express = require('express');
var app = express();
app.use(bodyParser.json());
app.use(require('morgan')('dev'));
store = new ActionStore();
app.get("/testdata", function(req, res) {
res.json(store.store);
});
app.post("/testdata", function(req, res) {
store.addTestData(req.body);
res.status(200).end();
});
var processAction = function(res, action) {
if (!action) {
res.status(process.env.NOT_FOUND_STATUS || 404).end();
return;
}
if(action.responseHeaders) {
res.set(action.responseHeaders);
}
if (action.status) {
res.status(action.status);
}
if (action.responseBody) {
if(action.responseHeaders && action.responseHeaders['Content-Type']) {
res.send(action.responseBody);
}else {
res.json(action.responseBody);
}
}
res.end();
};
app.get(/\/(.*)/, function(req, res) {
var path = url.parse(req.url).path;
var action = store.getAction(path, 'GET');
processAction(res, action);
});
app.post(/\/(.*)/, function(req, res) {
var path = url.parse(req.url).path;
var action = store.getAction(path, 'POST', req.body);
processAction(res, action);
});
app.put(/\/(.*)/, function(req, res) {
var path = url.parse(req.url).path;
var action = store.getAction(path, 'PUT', req.body);
processAction(res, action);
});
var pattern = process.env.TEST_FILER || "testdata/**/*.json";
glob(pattern, function(err, files) {
if (err) throw err;
files.forEach(function(file) {
console.log("loading file: " + file);
var fileObject = JSON.parse(fs.readFileSync(file, 'utf8'));
store.addTestData(fileObject);
});
});
var applicationPort = process.env.APPLICATION_PORT || 8081;
console.log("starting StubIt on port ", applicationPort);
var httpServer = http.createServer(app);
httpServer.listen(applicationPort);
|
/**
* Module dependencies.
*/
var fs = require('fs');
var assert = require('assert');
var pug = require('../');
var uglify = require('uglify-js');
var mkdirp = require('mkdirp').sync;
var filters = {
custom: function (str, options) {
assert(options.opt === 'val');
assert(options.num === 2);
return 'BEGIN' + str + 'END';
}
};
// test cases
function findCases(dir) {
return fs.readdirSync(dir).filter(function(file){
return ~file.indexOf('.pug');
}).map(function(file){
return file.replace('.pug', '');
});
}
var cases = findCases(__dirname + '/cases');
var es2015 = findCases(__dirname + '/cases-es2015');
var anti = findCases(__dirname + '/anti-cases');
mkdirp(__dirname + '/output');
mkdirp(__dirname + '/output-es2015');
function testSingle(it, suffix, test){
var name = test.replace(/[-.]/g, ' ');
it(name, function(){
var path = 'test/cases' + suffix + '/' + test + '.pug';
var str = fs.readFileSync(path, 'utf8');
var fn = pug.compile(str, {
filename: path,
pretty: true,
basedir: 'test/cases' + suffix,
filters: filters
});
var actual = fn({ title: 'Pug' });
fs.writeFileSync(__dirname + '/output' + suffix + '/' + test + '.html', actual);
var html = fs.readFileSync('test/cases' + suffix + '/' + test + '.html', 'utf8').trim().replace(/\r/g, '');
var clientCode = uglify.minify(pug.compileClient(str, {
filename: path,
pretty: true,
compileDebug: false,
basedir: 'test/cases' + suffix,
filters: filters
}), {output: {beautify: true}, mangle: false, compress: false, fromString: true}).code;
var clientCodeDebug = uglify.minify(pug.compileClient(str, {
filename: path,
pretty: true,
compileDebug: true,
basedir: 'test/cases' + suffix,
filters: filters
}), {output: {beautify: true}, mangle: false, compress: false, fromString: true}).code;
fs.writeFileSync(__dirname + '/output' + suffix + '/' + test + '.js', uglify.minify(pug.compileClient(str, {
filename: path,
pretty: false,
compileDebug: false,
basedir: 'test/cases' + suffix,
filters: filters
}), {output: {beautify: true}, mangle: false, compress: false, fromString: true}).code);
if (/filter/.test(test)) {
actual = actual.replace(/\n| /g, '');
html = html.replace(/\n| /g, '');
}
if (/mixins-unused/.test(test)) {
assert(/never-called/.test(str), 'never-called is in the pug file for mixins-unused');
assert(!/never-called/.test(clientCode), 'never-called should be removed from the code');
}
JSON.stringify(actual.trim()).should.equal(JSON.stringify(html));
actual = Function('pug', clientCode + '\nreturn template;')()({ title: 'Pug' });
if (/filter/.test(test)) {
actual = actual.replace(/\n| /g, '');
}
JSON.stringify(actual.trim()).should.equal(JSON.stringify(html));
actual = Function('pug', clientCodeDebug + '\nreturn template;')()({ title: 'Pug' });
if (/filter/.test(test)) {
actual = actual.replace(/\n| /g, '');
}
JSON.stringify(actual.trim()).should.equal(JSON.stringify(html));
});
}
describe('test cases', function () {
cases.forEach(testSingle.bind(null, it, ''));
});
describe('test cases for ECMAScript 2015', function () {
try {
eval('``');
es2015.forEach(testSingle.bind(null, it, '-es2015'));
} catch (ex) {
es2015.forEach(testSingle.bind(null, it.skip, '-es2015'));
}
});
describe('certain syntax is not allowed and will throw a compile time error', function () {
anti.forEach(function(test){
var name = test.replace(/[-.]/g, ' ');
it(name, function(){
var path = 'test/anti-cases/' + test + '.pug';
var str = fs.readFileSync(path, 'utf8');
try {
var fn = pug.compile(str, {
filename: path,
pretty: true,
basedir: 'test/anti-cases',
filters: filters
});
} catch (ex) {
assert(ex instanceof Error, 'Should throw a real Error');
assert(ex.code.indexOf('PUG:') === 0, 'It should have a code of "PUG:SOMETHING"');
assert(ex.message.replace(/\\/g, '/').indexOf(path) === 0, 'it should start with the path');
assert(/:\d+$/m.test(ex.message.replace(/\\/g, '/')), 'it should include a line number.');
return;
}
throw new Error(test + ' should have thrown an error');
})
});
});
|
$A.bind(window, "load", function() {
// Set the Multiselect ARIA Listbox
var multiselectListbox = new $A.Listbox($A.getEl("multiselectLB"), {
// Set the default list item index value
defaultIndex: 0,
// Set the screen reader accessible label text
label: "What do you want with lunch?",
// Enable multiselect
isMultiselect: true,
// Assign a callback to run every time a new list item is selected
callback: function(optionNode, optionsArray) {
// Toggle the class "selected"
var vals = this.val();
$A.query(optionsArray, function(i, o) {
if ($A.inArray(o.id, vals) !== -1) $A.addClass(o, "selected");
else $A.remClass(o, "selected");
});
// Set the Multiselect Field to match this.val()
// jQuery is used for this part, to save time.
if ($) $("#multiSelectField").val(vals);
}
});
// Bind the Multiselect field with the Multiselect ARIA Listbox
$A.bind("#multiSelectField", "keyup blur", function(ev) {
// jQuery is used for this part, to save time.
if ($) multiselectListbox.val($(this).val());
});
// Set up the form event binding for adding a new value to the listboxes
$A.bind("form.addFrm", "submit", function(ev) {
var newVal = $A.getEl("addNew").value,
newId = $A.getEl("addNewId").value;
if (!newVal || !newId || $A.getEl(newId)) return false;
// To add a new ARIA Listbox item, it needs to be an A tag with a unique ID attribute, so let's make one
var aTag = $A.createEl("a", {
// Assign node attributes
id: newId,
// Add an href attribute to ensure keyboard accessibility
href: "#"
});
// Then put the text in the A tag with supporting surrounding markup
aTag.innerHTML = '<span class="lbl">' + newVal + "</span>";
// Then add it to the ARIA Listbox as a new option
multiselectListbox.add(aTag);
// You can also add an array of A tags if desired.
// E.G multiselectListbox.add([aTag1, aTag2, etc]);
// To remove a list item from an ARIA Listbox, simply pass the ID value of the node you wish to remove to the rem() method, which will return the A tag for that node
// var removedNode = multiselectListbox.rem('multiselectOpt1');
// or an array of IDs like so
// var arrayOfRemovedNodes = multiselectListbox.rem(['multiselectOpt1', 'multiselectOpt2']);
// Now let's add the new value to the standard Select element so they match
var selectField = $A.getEl("multiSelectField");
selectField.appendChild(
$A.createEl(
"option",
{
value: newId
},
null,
null,
document.createTextNode(newVal)
)
);
selectField.size = selectField.options.length;
// Prevent the page from refreshing
ev.preventDefault();
});
});
|
// Import main SCSS for webpack compilation
import './styles/main.scss'
// Import all JS lib for webpack compilation
import './scripts/lib'
// Import your custom function
import {
navbarFixedTopAnimation,
scrollRevelation,
navActivePage
} from './scripts/main'
// Import all assets for webpack compilation
function importAll (r) {
return r.keys().map(r)
}
importAll(require.context('./assets', true, /\.(png|jpe?g|svg)$/))
// Declare which function are accessible to the browser
Object.assign(window, {
navbarFixedTopAnimation,
scrollRevelation,
navActivePage
})
|
'use strict';
import * as customFunctions from '../../shared/methods/common-functions.js';
const editEventRESTResource = (app) => {
app.factory('editEventRESTResource', ['$http', ($http) => {
return function(resourceName, callback) {
return {
getSingleEvent: (resourceName, callback) => {
$http.get('/api/fulllist/' + resourceName)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
editEvent: (resourceData, callback) => {
$http.post('/api/editevent', resourceData)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
deleteEvent: (resourceData, callback) => {
$http.delete(`/api/deleteevent/${resourceData}`)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
editTab: (resourceData, callback) => {
$http.post('/api/edittab', resourceData)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
editSpeakers: (resourceData, callback) => {
$http.post('/api/editeventspeakers', resourceData)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
addTab: (resourceData, callback) => {
$http.post('/api/addtab', resourceData)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
deleteTab: (resourceData, callback) => {
$http.delete('/api/deletetab/' + resourceData)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
},
newTabOrder: (resourceData, callback) => {
$http.post('/api/newtaborder', resourceData)
.success(customFunctions.handleSuccess(callback))
.error(customFunctions.handleError(callback));
}
}
}
}])
}
module.exports = editEventRESTResource;
|
/* global describe, it, require */
'use strict';
// MODULES //
var // Expectation library:
chai = require( 'chai' ),
// Check whether an element is a finite number
isFiniteNumber = require( 'validate.io-finite' ),
// Module to be tested:
pdf = require( './../lib/deepset.js' );
// VARIABLES //
var expect = chai.expect,
assert = chai.assert;
// TESTS //
describe( 'deepset pdf', function tests() {
var validationData = require( './fixtures/deepset.json' ),
alpha = validationData.alpha,
beta = validationData.beta;
it( 'should export a function', function test() {
expect( pdf ).to.be.a( 'function' );
});
it( 'should compute the Inverse Gamma pdf and deep set', function test() {
var data, expected, i;
data = validationData.data.map( function( e ) {
return {'x': e};
});
data = pdf( data, alpha, beta, 'x' );
expected = validationData.expected
.map( function( d ) {
if (d === 'Inf' ) {
return Number.POSITIVE_INFINITY;
}
if ( d === '-Inf' ) {
return Number.NEGATIVE_INFINITY;
}
return d;
})
.map( function( d ) {
return {'x': d};
});
for ( i = 0; i < data.length; i++ ) {
if ( isFiniteNumber( data[ i ].x ) && isFiniteNumber( expected[ i ].x ) ) {
assert.closeTo( data[ i ].x, expected[ i ].x, 1e-12 );
}
}
// Custom separator...
data = validationData.data.map( function( e ) {
return {'x': [9, e]};
});
data = pdf( data, alpha, beta, 'x/1', '/' );
expected = validationData.expected
.map( function( d ) {
if (d === 'Inf' ) {
return Number.POSITIVE_INFINITY;
}
if ( d === '-Inf' ) {
return Number.NEGATIVE_INFINITY;
}
return d;
})
.map( function( e ) {
return {'x': [9, e]};
});
for ( i = 0; i < data.length; i++ ) {
if ( isFiniteNumber( data[ i ].x[ 1 ] ) && isFiniteNumber( expected[ i ].x[ 1 ] ) ) {
assert.closeTo( data[ i ].x[ 1 ], expected[ i ].x[ 1 ], 1e-12, 'custom separator' );
}
}
});
it( 'should return an empty array if provided an empty array', function test() {
assert.deepEqual( pdf( [], alpha, beta, 'x' ), [] );
assert.deepEqual( pdf( [], alpha, beta, 'x', '/' ), [] );
});
it( 'should handle non-numeric values by setting the element to NaN', function test() {
var data, actual, expected;
data = [
{'x':true},
{'x':null},
{'x':[]},
{'x':{}}
];
actual = pdf( data, alpha, beta, 'x' );
expected = [
{'x':NaN},
{'x':NaN},
{'x':NaN},
{'x':NaN}
];
assert.deepEqual( data, expected );
});
});
|
$(function() {
$("#loading").hide();
$("#btn-file-input, #img-preview").on('click', function() {
$('#file-input').click();
});
// この写真を送信しますか？
$("#btn-next").on(
'click',
function() {
swalConfirm("", "Submit this picture?", "info", function(e) {
var imgData = $("#img-preview").attr('src');
var cp = {
id: Date.now(),
lat: getParam("lat"),
lon: getParam("lon"),
name: "name",
label: "label",
description: "description",
checkin: false,
markerColor: "red",
category: "",
subcategory: "",
imgSrc: "",
place: ""
};
new JsonRpcClient(new JsonRpcRequest(getBaseUrl(), "addCheckpoint", [getUserId(),
getCourseId(), cp, imgData], function(data) {
updateInitialDataIfNeeded(getCourseId(), function() {
location.href = "checkpoints.html";
});
})).rpc();
});
});
});
function handleFiles(files) {
if (files == null || files.length == 0 || files[0] == null) {
alert("Fail to get image."); // 画像を取得できませんでした
return;
}
var file = files[0];
loadImage.parseMetaData(file, function(data) {
var option = {
maxHeight: $("#task-img").height(),
canvas: true
};
if (data.exif && data.exif.get('Orientation')) {
option.orientation = data.exif.get('Orientation');
}
loadImage(file, function(canvas) {
$("#img-preview").attr('src', canvas.toDataURL("image/jpeg"));
}, option);
});
$("#btn-next").prop("disabled", false);
}
|
angular.module('yummyword.saveWordsController',[])
.controller('SaveWordsController',function($scope,Auth,$state,$firebaseArray, $ionicHistory,Words,MyWords){
$scope.myWords = [];
$scope.showDelete = false;
$scope.authData=null;
Auth.$onAuth(function(authData) {
if (authData === null) {
console.log("Not logged in yet");
} else {
$scope.authData = authData;
MyWords.retrieving(authData.uid, $scope.myWords);
}
});
$scope.goBack=function(){
$ionicHistory.goBack();
};
$scope.goDatailWord=function(saveWords){
$state.go('detailWord',{detail:saveWords});
};
$scope.deleteWord=function(word){
MyWords.deleteWord($scope.authData.uid,word, $scope.myWords);
};
})
.controller('DetailWordController',function($scope,$stateParams){
$scope.definitions=$stateParams.detail.definitions;
$scope.word=$stateParams.detail.word;
console.log($scope.definitions);
})
;
|
'use strict';
angular.module('angularApp', [
'ngRoute'
])
.config(function ($routeProvider) {
$routeProvider
.when('/', {
templateUrl: 'views/main.html',
controller: 'MainCtrl'
})
.otherwise({
redirectTo: '/'
});
});
|
import handyp from "handyp";
module.exports = async (target) => {
await handyp.spawn("npm", ["install"], {
cwd: target
}, (type, info) => {
console.log(`[${type}] ${info.toString()}`);
});
}
|
import {
GraphQLInputObjectType,
GraphQLString,
GraphQLNonNull,
GraphQLInt
} from 'graphql';
export default new GraphQLInputObjectType({
name: 'DeviceInput',
fields: {
type: {
type: GraphQLString
},
state: {
type: GraphQLString
},
node: {
type: GraphQLString
},
name: {
type: GraphQLString
},
topic: {
type: GraphQLString
},
pin: {
type: GraphQLInt
}
}
});
|
import * as React from 'react';
import * as Immutable from 'immutable';
import {connect} from 'react-redux';
import {
getElectronReduxCommState,
} from 'electron-redux-multi-window-comm/selectors';
import styles from './ConfigExample.less';
class ConfigExample extends React.Component {
constructor(props)
{
super(props);
}
render()
{
const {options} = this.props;
return (
<div className={styles.container}>
<pre className={styles.pre} >
{JSON.stringify(options.toJS(), null, 2)}
</pre>
</div>
);
}
}
const mapStateToProps = (state, ownProps) =>
{
const ElectronReduxCommState = getElectronReduxCommState(state);
return {
options: ElectronReduxCommState.getIn(['options'], Immutable.Map())
}
};
export default connect(mapStateToProps)(ConfigExample)
|
module.exports = class extends koahub.controller {
_initialize() {
// 控制器初始化
}
index() {
this.view('Hello World!');
}
detail() {
this.view(this.params.id);
}
}
|
import React from 'react';
import FormRow from './FormRow';
export default class AddPlayerWindow extends React.Component {
render() {
const styles = {
background: {
},
};
// const nameFocus = (this.props.style.visibility === `visible`);
const nameFocus = false;
return (
<div style={this.props.style}>
<div style={styles.background} />
<form onSubmit={this.handleSubmit}>
<FormRow name={`Name`} type={`string`} onChange={this.handleNameChange} focus={nameFocus} />
<FormRow name={`Initial Rank`} type={`number`} onChange={this.handleScoreChange} />
<input type={`submit`} value={`Add`} />
</form>
</div>
);
}
constructor(props) {
super(props);
this.state = {
name: ``,
rank: `0`,
};
}
handleNameChange = event => {
this.setState({
name: event.target.value,
});
}
handleScoreChange = event => {
this.setState({
rank: event.target.value,
});
}
handleSubmit = event => {
this.props.onSubmit();
event.preventDefault();
if (this.state.name.trim().length === 0) return;
const database = this.props.database.ref(`players/`);
database.once(`value`).then(snapshot => {
const players = snapshot.val();
let contains = false;
const keys = Object.keys(players);
for (let i = 0, len = keys.length; i < len; i++) {
if (players[keys[i]].name.toLowerCase() === this.state.name.toLowerCase()) {
contains = true;
break;
}
}
if (!contains) {
const name = this.state.name.substring(0, 1).toUpperCase() + this.state.name.substring(1).toLowerCase();
this.props.database.ref(`players/`).push({
name,
rank: this.state.rank,
});
}
});
}
}
AddPlayerWindow.propTypes = {
style: React.PropTypes.object.isRequired,
onSubmit: React.PropTypes.func.isRequired,
database: React.PropTypes.object.isRequired,
};
|
var React = require('react');
module.exports = React.createClass({
displayName: 'Content',
getInitialState: function() {
return { serverData: null };
},
refreshData: function() {
// replace this with your favourite library for doing ajax calls
var xhr = new XMLHttpRequest();
xhr.open('get', '/api/currentTime', true);
xhr.onload = () => {
var data = JSON.parse(xhr.responseText);
this.setState({ serverData: data.time });
};
xhr.send();
},
render: function () {
return (
<div>
<p>Here are some test Content <b ref='serverResponse'>{ this.state.serverData || 'Click the button to hit the API' }</b></p>
<input ref='refreshButton' type='button' onClick={this.refreshData } value='Hit the server'></input>
</div>
);
}
});
|
/**
* This function sets the size of the background of the full game and the left column
* depending on whether certain abrs are activated
* It is called by CM.Disp.UpdateAscendState() and CM.Disp.UpdateBotTimerBarPosition()
*/
export default function UpdateBackground() {
Game.Background.canvas.width = Game.Background.canvas.parentNode.offsetWidth;
Game.Background.canvas.height = Game.Background.canvas.parentNode.offsetHeight;
Game.LeftBackground.canvas.width = Game.LeftBackground.canvas.parentNode.offsetWidth;
Game.LeftBackground.canvas.height = Game.LeftBackground.canvas.parentNode.offsetHeight;
Game.DrawBackground();
}
|
// @ts-check
const fs = require('./fs');
const npm = require('./npm');
const editorconfig = require('./editorconfig');
const commands = require('./commands');
const MrmError = require('./error');
const file = require('./formats/file');
const ini = require('./formats/ini');
const json = require('./formats/json');
const lines = require('./formats/lines');
const markdown = require('./formats/markdown');
const template = require('./formats/template');
const yaml = require('./formats/yaml');
const packageJson = require('./files/packageJson');
module.exports = {
readFile: fs.readFile,
updateFile: fs.updateFile,
copyFiles: fs.copyFiles,
deleteFiles: fs.deleteFiles,
makeDirs: fs.makeDirs,
init: npm.init,
install: npm.install,
uninstall: npm.uninstall,
inferStyle: editorconfig.inferStyle,
getStyleForFile: editorconfig.getStyleForFile,
getIndent: editorconfig.getIndent,
format: editorconfig.format,
getExtsFromCommand: commands.getExtsFromCommand,
MrmError,
file,
ini,
json,
lines,
markdown,
template,
yaml,
packageJson,
};
|
import React from 'react'
import ReactDOM from 'react-dom'
import {Controller} from 'cerebral'
import Model from 'cerebral/models/immutable'
import Devtools from 'cerebral-module-devtools'
import {Container} from 'cerebral-view-react'
import Forms from 'cerebral-module-forms'
import Simple from './modules/Simple'
import SimpleForm from './components/Simple/Form'
const controller = Controller(Model({}))
controller.addModules({
devtools: Devtools(),
simple: Simple(),
forms: Forms()
})
const ExampleStyle = {
display: 'inline-block',
verticalAlign: 'top',
padding: 20,
margin: 20,
border: '1px solid #333',
backgroundColor: '#fafafa',
fontSize: '.9em'
}
ReactDOM.render(
<Container controller={controller}>
<div>
<div style={ExampleStyle}>
<h1>Simple Form</h1>
<SimpleForm/>
</div>
</div>
</Container>
, document.getElementById('root'))
|
import axios from "axios";
export const VERIFY_PAN = "verify_PAN";
export const FETCH_USERS = "fetch_users";
export const UPLOAD_PAN = "upload_PAN";
export const FETCH_PAN = "fetch_pan";
export function verifyPANDetails(values,id, callback) {
values = JSON.stringify(values)
const request = axios
.post(`http://34.227.56.111/edit_data/${id}/`, values)
.then(() => callback());
return {
type: VERIFY_PAN,
payload: request
};
}
export function getPANDetails(id) {
const request = axios.get(`http://34.227.56.111/verify/${id}/`);
return (dispatch) => {
request.then(({data}) => {
dispatch({ type: FETCH_PAN, payload: data })
});
};
}
export function uploadPAN(id,imageDetails) {
var data = new FormData();
data.append('file', imageDetails[0]);
const request = axios.post(`http://34.227.56.111/upload/${id}/`,data);
return (dispatch) => {
request.then(({data}) => {
dispatch({ type: UPLOAD_PAN, payload: data })
});
};
}
export function fetchUsers() {
const request = axios.get('http://34.227.56.111/user_points/');
return (dispatch) => {
request.then(({data}) => {
dispatch({ type: FETCH_USERS, payload: data })
});
};
}
|
/**
* User Database
* @type {Array}
*/
var users = [
{
username: 'user'
, password: 'password'
, roles: ['user']
},
{
username: 'admin'
, password: 'password'
, roles: ['admin']
},
{
username: 'root'
, password: 'password'
, roles: ['root']
},
{
username: 'mix'
, password: 'password'
, roles: ['admin', 'root']
}
]
|
var strategy = require('..');
describe('passport-hmac', function() {
it('should export Strategy constructor directly from package', function() {
expect(strategy).to.be.a('function');
expect(strategy).to.equal(strategy.Strategy);
});
it('should export Strategy constructor', function() {
expect(strategy.Strategy).to.be.a('function');
});
});
|
riot.tag2('rg-chart', '<canvas></canvas>', 'rg-chart,[data-is="rg-chart"]{ display: inline-block; width: 100%; }', '', function(opts) {
Chart.defaults.global.responsive = true;
this.on('mount', () => {
drawChart();
});
this.on('loaded', c => {
this.on('unmount', () => {
c.destroy();
});
});
const drawChart = () => {
if (!opts.chart) return;
let ctx = this.root.querySelector('canvas').getContext('2d');
let chart = new Chart(ctx);
let c = null;
switch (opts.chart.type) {
case 'line':
c = chart.Line(opts.chart.data, opts.chart.options);
break;
case 'radar':
c = chart.Radar(opts.chart.data, opts.chart.options);
break;
case 'polar':
c = chart.PolarArea(opts.chart.data, opts.chart.options);
break;
case 'pie':
c = chart.Pie(opts.chart.data, opts.chart.options);
break;
case 'doughnut':
c = chart.Doughnut(opts.chart.data, opts.chart.options);
break;
default:
c = chart.Bar(opts.chart.data, opts.chart.options);
break;
}
this.trigger('loaded', c);
};
});
|
version https://git-lfs.github.com/spec/v1
oid sha256:6c4e17952789103335a4ec23a7a153a971c817a6af945a1a5113f73a1cf02d58
size 1936
|
define(["SudokuToGo"], function(SudokuToGo)
{
"use strict";
QUnit.module("SudokuToGo");
QUnit.test("SudokuToGo properties Easy 1", function(assert)
{
var key = SudokuToGo.EASY_1;
var properties = SudokuToGo.properties[key];
assert.equal(properties.name, "Sudoku To Go 001");
assert.equal(properties.grid, "..6..8.74..5...1.99.74.16.5.3.1...46.........16...9.2.2.36.54.87.4...9..68.9..3..");
assert.equal(properties.value, key);
});
QUnit.test("keys and values", function(assert)
{
// Setup.
// Run.
var result = SudokuToGo.values();
var ownPropertyNames = Object.getOwnPropertyNames(SudokuToGo);
// Verify.
ownPropertyNames.forEach(function(key)
{
var key2 = SudokuToGo[key];
if (key !== "properties" && typeof key2 === "string")
{
assert.ok(SudokuToGo.properties[key2], "Missing value for key = " + key);
}
});
result.forEach(function(value)
{
var p = ownPropertyNames.filter(function(key)
{
return SudokuToGo[key] === value;
});
assert.equal(p.length, 1, "Missing key for value = " + value);
});
});
QUnit.test("values()", function(assert)
{
// Run.
var result = SudokuToGo.values();
// Verify.
assert.ok(result);
var length = 9;
assert.equal(result.length, length);
assert.equal(result[0], "easy1");
assert.equal(result[length - 1], "puzzle100");
var properties = Object.getOwnPropertyNames(SudokuToGo);
var count = properties.length - 1 - // properties
1 - // values
1 - // createEasy1Solution
1; // createDiabolical86Solution
assert.equal(result.length, count);
});
});
|
//abstract class for feed service
define([], function() {
//need the service
var self;
ServiceFeed = function(service,config) {
this._service = service;
this._config = config;
this.init();
self = this;
};
ServiceFeed.prototype.init = function() {
};
ServiceFeed.prototype.getYqlUrl = function() {
throw new Error('ServiceFeed#getYqlUrl must be overridden by subclass if to use');
};
ServiceFeed.prototype.getJsonUrl = function() {
throw new Error('ServiceFeed#getJsonUrl must be overridden by subclass if to use');
};
ServiceFeed.prototype.load = function() {
//TODO refactor
var promise=null;
console.log(self._config);
if(self._config.isYql){
promise = self._service.jsonpYql(self.getYqlUrl(), self.parse.bind(self),self._config);
}
else{
promise = self._service.loadJsonUrl(self.getJsonUrl(),self.parse.bind(self), self._config);
}
return {
"promise": promise
};
};
//TODO
//separate parse & DOM gen
ServiceFeed.prototype.parse = function() {
throw new Error('ServiceFeed#parse must be overridden by subclass');
};
//util TODO extract
ServiceFeed.parseYqlRes = function(query){
return query.data.query;
}
//factory to create ServiceFeed using this abstract feed as prototype
ServiceFeed.factory = function() {
var CreatedServiceFeed = function(service, config) {
ServiceFeed.call(this, service, config);
};
CreatedServiceFeed.prototype = Object.create(ServiceFeed.prototype);
CreatedServiceFeed.constructor = CreatedServiceFeed;
return CreatedServiceFeed;
};
//register itself?
return ServiceFeed;
});
|
"use strict";
sabio.services.blog = sabio.services.blog || {};
sabio.services.blog.post = function (blog, onSuccess, onError) {
var url = "/api/blogs";
var settings = {
cache: false,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
dataType: "json",
data: blog,
success: onSuccess,
error: onError,
type: "POST"
};
$.ajax(url, settings);
};
sabio.services.blog.put = function (id, blog, onSuccess, onError) {
var url = "/api/blogs/" + id;
var settings = {
cache: false,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
dataType: "json",
data: blog + "&id=" + id,
success: onSuccess,
error: onError,
type: "PUT"
};
$.ajax(url, settings);
};
sabio.services.blog.getById = function (id, onSuccess, onError) {
var url = "/api/blogs/" + id;
var settings = {
cache: false,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
dataType: "json",
success: onSuccess,
error: onError,
type: "GET"
};
$.ajax(url, settings);
};
sabio.services.blog.getAll = function (onSuccess, onError) {
var url = "/api/blogs";
var settings = {
cache: false,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
dataType: "json",
success: onSuccess,
error: onError,
type: "GET"
};
$.ajax(url, settings);
};
sabio.services.blog["delete"] = function (id, onSuccess, onError) {
var url = "/api/blogs/" + id;
var settings = {
cache: false,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
dataType: "json",
success: onSuccess,
error: onError,
type: "DELETE"
};
$.ajax(url, settings);
};
sabio.services.blog.search = function (searchStr, blogCategory, currentPage, itemsPerPage, onSuccess, onError) {
var url = "/api/blogs/search?SearchStr=" + searchStr + "&category=" + blogCategory + "&CurrentPage=" + currentPage + "&ItemsPerPage=" + itemsPerPage;
var settings = {
cache: false,
success: onSuccess,
error: onError,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
type: "GET"
};
$.ajax(url, settings);
};
sabio.services.blog.postJson = function (blog, onSuccess, onError) {
var url = "/api/blogs";
var settings = {
cache: false,
contentType: "application/json; charset=UTF-8",
dataType: "json",
data: JSON.stringify(blog),
success: onSuccess,
error: onError,
type: "POST"
};
$.ajax(url, settings);
};
sabio.services.blog.putJson = function (id, blog, onSuccess, onError) {
blog.id = id;
var url = "/api/blogs/" + id;
var settings = {
cache: false,
contentType: "application/Json; charset=UTF-8",
dataType: "json",
data: JSON.stringify(blog),
success: onSuccess,
error: onError,
type: "PUT"
};
$.ajax(url, settings);
};
sabio.services.blog.getByIdJson = function (id, onSuccess, onError) {
var url = "/api/blogs/" + id;
var settings = {
cache: false,
contentType: "application/Json; charset=UTF-8",
dataType: "json",
success: onSuccess,
error: onError,
type: "GET"
};
$.ajax(url, settings);
};
sabio.services.blog.getAllJson = function (onSuccess, onError) {
var url = "/api/blogs";
var settings = {
cache: false,
contentType: "application/Json; charset=UTF-8",
dataType: "json",
success: onSuccess,
error: onError,
type: "GET"
};
$.ajax(url, settings);
};
sabio.services.blog.deleteJson = function (id, onSuccess, onError) {
var url = "/api/blogs/" + id;
var settings = {
cache: false,
contentType: "application/Json; charset=UTF-8",
dataType: "json",
success: onSuccess,
error: onError,
type: "DELETE"
};
$.ajax(url, settings);
};
|
"use strict";
const runPrettier = require("../runPrettier");
describe("ignore path", () => {
runPrettier("cli/ignore-path", [
"**/*.js",
"--ignore-path",
".gitignore",
"-l"
]).test({
status: 1
});
});
describe("support .prettierignore", () => {
runPrettier("cli/ignore-path", ["**/*.js", "-l"]).test({
status: 1
});
});
describe("ignore file when using --debug-check", () => {
runPrettier("cli/ignore-path", ["**/*.js", "--debug-check"]).test({
status: 0
});
});
describe("outputs files as-is if no --write", () => {
runPrettier("cli/ignore-path", ["regular-module.js"], {
ignoreLineEndings: true
}).test({
status: 0
});
});
|
var animName = 'my-animation';
var a = <style>
@keyframes {{animName}} {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
</style>;
|
var util = require('util'),
dateFormat = require('dateformat'),
clc = require('cli-color');
/**
* Create new Log instance that will print to the console with following template:
* [date] [context] MSG
*
* @param context May be module name or anything that indicate where's it logged
* @constructor
*/
function Log(context) {
this._context = context;
}
Log.prototype = {
_context: '',
/**
* Format and return a message string (formatted) with addition format
*
* @param (format [, ..., ...])
* Message will log with format follow by NodeJS's util.format() syntax
* @returns {String}
* Message string
*/
_logString: function() {
var __msg = arguments[0];
var __args = Array.prototype.slice.call(arguments);
__args.splice(0, 1); // remove first element
__args.unshift(this._context);
__args.unshift(dateFormat(new Date(), 'yyyy-mm-dd hh:MM:ss'));
__args.unshift('[%s] [%s] ' + __msg);
return util.format.apply(util, __args);
},
/**
* Print log information
*
* @param (format [, ..., ...])
* Message will log with format follow by NodeJS's util.format() syntax
*/
info: function() {
console.log(this._logString.apply(this, arguments));
},
/**
* Print log & stack trace for error message. Error message color are red
*
* @param (format [, ..., ...])
* Message will log with format follow by NodeJS's util.format() syntax
*/
error: function() {
console.log(clc.red(this._logString.apply(this, arguments)));
console.trace();
},
/**
* Print log for warning message. Text color are yellow
*
* @param (format [, ..., ...])
* Message will log with format follow by NodeJS's util.format() syntax
*/
warn: function() {
console.log(clc.yellow(this._logString.apply(this, arguments)));
}
};
/**
* Get single instance of Log class
*
* @param context May be module name or anything that indicate where's it logged
* @returns {Log} Instance of Log
*/
exports.getInstance = function(context) {
return new Log(context);
};
|
// Same as 18.js
var fs = require('fs'),
util = require('util'),
maxPath = require('./18').maxPath,
content = fs.readFileSync('67.txt', 'utf8');
// Print result
util.print(maxPath(content));
// Execution time: 8ms
|
function Asteroid(pos) {
var loader = new THREE.JSONLoader();
this.position = pos;
this.mesh;
this.self = this;
this.load = function() {
onLoadObject = function (geometry) {
self.mesh = new THREE.Mesh( geometry, new THREE.MeshFaceMaterial());
scene.add( self.mesh );
loading = false;
}
loading = true;
loader.load('js/yellow_aste.js', onLoadObject);
}
this.getPosition = function () {
//alert(self.mesh.position.toSource());
return self.mesh.matrix.getPosition();
}
this.getPosition = function() {
return self.mesh.position.clone;
}
this.setPosition = function(pos) {
var movement = pos.subSelf(self.mesh.matrix.getPosition());
self.mesh.matrix.translate( movement.length() , movement);
}
this.update = function(elapsedTime) {
}
this.draw = function() {
//self.mesh.matrix.translate(new THREE.Vector3(10,0,0));
//self.mesh.updateMatrix();
self.mesh.position.x += 10;
}
}
|
import Ember from 'ember';
export default Ember.Route.extend({
redirect: function() {
this.get('authentication').logout();
}
});
|
function hipotenusa() {
let h1 = prompt('Dame primer cateto: ')
let h2 = prompt('Dame segundo cateto: ')
let h = Math.hypot(h1, h2)
return h
}
document.write(hipotenusa())
|
var name = 'zfpx',age=8;
/**
* 模板字符串 变量用${}包括起来
*/
//console.log(name);
let desc = `${name}
今年 ${age}
周年!`;
console.log(desc);
|
Ext.define('FastUI.view.vfield.VFile',{
extend: 'Ext.form.field.File',
valueObject: {},
winCtx:{},
winId:0,
rest:{},
buttonText: '',
buttonConfig: {
iconCls: 'fastui-upload'
},
initComponent:function(){
this.fieldLabel = this.getFValue('title');
this.name = this.rest.getTableName() + '[' + this.getFValue('m_property').name + ']';
this.disabled = this.getFValue('is_readonly');
this.allowBlank = true;
this.callParent();
},
getFValue:function (key) {
return this.valueObject[key];
}
});
|
import { AUTH_USER, UNAUTH_USER, AUTH_ERROR } from '../actions/types';
export default function (state = {}, action) {
switch (action.type) {
case AUTH_USER:
return { ...state, authenticated: true };
case UNAUTH_USER:
return { ...state, authenticated: false };
case AUTH_ERROR:
return { ...state, error: action.payload };
default:
return state;
}
}
|
module.exports = {
index: (req, res) => {
"use strict";
res.render('home/index')
},
about: (req, res) => {
"use strict";
res.render('home/about')
}
}
|
var svg = require('virtual-dom/virtual-hyperscript/svg')
var extend = require('xtend')
exports.render = function renderIcon (style) {
style = extend({
height: '20px'
}, style || {})
// Android 4.2- require explicit width *and* height
if (style.height && !style.width) {
style.width = style.height // it's a square
}
var options = {
style: style,
viewBox: [0, 0, 18, 18].join(' ')
}
return svg('svg', options, [
svg('g', {id: 'Google-Button', stroke: 'none', 'stroke-width': '1', fill: 'none', 'fill-rule': 'evenodd', 'sketch:type': 'MSPage'}, [
svg('g', {id: 'logo_googleg_48dp', 'sketch:type': 'MSLayerGroup'}, [
svg('path', {d: 'M17.64,9.20454545 C17.64,8.56636364 17.5827273,7.95272727 17.4763636,7.36363636 L9,7.36363636 L9,10.845 L13.8436364,10.845 C13.635,11.97 13.0009091,12.9231818 12.0477273,13.5613636 L12.0477273,15.8195455 L14.9563636,15.8195455 C16.6581818,14.2527273 17.64,11.9454545 17.64,9.20454545 L17.64,9.20454545 Z', id: 'Shape', fill: '#4285F4', 'sketch:type': 'MSShapeGroup'}),
svg('path', {d: 'M9,18 C11.43,18 13.4672727,17.1940909 14.9563636,15.8195455 L12.0477273,13.5613636 C11.2418182,14.1013636 10.2109091,14.4204545 9,14.4204545 C6.65590909,14.4204545 4.67181818,12.8372727 3.96409091,10.71 L0.957272727,10.71 L0.957272727,13.0418182 C2.43818182,15.9831818 5.48181818,18 9,18 L9,18 Z', id: 'Shape', fill: '#34A853', 'sketch:type': 'MSShapeGroup'}),
svg('path', {d: 'M3.96409091,10.71 C3.78409091,10.17 3.68181818,9.59318182 3.68181818,9 C3.68181818,8.40681818 3.78409091,7.83 3.96409091,7.29 L3.96409091,4.95818182 L0.957272727,4.95818182 C0.347727273,6.17318182 0,7.54772727 0,9 C0,10.4522727 0.347727273,11.8268182 0.957272727,13.0418182 L3.96409091,10.71 L3.96409091,10.71 Z', id: 'Shape', fill: '#FBBC05', 'sketch:type': 'MSShapeGroup'}),
svg('path', {d: 'M9,3.57954545 C10.3213636,3.57954545 11.5077273,4.03363636 12.4404545,4.92545455 L15.0218182,2.34409091 C13.4631818,0.891818182 11.4259091,0 9,0 C5.48181818,0 2.43818182,2.01681818 0.957272727,4.95818182 L3.96409091,7.29 C4.67181818,5.16272727 6.65590909,3.57954545 9,3.57954545 L9,3.57954545 Z', id: 'Shape', fill: '#EA4335', 'sketch:type': 'MSShapeGroup'}),
svg('path', {d: 'M0,0 L18,0 L18,18 L0,18 L0,0 Z', id: 'Shape', 'sketch:type': 'MSShapeGroup'})
])
])
])
}
|
import antdEn from 'antd/lib/locale-provider/en_US';
import appLocaleData from 'react-intl/locale-data/en';
import enMessages from './en.json';
window.appLocale = {
messages: {
...enMessages,
},
antd: antdEn,
locale: 'en-US',
data: appLocaleData,
};
|
import should from 'should' // eslint-disable-line no-unused-vars
import { selectUserFeedPhotos } from './userFeedPhotos'
describe('selector: userFeedPhotos', () => {
const state = {
userFeed: {
photos: [1, 2, 3, 4, 5, 6]
}
}
it('return expected state', () => {
selectUserFeedPhotos(state).should.be.eql([1, 2, 3, 4, 5])
})
})
|
import {combineReducers} from 'redux';
import modalToggle from './modalToggle';
const exampleApp = combineReducers({
modalToggle
});
export default exampleApp;
|
var React = require('react');
var FluxCartActions = require('../actions/FluxCartActions');
// Flux product view
var FluxProduct = React.createClass({
// Add item to cart
addToCart: function(event) {
console.log('[FluxProduct.react] Adding item to cart');
var sku = this.props.selected.sku;
var update = {
name: this.props.product.name,
type: this.props.selected.type,
price: this.props.selected.price
};
FluxCartActions.addToCart(sku, update);
FluxCartActions.updateCartVisible(true);
},
// Select product variant
selectVariant: function(event) {
console.log('[FluxProduct.react] Selecting product variant');
FluxCartActions.selectProduct(event.target.value);
},
// Render product view
render: function() {
console.log('[FluxProduct.react] Rendering view');
var numAvailable = (this.props.selected.sku in this.props.cartItems) ?
this.props.selected.inventory - this.props.cartItems[this.props.selected.sku].quantity :
this.props.selected.inventory;
return (
<div className="flux-product">
<img src={'img/' + this.props.product.image} />
<div className="flux-product-detail">
<h1 className="name">{this.props.product.name}</h1>
<p className="description">{this.props.product.description}</p>
<p className="price">Price: ${this.props.selected.price}</p>
<select onChange={this.selectVariant}>
{this.props.product.variants.map(function(variant, index) {
return (
<option key={index} value={index}>{variant.type}</option>
)
})}
</select>
<button type="button" onClick={this.addToCart} disabled={numAvailable > 0 ? '' : 'disabled'}>
{numAvailable > 0 ? 'Add To Cart' : 'Sold Out'}
</button>
</div>
</div>
);
},
});
module.exports = FluxProduct;
|
'use strict';
const jwt = require('jsonwebtoken');
const { CODE_OK, CODE_PASSWORD_INCORRECT } = require('../../../common/common');
const config = require('../../config');
const logger = require('../../logger');
const User = require('../../model/User/User');
const generateToken = ({ username, nonce, secret, expireTime }) => {
const payload = { username, nonce };
return jwt.sign(payload, secret, { expiresIn: expireTime });
};
/* Include client-generated nonce in JWT.
The client validates it once received from the server.
https://auth0.com/docs/api-auth/tutorials/nonce */
const signIn = async ({ request, connection }) => {
const { username, password, nonce } = request;
const { code } = await User.authenticate(username, password);
if (code !== CODE_OK) {
logger.debug(`User ${username} failed to authenticate: ${code}`);
return {
code: CODE_PASSWORD_INCORRECT,
status: 'Špatné jméno či heslo. Uživatel může být též zamčený.',
};
}
connection.onAuth({ authenticated: true, username });
return {
code: CODE_OK,
status: undefined,
response: {
username,
token: generateToken({
username,
nonce,
secret: config.jwt.secret,
expireTime: config.jwt.expireTime,
}),
},
};
};
module.exports = signIn;
|
angular.module('Northwind', ['ui.router','foundation', 'foundation.common', 'ngAnimate', 'ngCookies', 'ngResource', 'ngMessages', 'mm.foundation'])
.config(function ($stateProvider, $urlRouterProvider, $locationProvider) {
$urlRouterProvider.when('', '/');
$urlRouterProvider.otherwise('/landing');
$locationProvider.html5Mode(true);
$stateProvider
.state('start', {
abstract: true,
templateUrl: 'assets/landing.html',
controller: 'dashController',
controllerAs: 'Ctrl'
})
.state('start.dash', {
url: '/landing',
views: {
'dash': {
templateUrl: 'assets/dashboard.html'
},
'details': {
templateUrl: 'assets/details.html'
}
}
})
// .state('add', {
// url: '/add',
// templateUrl: 'assets/addModal.html',
// controller: 'addFormController',
// controllerAs: 'addCtrl'
// })
})
|
var dust = require('../../')._
dust.helpers.upper = function (chunk, ctx, bodies, params) {
var sentence = dust.helpers.tap(params.value, chunk, ctx)
return chunk.w(sentence.toUpperCase())
}
|
/** @module models/User **/
'use strict';
const mongoose = require('mongoose');
const ObjectId = mongoose.Schema.Types.ObjectId;
/** @constructor
* @augments UserSchemaInstance
* @param {Object} definition
*/
const UserSchema = new mongoose.Schema({
username : { type: String, required:true},
password : {type:String, required:true}
});
mongoose.model('User', UserSchema);
|
/* eslint-env mocha */
import should from 'should';
import config from '../test-config.js';
import {
openDb,
getDb,
closeDb,
importGtfs,
getStoptimes,
} from '../../index.js';
describe('getStoptimes():', () => {
before(async () => {
await openDb(config);
await importGtfs(config);
});
after(async () => {
const db = getDb(config);
await closeDb(db);
});
it('should return an empty array if no stoptimes exist for given agency', async () => {
const stopId = 'fake-stop-id';
const results = await getStoptimes({
stop_id: stopId,
});
should.exists(results);
results.should.have.length(0);
});
it('should return array of stoptimes for given stop_id', async () => {
const stopId = '70011';
const results = await getStoptimes({
stop_id: stopId,
});
should.exist(results);
results.should.have.length(80);
for (const result of results) {
result.stop_id.should.equal(stopId);
}
});
it('should return array of stoptimes for given trip_id ordered by stop_sequence', async () => {
const tripId = '421a';
const results = await getStoptimes(
{
trip_id: tripId,
},
[],
[['stop_sequence', 'ASC']]
);
should.exist(results);
results.should.have.length(24);
let lastStopSequence;
for (const result of results) {
result.trip_id.should.equal(tripId);
if (lastStopSequence !== undefined) {
result.stop_sequence.should.be.greaterThan(lastStopSequence);
}
lastStopSequence = result.stop_sequence;
}
});
});
|
angular.module("sim/ui/Explore.js", [
"sim/model/Mode.js",
"sim/ui/ActionBar.js"
]).
controller("Explore", Explore);
angular.module("sim/Simulation.js").
directive("explore", function () {
return {
restrict: "E",
scope: {
mode: "=",
player: "="
},
templateUrl: "ui/Explore.html"
}
});
function Explore($scope) {
// TODO(philharnish): Watching for changes is not ideal.
$scope.$watch("mode", function (mode) {
if (mode) {
var map = mode.parseActionList(Explore.ACTION_LIST);
$scope.actions = map.list;
map.fight.enabled = fightEnabled;
}
});
function fightEnabled() {
return $scope.player.inventory.has("weapon");
}
}
Explore.ACTION_LIST = [
{
name: "fight"
},
{
name: "flight"
}
];
|
export default {
key: 'Db',
suffix: 'mmaj7',
positions: [
{
frets: '1103',
fingers: '1204'
},
{
frets: '5444',
fingers: '2111',
barres: 4,
capo: true
},
{
frets: '6443',
fingers: '4221',
barres: 4
},
{
frets: '6887',
fingers: '1342'
}
]
};
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { graphql } from 'react-apollo'
import orderBy from 'lodash/orderBy'
import some from 'lodash/some'
import ChatListItem from './ChatListItem'
import Colors from '../utils/Colors';
import { FIRSTLOAD_CHATROOMS_QUERY, MORE_CHATROOMS_QUERY } from '../graphql/PublicChatrooms'
import { CHATROOM_STATE_TYPES } from '../constants'
import { computeSlugFromChatTitleAndID } from '../utils/misc'
// Change number of chats first load/ loadmore in constants.js
class ChatList extends Component {
static propTypes = {
onClickChatroom: PropTypes.func.isRequired,
initialChatroom: PropTypes.object,
currentRoomId: PropTypes.string,
sortedBy: PropTypes.string.isRequired,
dateDisplayFunction: PropTypes.func.isRequired,
};
render() {
const {
loading,
error,
allChatrooms,
_allChatroomsMeta,
onClickChatroom,
loadMoreEntries,
noMore,
currentRoomId,
dateDisplayFunction
} = this.props;
if (loading) return <div style={{ margin: '8px'}}>Loading</div>
if (error) return <div style={{ margin: '8px'}}>Error</div>
if (allChatrooms) {
if (allChatrooms.length === 0) return <div>No chats yet 😂</div>
return (
<div>
<ul style={{ listStyle: 'none', padding: 0 }}>
{allChatrooms.map((chat) => {
const computedSlug = computeSlugFromChatTitleAndID(chat.title, chat.id)
return (
<div key={chat.id}>
<li className="main" onClick={() => onClickChatroom(computedSlug)}>
<ChatListItem
id={chat.id}
title={chat.title}
count={chat._messagesMeta.count}
displayDate={dateDisplayFunction(chat)}
active={chat.id === currentRoomId}
/>
</li>
<style jsx>{`
.main {
cursor: pointer;
background-color: white;
}
.main:hover {
background-color: ${Colors.lightGrey};
}
`}</style>
</div>
)
})}
</ul>
{!noMore ?
<div onClick={loadMoreEntries} style={{ color: 'blue', textAlign: 'center', cursor: 'pointer' }}>load more</div>
:
<div style={{ color: 'gray', textAlign: 'center', fontSize: '14px', marginTop: '20px' }}>{_allChatroomsMeta.count} talk{_allChatroomsMeta.count !== 1 && 's'}</div>}
</div>
)
}
return <div>Something wrong, this shouldn't show.</div>
}
}
export default graphql(FIRSTLOAD_CHATROOMS_QUERY, {
options: props => {
return {
variables: {
orderBy: props.sortedBy,
}
}
},
props(receivedProps) {
const { ownProps: { initialChatroom, sortedBy } } = receivedProps
const { data: { loading, error, _allChatroomsMeta, fetchMore } } = receivedProps
let allChatrooms = receivedProps.data.allChatrooms
// Transform props
// ---------------
// The return props will be the available props.
// (this is called everytime data is changed, so allChatrooms might be undefined at first load)
let cursor;
let noMore = false;
if (allChatrooms) {
cursor = allChatrooms.length > 0 ? allChatrooms[allChatrooms.length-1].id : null
noMore = allChatrooms.length === _allChatroomsMeta.count
}
let allChatroomsWithInitial = allChatrooms
// Show to public only active/closed
if (sortedBy === 'new' && initialChatroom && (initialChatroom.stateType === CHATROOM_STATE_TYPES.active || initialChatroom.stateType === CHATROOM_STATE_TYPES.closed)) {
// **Append initialChat only when it doesn't already exist in allChatrooms.
if (!some(allChatrooms, { id: initialChatroom.id })) {
allChatroomsWithInitial = orderBy([...allChatrooms, initialChatroom], 'createdAt', 'desc')
}
}
return {
loading,
allChatrooms: allChatroomsWithInitial,
_allChatroomsMeta,
error,
noMore: noMore,
loadMoreEntries: () => {
return fetchMore({
query: MORE_CHATROOMS_QUERY,
variables: {
after: cursor,
orderBy: sortedBy,
},
updateQuery: (previousResult, { fetchMoreResult }) => {
const previousChatrooms = previousResult.allChatrooms
const newChatrooms = fetchMoreResult.allChatrooms
const count = newChatrooms.length
const newCursor = noMore ? fetchMoreResult.allChatrooms[count - 1].id : cursor
return {
cursor: newCursor,
allChatrooms: [...previousChatrooms, ...newChatrooms],
_allChatroomsMeta: previousResult._allChatroomsMeta, // use static count of chatrooms for now
}
}
})
}
}
}
})(ChatList)
|
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const firstRun = require("first-run");
const site_entity_1 = require("./entities/site.entity");
const design_entity_1 = require("./entities/design.entity");
function installSite(connection, main, editor) {
return __awaiter(this, void 0, void 0, function* () {
if (firstRun()) {
const siteSettings = new site_entity_1.Site();
const design = new design_entity_1.Design();
siteSettings.name = "David Gould Photography";
siteSettings.email = "[email protected]";
siteSettings.cover = "/media/default-cover.jpg";
const siteRepo = connection.getRepository(site_entity_1.Site);
const designRepo = connection.getRepository(design_entity_1.Design);
yield siteRepo.persist(siteSettings);
yield designRepo.persist({});
main.set("siteMetadata", {
name: siteSettings.name,
email: siteSettings.email,
cover: siteSettings.cover
});
}
else {
console.log("Installed: true");
const siteSettings = yield connection.getRepository(site_entity_1.Site).findOne({ id: 1 });
const renderMetadata = {
name: siteSettings.name,
email: siteSettings.email,
cover: siteSettings.cover
};
main.set("siteMetadata", renderMetadata);
}
//Testing always clears
//firstRun.clear();
});
}
exports.installSite = installSite;
|
var util = require('util');
var net = require("net");
var EventEmitter = require('events').EventEmitter;
function start(options) {
var result = new EventEmitter();
net.createServer(accept).listen(options.proxyPort);
function accept(proxySocket) {
var client = {}; // tag for customer
result.emit('connect', client);
var connected = false;
var buffers = new Array();
var serviceSocket = new net.Socket();
serviceSocket.connect(options.servicePort, options.serviceHost,
function() {
connected = true;
if (buffers.length > 0) {
for (i = 0; i < buffers.length; i++) {
serviceSocket.write(buffers[i]);
}
}
});
proxySocket.on("error", function(e) {
serviceSocket.end();
});
serviceSocket.on("error", function(e) {
console.error("Could not connect to service at host "
+ options.serviceHost + ', port ' + options.servicePort);
proxySocket.end();
});
proxySocket.on("data", function(data) {
result.emit('clientToServer', client, data);
if (connected) {
serviceSocket.write(data);
} else {
buffers[buffers.length] = data;
}
});
serviceSocket.on("data", function(data) {
result.emit('serverToClient', client, data);
proxySocket.write(data);
});
proxySocket.on("close", function(had_error) {
console.log('connection closed by client');
serviceSocket.end();
});
serviceSocket.on("close", function(had_error) {
console.log('connection closed by server');
proxySocket.end();
});
}
return result;
}
exports.start = start;
|
const app = require('../source/server/app.js').default
app.run()
|
var YoutubeExtactor = require('./extractors/youtube'),
VimeoExtractor = require('./extractors/vimeo'),
DailymotionExtractor = require('./extractors/dailymotion'),
VeohExtractor = require('./extractors/veoh'),
VevoExtractor = require('./extractors/vevo'),
YahooExtractor = require('./extractors/yahoo'),
config = require('./config/config');
module.exports = {
Youtube: new YoutubeExtactor(),
Yahoo: new YahooExtractor(config),
Vimeo: new VimeoExtractor(config),
Vevo: new VevoExtractor(config),
Veoh: new VeohExtractor(config),
Dailymotion: new DailymotionExtractor(config)
};
|
/**
* Created by Argon on 03.10.14.
*/
/*!
* sarcasm.js
* http://4rg0n.github.io/sarcasm.js
* MIT licensed
*
* Copyright (C) 2014 Dominic Rönicke
*/
//Initialize sarcasm.js
SarcasmJs.initialize({
//see README.md for configuration
});
|
/*
*
* DialPad reducer
*
*/
import { fromJS } from 'immutable';
import {
ADD_DIGIT,
REMOVE_DIGIT,
} from './constants';
const initialState = fromJS({
phoneNumber: '',
});
function dialPadReducer(state = initialState, action) {
switch (action.type) {
case ADD_DIGIT:
return state
.set('phoneNumber', state.get('phoneNumber').concat(action.number));
case REMOVE_DIGIT:
return state
.set('phoneNumber', state.get('phoneNumber').slice(0, -1));
default:
return state;
}
}
export default dialPadReducer;
|
/*
Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
For licensing, see license.txt or http://cksource.com/ckfinder/license
*/
CKFinder.customConfig = function( config )
{
// Define changes to default configuration here.
// For the list of available options, check:
// http://docs.cksource.com/ckfinder_2.x_api/symbols/CKFinder.config.html
// Sample configuration options:
// config.uiColor = '#BDE31E';
// config.language = 'fr';
// config.removePlugins = 'basket';
config.removePlugins = 'help,basket';
};
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.