text:
'use strict';

var url = require('url');
var request = require('sync-request');
var parseString = require('xml2json');
var _ = require('lodash');

module.exports = {
  parseKey: function (key) {
    var keyVersion;
    var pool;
    var pathAsArray;
    var name;
    var version = '';

    // Get key version
    if (key.indexOf('connect20') >= 0) {
      keyVersion = '2.0';
    } else if (key.indexOf('magento-') >= 0) {
      keyVersion = '1.0';
    } else {
      return false;
    }

    // Get extension pool
    switch (keyVersion) {
      case '2.0':
        var uri = url.parse(key);
        var path = uri.path;
        pathAsArray = path.split('/');
        if (pathAsArray[1]) {
          pool = pathAsArray[1];
        }
        break;
      case '1.0':
        pathAsArray = key.split('/');
        var stringAsArray = pathAsArray[0].split('-');
        if (stringAsArray[1]) {
          pool = stringAsArray[1];
        }
        break;
      default:
        return false;
    }

    if (pool === undefined) {
      return false;
    }

    // Get extension version and name
    var extension = pathAsArray.pop();
    var extensionAsArray = extension.split('-');

    if (extensionAsArray[1]) {
      name = extensionAsArray[0];
      version = extensionAsArray[1];
    } else {
      name = extension;
    }

    if (name === undefined) {
      return false;
    }

    return {
      key: {
        value: key,
        version: keyVersion
      },
      extension: {
        name: name,
        pool: pool,
        version: version
      }
    };
  },

  getKeyForDl: function (parsedKey) {
    var originalKey = parsedKey.key.value;
    var keyAsArray = originalKey.split('-');

    return keyAsArray[0];
  },

  getVersion: function (parsedKey) {
    var url;

    if (parsedKey.extension.version !== '') {
      return parsedKey.extension.version;
    }

    switch (parsedKey.key.version) {
      case '2.0':
        url = this.getKeyForDl(parsedKey) + '/releases.xml';
        break;
      case '1.0':
        url = 'http://connect.magentocommerce.com/' + parsedKey.extension.pool + '/Chiara_PEAR_Server_REST/r/' + parsedKey.extension.name.toLowerCase() + '/allreleases.xml';
        break;
      default:
        return false;
    }

    // Fetch version list from magento xml
    var response = request('GET', url);

    // Parse xml and get latest version
    var xml = response.getBody().toString();
    var result = parseString.toJson(xml, {object: true});
    var filteredVersions;
    var lastVersion;

    switch (parsedKey.key.version) {
      case '2.0':
        if (result.releases.r instanceof Array) {
          filteredVersions = result.releases.r.filter(function (item) {
            return item.s === 'stable';
          });

          filteredVersions = _.map(filteredVersions, 'v');
          lastVersion = _.max(filteredVersions);

          return lastVersion;
        }
        return result.releases.r.v;
      case '1.0':
        if (result.a.r instanceof Array) {
          filteredVersions = result.a.r.filter(function (item) {
            return item.s === 'stable';
          });

          filteredVersions = _.map(filteredVersions, 'v');
          lastVersion = _.max(filteredVersions);

          return lastVersion;
        }
        return result.a.r.v;
      default:
        return false;
    }
  },

  getDownloadUrl: function (parsedKey) {
    var extVersion = this.getVersion(parsedKey);

    switch (parsedKey.key.version) {
      case '2.0':
        // pattern: http://connect20.magentocommerce.com/{pool}/{name}/{version}/{name}-{version}.tgz
        return this.getKeyForDl(parsedKey) + '/' + extVersion + '/' + parsedKey.extension.name + '-' + extVersion + '.tgz';
      case '1.0':
        // pattern: http://connect.magentocommerce.com/{pool}/get/{name}-{version}.tgz
        return 'http://connect.magentocommerce.com/' + parsedKey.extension.pool + '/get/' + parsedKey.extension.name + '-' + extVersion + '.tgz';
      default:
        return false;
    }
  },

  isKey: function (key) {
    return this.parseKey(key);
  },

  getKey: function (key) {
    var parsedKey = this.parseKey(key);

    if (parsedKey !== false) {
      return this.getDownloadUrl(parsedKey);
    }

    return false;
  }
};


text:
<tile>
<visual lang='en-US' version='2'>

<binding template="TileSquare150x150PeekImageAndText04" branding="name">
<image id="1" src="http://samples.msdn.microsoft.com/iedevcenter/PinnedSites/images/2.jpg"/>
<text id="1">Serving Today: Samosas</text>
</binding>

<binding template="TileWide310x150ImageAndText01" branding="name">
<image id="1" src="http://samples.msdn.microsoft.com/iedevcenter/PinnedSites/images/2.jpg"/>
<text id="1">Serving Today: Samosas</text>
</binding>

