setup: function () {
/* jshint ignore:start */
var numberOfItems = 10000;
var filteredCount = this.results.attr('numberOfItems');
var values = this.makeArray(numberOfItems);
var source = new can.List();
values.forEach(function (element, index) {
if (index < filteredCount) {
element.completed = true;
} else {
element.completed = false;
}
source.push(element);
});
var element = source.attr(numberOfItems - 1);
var filtered = source.dFilter(this.makePredicateFn());
var renderer = can.stache(
"<ul>\n{{#each filtered}}\n<li></li>\n{{/each}}\n</ul>");
var fragment = renderer({
filtered: filtered
});
$(this.sandboxEl).html(fragment);
/* jshint ignore:end */
},
setup: function () {
/* jshint ignore:start */
var numberOfItems = this.results.attr('numberOfItems');
var values = this.makeArray(numberOfItems);
var source = new can.List();
values.forEach(function (element) {
source.push(element);
});
var updateIndex = source.attr('length') - 1;
var element = source.attr(updateIndex);
var filtered = source.dFilter(this.makePredicateFn());
var renderer = can.stache(
"<ul>\n{{#each filtered}}\n<li></li>\n{{/each}}\n</ul>");
var fragment = renderer({
filtered: filtered
});
$('#sandbox').html(fragment);
/* jshint ignore:end */
},
template: function (data, options) {
// fetch a subtemplate content from datagrid tag
var fragment = document.createDocumentFragment();
var element = document.createElement('div');
fragment.appendChild(element);
options.attr('tags').content(element, {
scope: data,
options: options
});
if (data.attr('embedded') === 'true' ) {
data.attr('config.embedded', true);
}
data.attr('config').processControlDocumentFragment(fragment);
var classes = 'datagrid-layout';
classes += ' {{#if config.visibleForm}}collapsed{{/if}}';
classes += ' {{#if config.embedded}}embedded{{/if}}';
classes += ' {{#if config.formConfig}}has-form{{/if}}';
var html = '<div class="' + classes + '">';
html += '<div class="datagrid-header"><h4>{{title}}</h4>';
html += '{{#if config.allowInsert}}<button can-click="showInsertForm" class="btn small right primary insert">Insert</button>{{/if}}';
data.attr('config').actions.each(function(action) {
html += action.getTopTemplate();
});
html += '</div>';
html += '<div class="datagrid">';
html += '<loader data-name="datagrid-loader"></loader>';
html += '<div class="datagrid-table">';
html += '<datagrid-filters config="{config.filtersConfig}"></datagrid-filters>';
html += '<datagrid-pagination config="{config.pagination}"></datagrid-pagination>';
html += '<datagrid-table config="{config}"></datagrid-table>';
html += '<datagrid-pagination config="{config.pagination}"></datagrid-pagination>';
html += '</div>';
html += '</div>';
html += '{{#if config.visibleForm}}<div class="datagrid-edit-form">';
html += '<div class="overlay"></div>';
html += '<div class="edit-form-window"><st-form config="{config.formConfig}" visible-form="{config.visibleForm}"></st-form></div>';
html += '</div>{{/if}}';
html += '</div>';
return can.stache(html)(data, options);
},
beforeEach: function () {
template = can.stache('<bitstrap-dropdown items="{items}" button-label="test"></bitstrap-dropdown>');
$('#qunit-fixture').append(template({}));
$component = $('bitstrap-dropdown',$('#qunit-fixture') );
vm = can.viewModel($component);
var items = new can.List([{label:'test'},{label:'hello'}]);
vm.attr('items', items);
}
template: function(data, helpers) {
var filters = data.attr('config').filters;
if (!can.isEmptyObject(filters.attr())) { //There are some filters to render
var html = '<div class="datagrid-filters">';
filters.each(function(filter){
html += ' <div class="form-group filter-'+filter.name+'" data-filter-type="' + filter.type + '">' + filter.getLabelTemplate() + filter.getTemplate();
if (filter.name === 'search') {
html += '<button class="icon-search search-input-toggle"></button>';
}
html += '</div>'; //end of .form-group
});
html += '</div>'; //end of .datagrid-filters
return can.stache(html)(data, helpers);
} else {
return ''; //No filters -> nothing to render
}
},
QUnit.test('Create button is disabled while posting data', function () {
var expectingRequest = true;
var frag = can.stache('<tournament-list {app-state}="appState" {tournament}="tournament" />')({
appState: {
isAdmin: true
},
tournament: {
name: 'Ballderdash',
date: '01/21/1987'
}
});
var resolveRequest;
fixture('POST /services/tournaments', function (req, res) {
ok(expectingRequest, 'Request was made');
// Determine when the request resolves, later
resolveRequest = res;
// The request should only be made once
expectingRequest = false;
});
$('#qunit-fixture').html(frag);
// Click the button multiple times and ensure it's disabled
// during requests
F('tournament-list .create-btn')
.visible('Create button is visible')
.attr('disabled', undefined, 'Create button is enabled')
.click()
.attr('disabled', 'disabled', 'Create button is disabled after click')
.click()
.then(function () {
resolveRequest({});
})
.attr('disabled', undefined,
'Create button is enabled after the request is resolved');
});
QUnit.test('Form is only shown to admins', function () {
var session = new Session({
user: {
isAdmin: false
}
});
var frag = can.stache('<player-edit {session}="session" />')({
session: session
});
$('#qunit-fixture').html(frag);
F('player-edit .edit-form')
.missing('Edit form is excluded for non-admin user')
.then(function () {
session.attr('user', {
isAdmin: true
});
})
.exists('Edit form is included for admin user');
});
import $ from "jquery";
import F from "funcunit";
F.attach(QUnit);
QUnit.module("bit-tabs view model");
QUnit.test("basics", function(){
var tabsVM = new BitTabsVM();
var panelVM = new BitPanelVM();
tabsVM.addPanel(panelVM);
equal(panelVM.attr("active"), true, "first panel added is active");
});
var template = can.stache("<bit-tabs tabs-class='nav nav-tabs'><bit-panel title='First'>Hello!</bit-panel><bit-panel title='Second'>Another</bit-panel></bit-tabs>");
QUnit.module("bit-tabs component",{
setup: function(){
$("#qunit-fixture").append(template());
}
});
QUnit.test("basics", function(){
F("bit-tabs ul li").text(/First/, "has text");
F("bit-tabs ul").hasClass("nav", true).hasClass("nav-tabs", true, "tabsClass gets assigned to ul");
});
QUnit.test("clicking works", function(){
F("bit-tabs li:nth(1)").click();
F("bit-panel:nth(1)").text("Another", "Correct text shown");
import fixtures from "../../fixtures/fixture_data.json";
import can from "can";
import $ from "jquery";
import Bit from "../../models/bit";
import "../../bits_vertical_infinite/";
import "./custom_bit";
var bitData = new Bit.List(fixtures.data);
var template = can.stache('<bh-bits-vertical-infinite bits={bits} bit-tag="bh-custom-bit"></bh-bits-vertical-infinite>');
var State = can.Map.extend({
isAdmin(){
return false;
},
assetRoot: "../",
hubId: 1
});
$('#app').html(template({
bits: bitData,
state: new State()
}));
import can from "can";
import Service from "./service";
import moment from "moment";
import "can/map/define/";
import "components/service-config-formatter/";
var TOOLTIP = can.stache('<bh-service-config-formatter service="{this}"></bh-service-config-formatter>');
var fillInMissingTimepoints = function(points, length){
var firstRun = true;
while(points.length < length){
if(firstRun){
points.unshift(0);
firstRun = false;
} else {
points.unshift(null);
}
}
return points;
};
var alphaVersion = function(color){
return 'rgba' + color.substring(3, color.length - 1) + ', .2)';
};
var Analytics = can.Model.extend({
findAll : '/api/v3/analytics?source_type={sourceType}&resolution={resolution}&owner_id={ownerId}'
}, {
Component.extend({
tag: "task-editor",
view: stache(`
{{# if logout }}
<h1><code><task-editor></code></h1>
<p>
This content is provided by the <code><task-editor></code> component.
Click <a href="{{ routeUrl(page='home') }}">Home</a> to return to the homepage, or
<button on:click='logout()'>Logout</button> to log out. Edit the task below:
</p>
{{/ else }}
<h2>Task Editor</h2>
{{/ if }}
<form on:submit='save(scope.event)'>
Name: {{ name }}
<p>
<input value:bind='name'/>
</p>
Progress: {{ progress }}
<p>
<percent-slider value:bind='progress'/>
</p>
<button disabled:from="isSaving">
{{# if(isSaving) }}Saving{{ else }}Save{{/ if }}
</button>
</form>
`),
ViewModel: DefineMap.extend({
id: "number",
QUnit.test('Register button exists', function () {
var frag = can.stache('<bitballs-navigation></bitballs-navigation>')();
var buttons = $(frag).find('.register-btn');
QUnit.equal(buttons.length, 1, 'Register button found');
});
beforeEach: function () {
var frag = can.stache('<bitballs-navigation></bitballs-navigation>')();
testUtils.insertAndPopulateIframe('#qunit-fixture', frag);
},
import QUnit from "steal-qunit";
// import {CanPanelVM, CanTabsVM} from "bit-tabs";
import can from "can";
import stache from "can/view/stache/";
import $ from "jquery";
QUnit.module("bit-strap-scrollspy view model");
QUnit.test("basics", function(){
QUnit.ok(true, 'works');
});
var template = can.stache("<div></div>");
QUnit.module("bit-strap-scrollspy component",{
setup: function(){
$("#qunit-fixture").append(template());
}
});
QUnit.test("basics", function(){
QUnit.ok(true, 'works');
});
template: function (data, options) {
var formConfig = data.attr('config');
if (!formConfig.configProcessed()) {
_fullFillConfigFromInner(formConfig, data, options);
formConfig.setDefaultValues();
}
var html = '';
html += '<loader data-name="form-loader"></loader>';
html += '<div class="form-container">';
html += '<div class="form-content">';
data.attr('config').titles.each(function (title) {
html += title.getTemplate();
});
data.attr('config').structuredFields.each(function (field) {
html += field.getTemplate();
});
html += '<div class="form-areas">';
data.attr('config').areas.each(function (area) {
html += area.getTemplate();
});
html += '</div>';
html += '</div>'; //form-content
html += '</div>'; //container
var actionsHtml = '';
data.attr('config').actions.each(function (action) {
actionsHtml += action.getTemplate();
});
if (actionsHtml) { //add footer only if there is any action
html += '<div class="form-bottom">';
html += actionsHtml;
html += '</div>';
}
var resultFragment = can.stache(html)(data, options);
data.attr('config').areas.each(function (area) {
var areaContainer = resultFragment.querySelectorAll('#' + area.attr('id'))[0];
var areaFragmentInner = area.getInnerFragment(options);
var shouldBeHiddenCompute = area.getHiddenCompute();
if (!shouldBeHiddenCompute()) {
areaContainer.appendChild(areaFragmentInner);
}
var shouldBeHiddenListener = function (event, newShouldBeHidden) {
var isHidden = areaFragmentInner.parentNode !== areaContainer;
if (newShouldBeHidden && !isHidden) {
areaContainer.removeChild(areaFragmentInner);
} else if (!newShouldBeHidden && isHidden) {
areaContainer.appendChild(areaFragmentInner);
}
};
shouldBeHiddenCompute.bind('change', shouldBeHiddenListener);
data._context.onRemovedCallbacks.push(function () {
shouldBeHiddenCompute.unbind('change', shouldBeHiddenListener);
});
});
return resultFragment;
},
renderCard : function(bit, opts){
var tag = this.attr('bitTag');
var template = can.stache('<' + tag + ' bit="{bit}" state="{state}"></' + tag + '>');
return template(opts.scope.add({bit: bit}));
}
import can from 'can';
import Component from 'can.component';
import registerIndex from '../../templates/authentication/register.stache';
import RegisterModel from '../models/authenticationModel';
export default can.Component.extend({
tag: 'register-user',
template: can.stache(registerIndex),
viewModel: {
username: '',
password: '',
email: '',
registerUser: function(vm) {
var user = new RegisterModel({
username: vm.username,
password: vm.password,
email: vm.email
});
user.save();
}
}
});