<binding template="TileSquare310x310ImageAndText01" branding="name">
<image id="1" src="http://samples.msdn.microsoft.com/iedevcenter/PinnedSites/images/2.jpg"/>
<text id="1">Serving Today: Samosas</text>
</binding>

</visual>
</tile>

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!--
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 -->

<!-- Descriptor for testing configuration groups. -->

<taeDescription xmlns="http://uima.apache.org/resourceSpecifier">
<frameworkImplementation>org.apache.uima.java</frameworkImplementation>
<primitive>false</primitive>

<delegateAnalysisEngineSpecifiers>
<delegateAnalysisEngine key="Annotator1">
  <import location="AnnotatorWithConfigurationGroups.xml"/>
</delegateAnalysisEngine>

<delegateAnalysisEngine key="Annotator2">
  <import location="AnnotatorWithConfigurationGroups.xml"/>
</delegateAnalysisEngine>
</delegateAnalysisEngineSpecifiers>

<analysisEngineMetaData>
<name>Invalid Aggregate - Undefined Key in Flow</name>
<description>This aggregate descriptor uses key "Annotator3" in its flow, but that key
   is not defined.  This should be caught during validation.</description>
<version>1.0</version>
<vendor>The Apache Software Foundation</vendor>

<flowConstraints>
  <fixedFlow>
    <node>Annotator1</node>
    <node>Annotator2</node>
    <node>Annotator3</node> <!-- Invalid -->
  </fixedFlow>
</flowConstraints>

<!-- Capabilities: Inputs and Outputs -->
<capabilities>
<capability>
<inputs/>
<outputs/>
<languagesSupported/>
</capability>
</capabilities>

<operationalProperties>
  <modifiesCas>true</modifiesCas>
  <multipleDeploymentAllowed>true</multipleDeploymentAllowed>
  <outputsNewCASes>false</outputsNewCASes>
</operationalProperties>

</analysisEngineMetaData>

</taeDescription>


text:
function generate(type, text) {
    attributes = {
        text: text,
        dismissQueue: true,
        layout: 'bottomRight',
        maxVisible: 10,
        timeout: 3000,
        animation: {
            open: 'animated slideInRight',
            close: 'animated slideOutRight',
            easing: 'swing',
            speed: 500
        }
    };
    notifierInstance = (type === 'success') ? APP.noti.successFM("lg", "full") : APP.noti.errorFM("lg", "full");
    noty($.extend({}, notifierInstance, attributes));
}


text:
#ifndef __WINDOW_HEADER_H__
#define __WINDOW_HEADER_H__

#include "layer.h"

extern void drawstring_and_refresh(layer_t* layer, int x,
    int y, int color, int bg_color, char* string, int len);
extern void make_title8(unsigned char* buf,
    int width, char* title, char act);
extern void make_window8(unsigned char* buf,
    int width, int height, char* title, char act);
extern void make_text8(layer_t* layer, int x, int y, int w, int h, int c);
extern void change_wtitle8(layer_t* layer, char act);

#endif  /* __WINDOW_HEADER_H__ */


text:
const environment = process.env.NODE_ENV || "development"

function isProduction() {
  return environment === "production"
}

function isDevelopment() {
  return environment === "development"
}

function isTest() {
  return environment === "test"
}

export { environment, isProduction, isDevelopment, isTest }


text:
{% include 'questionnaire/partial/list.html' %}

{% include "pagination.html" %}


text:
/**
 * @author simonThiele / https://github.com/simonThiele
 */

module( "Raycaster" );

test( "intersectObjects", function() {
	var raycaster = getRaycaster();
	var objectsToCheck = getObjectsToCheck();

	ok ( raycaster.intersectObjects( objectsToCheck ).length === 1,
		"no recursive search should lead to one hit" );

	ok ( raycaster.intersectObjects( objectsToCheck, true ).length === 3,
		"recursive search should lead to three hits" );

	var intersections = raycaster.intersectObjects( objectsToCheck, true );
	for ( var i = 0; i < intersections.length - 1; i++ ) {

	  ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, "intersections are sorted" );

	}
});

test( "intersectObject", function() {
	var raycaster = getRaycaster();
	var objectsToCheck = getObjectsToCheck();

	ok ( raycaster.intersectObject( objectsToCheck[ 0 ] ).length === 1,
		"no recursive search should lead to one hit" );

	ok ( raycaster.intersectObject( objectsToCheck[ 0 ], true ).length === 3,
		"recursive search should lead to three hits" );

	var intersections = raycaster.intersectObject( objectsToCheck[ 0 ], true );
	for ( var i = 0; i < intersections.length - 1; i++ ) {

	  ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, "intersections are sorted" );

	}
});

test( "setFromCamera", function() {
	var raycaster = new THREE.Raycaster();
	var rayDirection = raycaster.ray.direction;
	var camera = new THREE.PerspectiveCamera( 90, 1, 1, 1000 );

	raycaster.setFromCamera( { x : 0, y: 0 }, camera );
	ok( rayDirection.x === 0, rayDirection.y === 0, rayDirection.z === -1,
		"camera is looking straight to -z and so does the ray in the middle of the screen" );

	var step = 0.1;

	for ( var x = -1; x <= 1; x += step ) {

		for ( var y = -1; y <= 1; y += step ) {

			raycaster.setFromCamera( { x, y }, camera );

			var refVector = new THREE.Vector3( x, y, -1 ).normalize();

			checkRayDirectionAgainstReferenceVector( rayDirection, refVector );

		}

	}
});

function checkRayDirectionAgainstReferenceVector( rayDirection, refVector ) {
	ok( refVector.x - rayDirection.x <= Number.EPSILON &&
			refVector.y - rayDirection.y <= Number.EPSILON &&
			refVector.z - rayDirection.z <= Number.EPSILON,
			"camera is pointing to the same direction as expected" );
}

function getRaycaster() {
	return raycaster = new THREE.Raycaster(
		new THREE.Vector3( 0, 0, 0 ),
		new THREE.Vector3( 0, 0, -1 ),
		1,
		100
	);
}

function getObjectsToCheck() {
	var objects = [];

	var sphere1 = getSphere();
	sphere1.position.set( 0, 0, -10 );
	sphere1.name = 1;
	objects.push( sphere1 );

	var sphere11 = getSphere();
	sphere11.position.set( 0, 0, 1 );
	sphere11.name = 11;
	sphere1.add( sphere11 );

	var sphere12 = getSphere();
	sphere12.position.set( 0, 0, -1 );
	sphere12.name = 12;
	sphere1.add( sphere12 );

	var sphere2 = getSphere();
	sphere2.position.set( -5, 0, -5 );
	sphere2.name = 2;
	objects.push( sphere2 );

	for ( var i = 0; i < objects.length; i++ ) {

		objects[ i ].updateMatrixWorld();

	}

	return objects;
}

function getSphere() {
	return new THREE.Mesh( new THREE.SphereGeometry( 1, 100, 100 ) );
}


text:
var _ = require('lodash')
var it = global.it
var describe = global.describe
var expect = require('expect.js')
var config = require('../config/test')

var GlobalSettings = require('../settingsManager/globalSettings')

describe('test/test_globalSettings.js', function()
{
this.timeout(10000)

it('should init', function()
{
	var globalSettings = new GlobalSettings()
	expect(globalSettings).to.not.equal(undefined)
})

var firstPath = config.firstPath
var secondPath = config.secondPath

it('should load in config from one path, one mode', function()
{
	var globalSettings = new GlobalSettings(firstPath, 'default')
	expect(globalSettings.firstTest).to.equal('testOne')

})

it('should load in config from several paths, several modes', function()
{
	var globalSettings = new GlobalSettings([firstPath, secondPath], ['default', 'more'])
	expect(globalSettings.firstTest).to.equal('testOne')
	expect(globalSettings.otherSetting).to.equal('othersetting')

})

it('should handle lists, strings and objects', function()
{
	var globalSettings = new GlobalSettings(firstPath, 'default')
	expect(globalSettings.firstTest).to.equal('testOne')
	expect(_.isEqual(globalSettings.listTest, ['apples', 'pears'])).to.equal(true)
	expect(_.isEqual(globalSettings.dictTest, {other: 'test'})).to.equal(true)
})

it('should overwrite settings from left to right in the modes', function()
{
	var globalSettings = new GlobalSettings(firstPath, ['default', 'newMode'])
	expect(globalSettings.firstTest).to.equal('newTestOne')
	expect(globalSettings.listTest).to.equal('overwrittenTest')
	expect(_.isEqual(globalSettings.dictTest, {other: 'test'})).to.equal(true)
})

it('should overwrite settings from left to right in the filepaths', function()
{
	var globalSettings = new GlobalSettings([firstPath, secondPath], 'newMode')
	expect(globalSettings.secondPathTest).to.equal('secondPathOnly')
	expect(globalSettings.firstTest).to.equal('newTestTwo')
	expect(globalSettings.listTest).to.equal('overwrittenTest')
})

})


text:
layout: default
title: Bartosz Kazimierz Papis: Software
css: list.css;software.css;perfect-scrollbar.min.css;flash.css
js: initScroll.js;perfect-scrollbar.min.js;flash.js
---

    {% include software.html title=".NET RL-Glue Codec" link="downloads/dotRLGlueCodec.zip" linkname="Download Source & Binaries" secondlink="https://github.com/bartoszkp/dotRLGlueCodec" secondlinkname="GitHub" description=".NET library for integration with the RL-Glue platform" licence="Permissive-type licence" %}

    {% include software.html title="dotRL" link="https://sourceforge.net/projects/dotrl/" linkname="SourceForge" description="A platform allowing convenient evaluation of Reinforcement Learning algorithms" licence="BSD Licence" %}


text:
package org.basex.query.func.hof;

import org.basex.query.func.fn.*;

/**
 * Function implementation.
 *
 * @author BaseX Team 2005-22, BSD License
 * @author Leo Woerteler
 */
public final class HofConst extends FnIdentity {
}


text:
import { Injectable } from '@angular/core';
import { LoginService } from './services/login.service';

@Injectable()
export class LoginFacade {

    constructor(public loginService : LoginService) {}

    get ready() {
        return this.loginService.ready$
    }

    get sheet_id() {
        return this.loginService.sheet_id$
    }

    get drive_folder() {
        return this.loginService.drive_folder$
    }

    login(sheet_id) {
        this.loginService.login(sheet_id)
    }

    logout() {
        this.loginService.logout()
    }

    share_access(email) : Promise<void> {
        return this.loginService.share_access(email)
    }

    generate_new() {
        return this.loginService.generate_new()
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom"
    xmlns:gContact="http://schemas.google.com/contact/2008"
    xmlns:gd="http://schemas.google.com/g/2005" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/">
    <id>user@gmail.com</id>
    <updated>2008-02-26T20:42:39.993Z</updated>
    <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/contact/2008#contact"/>
    <title type="text">Contacts</title>
    <link
        href="http://www.google.com/m8/feeds/contacts/user%40gmail.com/full"
        rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml"/>
    <link
        href="http://www.google.com/m8/feeds/contacts/user%40gmail.com/full"
        rel="http://schemas.google.com/g/2005#post" type="application/atom+xml"/>
    <author>
        <name>Fred Flintstone</name>
        <email>user@gmail.com</email>
    </author>
    <generator uri="http://www.google.com/m8/feeds" version="1.0">Contacts</generator>
    <openSearch:totalResults>2</openSearch:totalResults>
    <openSearch:startIndex>1</openSearch:startIndex>
    <openSearch:itemsPerPage>2500</openSearch:itemsPerPage>
    <entry>
        <id>http://www.google.com/m8/feeds/contacts/user%40gmail.com/full/9cfaae9</id>
        <updated>2008-02-26T20:31:51.809Z</updated>
        <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/contact/2008#contact"/>
        <title type="text">Foo Barz</title>
        <link
            href="http://www.google.com/m8/feeds/contacts/user%40gmail.com/full/9cfaae9"
            rel="self" type="application/atom+xml"/>
        <link
            href="http://www.google.com/m8/feeds/contacts/user%40gmail.com/full/9cfaae9/1204057911809000"
            rel="edit" type="application/atom+xml"/>
        <gd:organization primary="true" rel="http://schemas.google.com/g/2005#other">
            <gd:orgName>Le Company</gd:orgName>
            <gd:orgTitle>Titularstuff</gd:orgTitle>
        </gd:organization>
        <gd:organization label="DAz">
            <gd:orgName>Deadhead Associates</gd:orgName>
            <gd:orgTitle>Groupie</gd:orgTitle>
        </gd:organization>
        <gd:email address="foo@bar.com" primary="true" rel="http://schemas.google.com/g/2005#home"/>
        <gd:email address="2@bar.com" label="norzglie"/>
        <gd:im primary="true" address="fooaimz" label="werkz" protocol="http://schemas.google.com/g/2005#AIM"/>
        <gd:im address="foomsn"
            protocol="http://schemas.google.com/g/2005#MSN" rel="http://schemas.google.com/g/2005#home"/>
        <gd:im address="foo@gmail.com"
            protocol="http://schemas.google.com/g/2005#GOOGLE_TALK" rel="http://schemas.google.com/g/2005#other"/>
        <gd:im address="foo@jabber.org" label="jabz" protocol="http://schemas.google.com/g/2005#JABBER"/>
        <gd:phoneNumber primary="true" rel="http://schemas.google.com/g/2005#mobile">123-4567</gd:phoneNumber>
        <gd:phoneNumber label="shoefone">333-1414</gd:phoneNumber>
        <gd:postalAddress primary="true" rel="http://schemas.google.com/g/2005#home">123 Lane St</gd:postalAddress>
        <gd:extendedProperty name="com.mycompany.myprop" value="zoop" />
        <gd:extendedProperty name="com.mycompany.myprop2"><myXML><myChild attr="nerf"/></myXML></gd:extendedProperty>
        <gContact:groupMembershipInfo href="http://www.google.com/m8/feeds/contactGroups/user@gmail.com/full/2" deleted="true" />
    </entry>
    <entry>
        <id>http://www.google.com/m8/feeds/contacts/user%40gmail.com/full/b001135</id>
        <updated>2008-02-08T21:20:15.384Z</updated>
        <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/contact/2008#contact"/>
        <link
            href="http://www.google.com/m8/feeds/contacts/user%40gmail.com/full/b001135"
            rel="self" type="application/atom+xml"/>
        <link
            href="http://www.google.com/m8/feeds/contacts/user%40gmail.com/full/b001135/1202505615384000"
            rel="edit" type="application/atom+xml"/>
        <gd:deleted/>
    </entry>
</feed>


text:
layout: default
modal-id: 7
title: Genysis
date: 2017-06-14
img: genysis_logo.png
alt: image-alt
project-date: November 2016
category: Product and Development
---

I attended Hacking Health in Fall 2016 with two of my friends.

 We were all in different programs (Computer Science, Actuarial Science, and Health Studies). We wanted to try something a bit different and out of our usual routine, so we thought this was a good opportunity for us. Little did we know that we were going to end up placing first in the hackathon and winning over $30,000 worth of services and constulting! You can find a list of the awards we won, and a video of me sharing my experience over here.

About

Genysis is an online service we created during the hackathon to help provide communities with a platform in which people in need for help, and people willing to volunteer their time to help can establish a communication channel. With a service like this, a lot of issues such as aging at home, cognitive health, and loneliness can be solved. It even provides a good source of volunteering hours and experience for they people volunteering and we feel it help build a richer community.

My Role

Being the person in Computer Science, my job mostly involved creating the landing page for such a service, and a custom dashboard that is unique to each volunteer or person seeking help.

I was also in charge of coming up with the user experience of such a service, so I got to be a bit of a unicorn during the hackathon.

Product

Most of my contribution and work was focused on the designing of the Dashboard, as I felt this is were our product had the most value. Below is a video showcasing the user flow

Development

The development of the content in the demo above happened over the span of 48 hours (I did take a 5 hour "nap"). The development work was fairly straight forward, it was done using the MEAN stack. The dashboard was based of this wonderful template, so that saved me quite a bit of development time, and could focus on some other portions. Below is a list of tools and frameworks I used to complete this project:

Leaflet.js

Webflow

M, A, N from the MEAN stack

Here is a live demo of the dashboard on heroku.

Conclusion

It was very rewarding to have the 48 hours of hacking pay off! And it further showed me that by have a multidisciplinary team, a lot of interesting problems can be solved. I would not have known what the exact pain points in the volunteering community would have been if I didn't collaborate with my friend in Health Studies.

My two friends are currently taking things further with this project and are trying to get this idea integrated in a community and hopefully scale up from there!


text:
package org.saiku.repository;

public enum AclType {
	PRIVATE,
	SECURED,
	PUBLIC

}


text:
/// <reference path='fourslash.ts' />

// Extracting from a static method should create a static method

//// class Foo {
////     static method() {
////         /*start*/return 1;/*end*/
////     }
//// }

goTo.select('start', 'end')

verify.refactorAvailable('Extract Symbol', 'function_scope_1');

edit.applyRefactor({
    refactorName: "Extract Symbol",
    actionName: "function_scope_1",
    actionDescription: "Extract to method in class 'Foo'",
    newContent:
`class Foo {
    static method() {
        return Foo./*RENAME*/newMethod();
    }

    private static newMethod() {
        return 1;
    }
}`
});


text: from .view import ViewPanel


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta name="description" content="Kode is a Premium Bootstrap Admin Template, It's responsive, clean coded and mobile friendly">
  <meta name="keywords" content="bootstrap, admin, dashboard, flat admin template, responsive," />
  <title>Kode - Premium Bootstrap Admin Template</title>

  <link href="css/root.css" rel="stylesheet">

      kode

    <form class="searchform">
      <input type="text" class="searchbox" id="searchbox" placeholder="Search">

    </form>

Files

Authors

        My Files

Videos

Pictures

Blog Posts

      Create New

Product or Item

Blog Post

Image Gallery

Video Gallery

      6

      Jonathan Doe

Profile

Inbox4

Files

Settings

 Lockscreen

 Logout

MAIN

Dashboard2

Mailbox19

UI Elements

Icons

Tabs

Buttons

Panels

Notifications

Modal Boxes

Progress Bars

OthersNEW

Charts

Tables

Basic Tables

Data Tables

Forms

Form Elements

Form Layouts

Text Editors

Widgets

CalendarNEW

Typography

Extra Pages

Social Profile

InvoiceNEW

Login Page

Register

Forgot Password

Lockscreen

Blank Page

Contact

404 Page

500 Page

MORE

Grid System

Maps

Customizable

Helper Classes

Changelogs

  Pro PlanUpgrade

42 GB / 100 GB

Charts

Dashboard

Charts

        Dashboard

Charts

Kode coming with dozens charts.
All of responsive and easy to edit.

Rickshaw

Chartist

Flot Charts

Easy Pie Chart

Sparklines

          Rickshaw

Rickshaw is a JavaScript toolkit for creating interactive time series graphs.

Rickshaw provides the elements you need to create interactive graphs: renderers, legends, hovers, range selectors, etc. You put the pieces together

Rickshaw: A JavaScript toolkit for creating interactive time-series graphs

              Official documentation

          Lines and Toggling

          Bars

          Fixed

          Scaled

          Time Scale

          Gaps

          CHARTIST

Chartist - Simple Responsive Charts

You may think that this is just yet an other charting library. But Chartist.js is the product of a community that was disappointed about the abilities provided by other charting libraries. Of course there are hundreds of other great charting libraries but after using them there were always tweaks you would have wished for that were not included.

Chartist: Simple Responsive Charts

              Official documentation

          Simple Line Chart

          Line Scatter Diagram

          Line Chart with Area

          Bi-polar

          Overlapping Bars

          Horizontal Bar

          Simple Pie Chart

          Gauge Chart

          FLOT CHARTS

Flot is a pure JavaScript plotting library for jQuery, with a focus on simple usage, attractive looks and interactive features.

Here are some examples for Flot, the Javascript charting library for jQuery:

Flot: Attractive JavaScript plotting for jQuery

              Official documentation

          Real-time Chart

          Setting various options

          Multiple axes

          Stacking Bars

Easy Pie Chart

Easy Pie Chart

Easy pie chart is a jQuery plugin that uses the canvas element to render simple pie charts for single values. These charts are highly customizable, very easy to implement, scale to the resolution of the display of the client to provide sharp charts even on retina displays, and use requestAnimationFrame for smooth animations on modern devices.

Easy Pie Chart by rendro

                  Official documentation

Basic

90Orders

29Products

912Comments

Sparklines

Tiny but Amazing

This jQuery plugin generates sparklines (small inline charts) directly in the browser using data supplied either inline in the HTML, or via javascript.

jQuery Sparklines

                  Official documentation

Line

Bar

Pie

  Copyright © 2015 Egemem All rights reserved.

    Design and Developed by Egemem

TODAY

TASKS

CHAT

        Today

NEW

            ORDER
            9 hours ago

New Jacket 2.0

            Etiam auctor porta augue sit amet facilisis. Sed libero nisi, scelerisque.

            COMMENT
            14 hours ago

Bill Jackson

            Etiam auctor porta augue sit amet facilisis. Sed libero nisi, scelerisque.

            MEETING
            at 2:30 PM

Developer Team

            Etiam auctor porta augue sit amet facilisis. Sed libero nisi, scelerisque.

            EVENT
            3 days left

Birthday Party

            Etiam auctor porta augue sit amet facilisis. Sed libero nisi, scelerisque.

        To-do List

TODAY

          <input id="checkboxside1" type="checkbox">Add new products

          <input id="checkboxside2" type="checkbox">May 12, 6:30 pm Meeting with Team

          <input id="checkboxside3" type="checkbox">Design Facebook page

          <input id="checkboxside4" type="checkbox">Send Invoice to customers

          <input id="checkboxside5" type="checkbox">Meeting with developer team

TOMORROW

          <input id="checkboxside6" type="checkbox">Redesign our company blog

          <input id="checkboxside7" type="checkbox">Finish client work

          <input id="checkboxside8" type="checkbox">Call Johnny from Developer Team

        Friend List

ONLINE MEMBERS (3)

Allice MinghamLos Angeles

James ThrowingLas Vegas

Fred StonefieldNew York

Chris M. JohnsonCalifornia

OFFLINE MEMBERS (8)

Allice MinghamLos Angeles

James ThrowingLas Vegas

      <form class="search">
        <input type="text" class="form-control" placeholder="Search a Friend...">
      </form>


text:
from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
                        unicode_literals, with_statement)

from abc import abstractproperty

from twitter.common.lang import AbstractClass

from pants.backend.jvm.targets.jar_dependency import JarDependency

class Jarable(AbstractClass):
  """A mixin that identifies a target as one that can provide a jar."""

  @abstractproperty
  def identifier(self):
    """Subclasses should return a stable unique identifier for the jarable target."""

  @property
  def provides(self):
    """Returns an optional :class:`pants.backend.jvm.targets.artifact.Artifact` if this target is exportable.

    Subclasses should override to provide an artifact descriptor when one applies, by default None
    is supplied.
    """
    return None

  def get_artifact_info(self):
    """Returns a triple composed of a :class:`pants.backend.jvm.targets.jar_dependency.JarDependency`
    describing the jar for this target, this target's artifact identifier and a bool indicating if
    this target is exportable.
    """
    exported = bool(self.provides)

    org = self.provides.org if exported else 'internal'
    module = self.provides.name if exported else self.identifier

    id_ = "%s-%s" % (self.provides.org, self.provides.name) if exported else self.identifier

    # TODO(John Sirois): This should return something less than a JarDependency encapsulating just
    # the org and name.  Perhaps a JarFamily?
    return JarDependency(org=org, name=module, rev=None), id_, exported


text:
"use strict";
exports.__esModule = true;
var babylon_1 = require("babylon");
var b = require("babel-types");
var binaryOperation_1 = require("./binaryOperation");
function expressionToConstant(expression, options) {
    if (options === void 0) { options = {}; }
    var constant = true;
    function toConstant(expression) {
        if (!constant)
            return;
        if (b.isArrayExpression(expression)) {
            var result_1 = [];
            for (var i = 0; constant && i < expression.elements.length; i++) {
                var element = expression.elements[i];
                if (b.isSpreadElement(element)) {
                    var spread = toConstant(element.argument);
                    if (!(isSpreadable(spread) && constant)) {
                        constant = false;
                    }
                    else {
                        result_1.push.apply(result_1, spread);
                    }
                }
                else {
                    result_1.push(toConstant(element));
                }
            }
            return result_1;
        }
        if (b.isBinaryExpression(expression)) {
            var left = toConstant(expression.left);
            var right = toConstant(expression.right);
            return constant && binaryOperation_1["default"](expression.operator, left, right);
        }
        if (b.isBooleanLiteral(expression)) {
            return expression.value;
        }
        if (b.isCallExpression(expression)) {
            var args = [];
            for (var i = 0; constant && i < expression.arguments.length; i++) {
                var arg = expression.arguments[i];
                if (b.isSpreadElement(arg)) {
                    var spread = toConstant(arg.argument);
                    if (!(isSpreadable(spread) && constant)) {
                        constant = false;
                    }
                    else {
                        args.push.apply(args, spread);
                    }
                }
                else {
                    args.push(toConstant(arg));
                }
            }
            if (!constant)
                return;
            if (b.isMemberExpression(expression.callee)) {
                var object = toConstant(expression.callee.object);
                if (!object || !constant) {
                    constant = false;
                    return;
                }
                var member = expression.callee.computed
                    ? toConstant(expression.callee.property)
                    : b.isIdentifier(expression.callee.property)
                        ? expression.callee.property.name
                        : undefined;
                if (member === undefined && !expression.callee.computed) {
                    constant = false;
                }
                if (!constant)
                    return;
                if (canCallMethod(object, '' + member)) {
                    return object[member].apply(object, args);
                }
            }
            else {
                var callee = toConstant(expression.callee);
                if (!constant)
                    return;
                return callee.apply(null, args);
            }
        }
        if (b.isConditionalExpression(expression)) {
            var test = toConstant(expression.test);
            return test
                ? toConstant(expression.consequent)
                : toConstant(expression.alternate);
        }
        if (b.isIdentifier(expression)) {
            if (options.constants &&
                {}.hasOwnProperty.call(options.constants, expression.name)) {
                return options.constants[expression.name];
            }
        }
        if (b.isLogicalExpression(expression)) {
            var left = toConstant(expression.left);
            var right = toConstant(expression.right);
            if (constant && expression.operator === '&&') {
                return left && right;
            }
            if (constant && expression.operator === '||') {
                return left || right;
            }
        }
        if (b.isMemberExpression(expression)) {
            var object = toConstant(expression.object);
            if (!object || !constant) {
                constant = false;
                return;
            }
            var member = expression.computed
                ? toConstant(expression.property)
                : b.isIdentifier(expression.property)
                    ? expression.property.name
                    : undefined;
            if (member === undefined && !expression.computed) {
                constant = false;
            }
            if (!constant)
                return;
            if ({}.hasOwnProperty.call(object, '' + member) && member[0] !== '_') {
                return object[member];
            }
        }
        if (b.isNullLiteral(expression)) {
            return null;
        }
        if (b.isNumericLiteral(expression)) {
            return expression.value;
        }
        if (b.isObjectExpression(expression)) {
            var result_2 = {};
            for (var i = 0; constant && i < expression.properties.length; i++) {
                var property = expression.properties[i];
                if (b.isObjectProperty(property)) {
                    if (property.shorthand) {
                        constant = false;
                        return;
                    }
                    var key = property.computed
                        ? toConstant(property.key)
                        : b.isIdentifier(property.key)
                            ? property.key.name
                            : b.isStringLiteral(property.key)
                                ? property.key.value
                                : undefined;
                    if (!key || key[0] === '_') {
                        constant = false;
                    }
                    if (!constant)
                        return;
                    var value = toConstant(property.value);
                    if (!constant)
                        return;
                    result_2[key] = value;
                }
                else if (b.isObjectMethod(property)) {
                    constant = false;
                }
                else if (b.isSpreadProperty(property)) {
                    var argument = toConstant(property.argument);
                    if (!argument)
                        constant = false;
                    if (!constant)
                        return;
                    Object.assign(result_2, argument);
                }
            }
            return result_2;
        }
        if (b.isParenthesizedExpression(expression)) {
            return toConstant(expression.expression);
        }
        if (b.isRegExpLiteral(expression)) {
            return new RegExp(expression.pattern, expression.flags);
        }
        if (b.isSequenceExpression(expression)) {
            for (var i = 0; i < expression.expressions.length - 1 && constant; i++) {
                toConstant(expression.expressions[i]);
            }
            return toConstant(expression.expressions[expression.expressions.length - 1]);
        }
        if (b.isStringLiteral(expression)) {
            return expression.value;
        }
        // TODO: TaggedTemplateExpression
        if (b.isTemplateLiteral(expression)) {
            var result_3 = '';
            for (var i = 0; i < expression.quasis.length; i++) {
                var quasi = expression.quasis[i];
                result_3 += quasi.value.cooked;
                if (i < expression.expressions.length) {
                    result_3 += '' + toConstant(expression.expressions[i]);
                }
            }
            return result_3;
        }
        if (b.isUnaryExpression(expression)) {
            var argument = toConstant(expression.argument);
            if (!constant) {
                return;
            }
            switch (expression.operator) {
                case '-':
                    return -argument;
                case '+':
                    return +argument;
                case '!':
                    return !argument;
                case '~':
                    return ~argument;
                case 'typeof':
                    return typeof argument;
                case 'void':
                    return void argument;
            }
        }
        constant = false;
    }
    var result = toConstant(expression);
    return constant ? { constant: true, result: result } : { constant: false };
}
exports.expressionToConstant = expressionToConstant;
function isSpreadable(value) {
    return (typeof value === 'string' ||
        Array.isArray(value) ||
        (typeof Set !== 'undefined' && value instanceof Set) ||
        (typeof Map !== 'undefined' && value instanceof Map));
}
function shallowEqual(a, b) {
    if (a === b)
        return true;
    if (a && b && typeof a === 'object' && typeof b === 'object') {
        for (var key in a) {
            if (a[key] !== b[key]) {
                return false;
            }
        }
        for (var key in b) {
            if (a[key] !== b[key]) {
                return false;
            }
        }
        return true;
    }
    return false;
}
function canCallMethod(object, member) {
    switch (typeof object) {
        case 'boolean':
            switch (member) {
                case 'toString':
                    return true;
                default:
                    return false;
            }
        case 'number':
            switch (member) {
                case 'toExponential':
                case 'toFixed':
                case 'toPrecision':
                case 'toString':
                    return true;
                default:
                    return false;
            }
        case 'string':
            switch (member) {
                case 'charAt':
                case 'charCodeAt':
                case 'codePointAt':
                case 'concat':
                case 'endsWith':
                case 'includes':
                case 'indexOf':
                case 'lastIndexOf':
                case 'match':
                case 'normalize':
                case 'padEnd':
                case 'padStart':
                case 'repeat':
                case 'replace':
                case 'search':
                case 'slice':
                case 'split':
                case 'startsWith':
                case 'substr':
                case 'substring':
                case 'toLowerCase':
                case 'toUpperCase':
                case 'trim':
                    return true;
                default:
                    return false;
            }
        default:
            if (object instanceof RegExp) {
                switch (member) {
                    case 'test':
                    case 'exec':
                        return true;
                    default:
                        return false;
                }
            }
            return {}.hasOwnProperty.call(object, member) && member[0] !== '_';
    }
}
var EMPTY_OBJECT = {};
var lastSrc = '';
var lastConstants = EMPTY_OBJECT;
var lastOptions = EMPTY_OBJECT;
var lastResult = null;
var lastWasConstant = false;
function isConstant(src, constants, options) {
    if (constants === void 0) { constants = EMPTY_OBJECT; }
    if (options === void 0) { options = EMPTY_OBJECT; }
    if (lastSrc === src &&
        shallowEqual(lastConstants, constants) &&
        shallowEqual(lastOptions, options)) {
        return lastWasConstant;
    }
    lastSrc = src;
    lastConstants = constants;
    var ast;
    try {
        ast = babylon_1.parseExpression(src, options);
    }
    catch (ex) {
        return (lastWasConstant = false);
    }
    var _a = expressionToConstant(ast, { constants: constants }), result = _a.result, constant = _a.constant;
    lastResult = result;
    return (lastWasConstant = constant);
}
exports.isConstant = isConstant;
function toConstant(src, constants, options) {
    if (constants === void 0) { constants = EMPTY_OBJECT; }
    if (options === void 0) { options = EMPTY_OBJECT; }
    if (!isConstant(src, constants, options)) {
        throw new Error(JSON.stringify(src) + ' is not constant.');
    }
    return lastResult;
}
exports.toConstant = toConstant;
exports["default"] = isConstant;
module.exports = isConstant;
module.exports["default"] = isConstant;
module.exports.expressionToConstant = expressionToConstant;
module.exports.isConstant = isConstant;
module.exports.toConstant = toConstant;


text: docker build -t registry.access.redhat.com/openshift3/war-custom-docker-builder:v3.2.1.1 .