columbus3 0.4.0 → 0.5.0

data/bower_components/leaflet/CONTRIBUTING.md

@@ -4,18 +4,23 @@ Contributing to Leaflet
  1. [Getting Involved](#getting-involved)
  2. [Reporting Bugs](#reporting-bugs)
  3. [Contributing Code](#contributing-code)
- 4. [Improving Documentation](#improving-documentation)
+ 4. [Running the Tests](#running-the-tests)
+ 5. [Code Coverage](#code-coverage)
+ 6. [Improving Documentation](#improving-documentation)
+ 7. [Code of Conduct](#code-of-conduct)
+ 8. [Thank You](#thank-you)
 
 ## Getting Involved
 
 Third-party patches are absolutely essential on our quest to create the best mapping library that will ever exist.
-However, they're not the only way to get involved with the development of Leaflet.
-You can help the project tremendously by discovering and [reporting bugs](#reporting-bugs),
-[improving documentation](#improving-documentation),
-helping others on the [Leaflet forum](https://groups.google.com/forum/#!forum/leaflet-js)
-and [GitHub issues](https://github.com/Leaflet/Leaflet/issues),
-showing your support for your favorite feature suggestions on [Leaflet UserVoice page](http://leaflet.uservoice.com),
-tweeting to [@LeafletJS](http://twitter.com/LeafletJS)
+However, they're not the only way to get involved with Leaflet development.
+You can help the project tremendously by discovering and [reporting bugs](#reporting-bugs);
+[improving documentation](#improving-documentation);
+helping others on [Stack Overflow](https://stackoverflow.com/questions/tagged/leaflet),
+[GIS Stack Exchange](https://gis.stackexchange.com/questions/tagged/leaflet)
+and [GitHub issues](https://github.com/Leaflet/Leaflet/issues);
+showing your support for your favorite feature suggestions on [Leaflet UserVoice page](http://leaflet.uservoice.com);
+tweeting to [@LeafletJS](http://twitter.com/LeafletJS);
 and spreading the word about Leaflet among your colleagues and friends.
 
 ## Reporting Bugs
@@ -26,34 +31,35 @@ first make sure that your issue is caused by Leaflet, not your application code
 Second, search the already reported issues for similar cases,
 and if it's already reported, just add any additional details in the comments.
 
-After you made sure that you've found a new Leaflet bug,
+After you've made sure that you've found a new Leaflet bug,
 here are some tips for creating a helpful report that will make fixing it much easier and quicker:
 
  * Write a **descriptive, specific title**. Bad: *Problem with polylines*. Good: *Doing X in IE9 causes Z*.
  * Include **browser, OS and Leaflet version** info in the description.
- * Create a **simple test case** that demonstrates the bug (e.g. using [JSFiddle](http://jsfiddle.net/)).
+ * Create a **simple test case** that demonstrates the bug (e.g. using [Leaflet playground](http://playground-leaflet.rhcloud.com/)).
  * Check whether the bug can be reproduced in **other browsers**.
  * Check if the bug occurs in the stable version, master, or both.
  * *Bonus tip:* if the bug only appears in the master version but the stable version is fine,
    use `git bisect` to find the exact commit that introduced the bug.
 
 If you just want some help with your project,
-try asking [on the Leaflet forum](https://groups.google.com/forum/#!forum/leaflet-js) instead.
+try asking on [Stack Overflow](https://stackoverflow.com/questions/tagged/leaflet)
+or [GIS Stack Exchange](https://gis.stackexchange.com/questions/tagged/leaflet) instead.
 
 ## Contributing Code
 
 ### Considerations for Accepting Patches
 
-While we happily accept patches, we're also commited to keeping Leaflet simple, lightweight and blazingly fast.
+While we happily accept patches, we're also committed to keeping Leaflet simple, lightweight and blazingly fast.
 So bugfixes, performance optimizations and small improvements that don't add a lot of code
 are much more likely to get accepted quickly.
 
-Before sending a pull request with a new feature, first check if it's been discussed before already
+Before sending a pull request with a new feature, check if it's been discussed before already
 (either on [GitHub issues](https://github.com/Leaflet/Leaflet/issues)
 or [Leaflet UserVoice](http://leaflet.uservoice.com/)),
-and then ask yourself two questions:
+and ask yourself two questions:
 
- 1. Are you sure that this new feature is important enough to justify its presense in the Leaflet core?
+ 1. Are you sure that this new feature is important enough to justify its presence in the Leaflet core?
     Or will it look better as a plugin in a separate repository?
  2. Is it written in a simple, concise way that doesn't add bulk to the codebase?
 
@@ -62,16 +68,18 @@ please consider submitting another pull request with the corresponding [document
 
 ### Setting up the Build System
 
-To set up the Leaflet build system, install [Node](http://nodejs.org/),
-then run the following commands in the project root:
+The Leaflet build system uses [Node](http://nodejs.org/), and the [Jake](http://jakejs.com/) Javascript build tool.
+To set up the Leaflet build system, install Node then run the following commands in the project root to install Jake:
 
 ```
 npm install -g jake
 npm install
 ```
-
-You can build minified Leaflet by running `jake` (it will be built from source in the `dist` folder).
-For a custom build with selected components, open `build/build.html` in the browser and follow the instructions from there.
+or, if you prefer [`yarn`](https://yarnpkg.com/) over `npm`:
+```
+yarn global add jake
+yarn install
+```
 
 ### Making Changes to Leaflet Source
 
@@ -85,7 +93,7 @@ Please do not commit to the `master` branch, or your unrelated changes will go i
 You should also follow the code style and whitespace conventions of the original codebase.
 In particular, use tabs for indentation and spaces for alignment.
 
-Before commiting your changes, run `jake lint` to catch any JS errors in the code and fix them.
+Before committing your changes, run `jake lint` to catch any JS errors in the code and fix them.
 If you add any new files to the Leaflet source, make sure to also add them to `build/deps.js`
 so that the build system knows about them.
 
@@ -93,6 +101,25 @@ Also, please make sure that you have [line endings configured properly](https://
 
 Happy coding!
 
+### Using RollupJS
+
+The source javascript code for Leaflet is a few dozen files, in the `src/` directory.
+But normally, Leaflet is loaded in a web browser as just one javascript file.
+
+In order to create this file, run `npm run-script rollup` or `yarn run rollup`.
+
+You'll find `dist/leaflet-src.js` and `dist/leaflet.js`. The difference is that
+`dist/leaflet-src.js` has sourcemaps and it's not uglified, so it's better for
+development. `dist/leaflet.js` is uglified and thus is smaller, so it's better
+for deployment.
+
+When developing (or bugfixing) core Leaflet functionalities, it's common to use
+the webpages in the `debug/` directory, and run the unit tests (`spec/index.html`)
+in a graphical browser. This requires regenerating the bundled files quickly.
+
+In order to do so, run `npm run-script watch` or `yarn run rollup`. This will keep
+on rebuilding the bundles whenever any source file changes.
+
 ## Running the Tests
 
 To run the tests from the command line,
@@ -119,18 +146,18 @@ To generate a detailed report about test coverage (which helps tremendously when
 jake test --cov
 ```
 
-After that, open `spec/coverage/<environment>/index.html` in a browser to see the report.
+After that, open `coverage/<environment>/index.html` in a browser to see the report.
 From there you can click through folders/files to get details on their individual coverage.
 
 ## Improving Documentation
 
-The code of the live Leaflet website that contains all documentation and examples is located in the `gh-pages` branch
-and is automatically generated from a set of HTML and Markdown files by [Jekyll](https://github.com/mojombo/jekyll).
+The code of the live Leaflet website that contains all documentation and examples is located in the `docs/` directory of the `master` branch
+and is automatically generated from a set of HTML and Markdown files by [Jekyll](http://jekyllrb.com/).
 
 The easiest way to make little improvements such as fixing typos without even leaving the browser
 is by editing one of the files with the online GitHub editor:
-browse the [gh-pages branch](https://github.com/Leaflet/Leaflet/tree/gh-pages),
-choose a certain file for editing (e.g. `reference.html` for API reference),
+browse the [`docs/ directory`](https://github.com/Leaflet/Leaflet/tree/master/docs),
+choose a certain file for editing (e.g. `plugins.md` for the list of Leaflet plugins),
 click the Edit button, make changes and follow instructions from there.
 Once it gets merged, the changes will immediately appear on the website.
 
@@ -138,18 +165,46 @@ If you need to make edits in a local repository to see how it looks in the proce
 
  1. [Install Ruby](http://www.ruby-lang.org/en/) if don't have it yet.
  2. Run `gem install jekyll`.
- 3. Run `jekyll serve --watch` in the root `Leaflet` folder.
- 4. Open `localhost:4000` in your browser.
+ 3. Enter the directory where you cloned the Leaflet repository
+ 4. Make sure you are in the `master` branch by running `git checkout master`
+ 5. Enter the documentation subdirectory by running `cd docs`
+ 6. Run `jekyll serve --watch`.
+ 7. Open `localhost:4000` in your web browser.
 
 Now any file changes will be updated when you reload pages automatically.
-After commiting the changes, just send a pull request.
+After committing the changes, just send a pull request.
+
+### API documentation
+
+Since Leaflet 1.0.0-rc1, the API documentation in `reference-1.0.0.html` is handled
+via [Leafdoc](https://github.com/Leaflet/Leafdoc). This means that next to the
+code for every method, option or property there is a special code comment documenting
+that feature. In order to edit the API documentation, just edit these comments in the
+source code.
+
+In order to generate the documentation, make sure that the development dependencies
+are installed (run either `npm install` or `yarn install`), then just run
+
+```
+jake docs
+```
+
+and you'll find a `.html` file in the `dist/` directory.
+
+On every release of a new Leaflet version, this file will be generated and copied
+over to `docs/reference.html` - there is no need to send pull requests with changes to this file to update the API documentation.
+
+## Code of Conduct
 
-If you need to update documentation according to a new feature that only appeared in the master version (not stable one),
-you need to make changes to `gh-pages-master` branch instead of `gh-pages`.
-It will get merged into the latter when released as stable.
+Everyone is invited to participate in the Leaflet community and related projects:
+we want to create a welcoming and friendly environment.
+Harassment of participants or other unethical and unprofessional behavior will not be tolerated in our spaces.
+The [Contributor Covenant](http://contributor-covenant.org/version/1/3/0/)
+applies to all projects under the Leaflet organization.
+Report any issues to agafonkin@gmail.com.
 
 ## Thank You
 
-Not only are we grateful for any contributions, &mdash; helping Leaflet and its community actually makes you AWESOME.
+Not only does your contribution to Leaflet and its community earn our gratitude, but it also makes you AWESOME.
 Join [this approved list of awesome people](https://github.com/Leaflet/Leaflet/graphs/contributors)
 and help us push the limits of what's possible with online maps!

data/bower_components/leaflet/ISSUE_TEMPLATE.md

@@ -0,0 +1,25 @@
+<!--
+Thanks for taking the time to open an issue! Help us have good bug requests:
+
+- [ ] I'm reporting a bug, not asking for help; support questions like "How can I do X with Leaflet?" will be closed (use [Stack Overflow](http://stackoverflow.com/) or [gis.stackexchange.com](http://gis.stackexchange.com/) for questions)
+- [ ] I've looked at the [documentation](http://leafletjs.com/reference-1.0.3.html) to make sure the behaviour is documented and expected
+- [ ] I'm sure this is a Leaflet code issue, not an issue with my own code nor with the framework I'm using (Cordova, Ionic, Angular, React…)
+- [ ] I've searched through the issues to make sure it's not yet reported
+-->
+
+## How to reproduce
+
+- Leaflet version I'm using:
+- Browser (with version) I'm using:
+- OS/Platform (with version) I'm using:
+- step 1
+- step 2
+
+## What behaviour I'm expecting and which behaviour I'm seeing
+
+## Minimal example reproducing the issue
+
+- [ ] this example is as simple as possible
+- [ ] this example does not rely on any third party code
+
+Using http://playground-leaflet.rhcloud.com/ or any other jsfiddle-like site.

data/bower_components/leaflet/Jakefile.js

@@ -7,38 +7,97 @@ To use, install Node, then run the following commands in the project root:
     npm install
 
 To check the code for errors and build Leaflet from source, run "jake".
-To run the tests, run "jake test".
+To run the tests, run "jake test". To build the documentation, run "jake docs".
 
 For a custom build, open build/build.html in the browser and follow the instructions.
 */
 
-var build = require('./build/build.js');
+var buildDocs = require('./build/docs'),
+    git = require('git-rev-sync'),
+    path = require('path');
 
-function hint(msg, paths) {
+function hint(msg, args) {
 	return function () {
 		console.log(msg);
-		jake.exec('node node_modules/jshint/bin/jshint -c ' + paths,
+		jake.exec('node node_modules/eslint/bin/eslint.js ' + args,
 				{printStdout: true}, function () {
 			console.log('\tCheck passed.\n');
 			complete();
 		});
-	}
+	};
 }
 
-desc('Check Leaflet source for errors with JSHint');
-task('lint', {async: true}, hint('Checking for JS errors...', 'build/hintrc.js src'));
+// Returns the version string in package.json, plus a semver build metadata if
+// this is not an official release
+function calculateVersion(officialRelease) {
 
-desc('Check Leaflet specs source for errors with JSHint');
-task('lintspec', {async: true}, hint('Checking for specs JS errors...', 'spec/spec.hintrc.js spec/suites'));
+	var version = require('./package.json').version;
 
-desc('Combine and compress Leaflet source files');
-task('build', {async: true}, function () {
-	build.build(complete);
-});
+	if (officialRelease) {
+		return version;
+	} else {
+		return version + '+' + git.short();
+	}
+}
+
+desc('Check Leaflet source for errors with ESLint');
+task('lint', {async: true}, hint('Checking for JS errors...', 'src'));
+
+desc('Check Leaflet specs source for errors with ESLint');
+task('lintspec', {async: true}, hint('Checking for specs JS errors...', 'spec/suites'));
 
 desc('Run PhantomJS tests');
 task('test', ['lint', 'lintspec'], {async: true}, function () {
-	build.test(complete);
+
+	var karma = require('karma'),
+	 testConfig = {configFile : path.join(__dirname, './spec/karma.conf.js')};
+
+	 testConfig.browsers = ['PhantomJSCustom'];
+
+	 function isArgv(optName) {
+		 return process.argv.indexOf(optName) !== -1;
+	 }
+
+	 if (isArgv('--chrome')) {
+		 testConfig.browsers.push('Chrome');
+	 }
+	 if (isArgv('--safari')) {
+		 testConfig.browsers.push('Safari');
+	 }
+	 if (isArgv('--ff')) {
+		 testConfig.browsers.push('Firefox');
+	 }
+	 if (isArgv('--ie')) {
+		 testConfig.browsers.push('IE');
+	 }
+
+	 if (isArgv('--cov')) {
+		 testConfig.preprocessors = {
+			 'src/**/*.js': 'coverage'
+		 };
+		 testConfig.coverageReporter = {
+			 type : 'html',
+	 dir : 'coverage/'
+		 };
+		 testConfig.reporters = ['coverage'];
+	 }
+
+	 console.log('Running tests...');
+
+	 var server = new karma.Server(testConfig, function(exitCode) {
+		 if (!exitCode) {
+			 console.log('\tTests ran successfully.\n');
+			 complete();
+		 } else {
+			 process.exit(exitCode);
+		 }
+	 });
+	 server.start();
+});
+
+desc('Build documentation');
+task('docs', {}, function() {
+	buildDocs();
 });
 
 task('default', ['test', 'build']);

data/bower_components/leaflet/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2013, Vladimir Agafonkin
+Copyright (c) 2010-2016, Vladimir Agafonkin
 Copyright (c) 2010-2011, CloudMade
 All rights reserved.
 

data/bower_components/leaflet/PLUGIN-GUIDE.md

@@ -15,6 +15,9 @@ This guide lists a number of best practices for publishing a Leaflet plugin that
 	- [File Structure](#file-structure)
 	- [Code Conventions](#code-conventions)
 	- [Plugin API](#plugin-api)
+3. [Publishing on NPM](#publishing-on-npm)
+4. [Module Loaders](#module-loaders)
+5. [Adding to the plugins list](#adding-to-the-plugins-list)
 
 ## Presentation
 
@@ -42,7 +45,7 @@ after pushing, it'll be published as `http://<user>.github.io/<repo>`.
 
 ### Readme
 
-The next thing you need to have is a descriptive `README.md` in the root of the repo (or a link to a website with a similar content).
+The next thing you need to have is a [good `README.md`](https://github.com/noffle/art-of-readme) in the root of the repo (or a link to a website with a similar content).
 At a minimum it should contain the following items:
 
 - name of the plugin
@@ -105,13 +108,14 @@ and putting a space after the `function` keyword.
 Never expose global variables in your plugin.<br>
 If you have a new class, put it directly in the `L` namespace (`L.MyPlugin`).<br>
 If you inherit one of the existing classes, make it a sub-property (`L.TileLayer.Banana`).<br>
+Every class should have a factory function in camelCase, e.g. (`L.tileLayer.banana`).<br>
 If you want to add new methods to existing Leaflet classes, you can do it like this: `L.Marker.include({myPlugin: …})`.
 
-Function, method and property names should be in `camelCase`.<br>
+Function, method, property and factory names should be in `camelCase`.<br>
 Class names should be in `CapitalizedCamelCase`.
 
 If you have a lot of arguments in your function, consider accepting an options object instead
-(putting default values where possible so that users don't need specify all of them):
+(putting default values where possible so that users don't need to specify all of them):
 
 ```js
 // bad
@@ -125,3 +129,93 @@ marker.myPlugin('bla', {
 ```
 
 And most importantly, keep it simple. Leaflet is all about *simplicity*.
+
+## Publishing on NPM
+
+NPM (Node Packaged Modules) is a package manager and code repository for JavaScript. Publishing your module on NPM allows other developers to quickly find and install your plugin as well as any other plugins it depends on.
+
+NPM has an excellent [developers guide](https://www.npmjs.org/doc/misc/npm-developers.html) to help you through the process.
+
+When you publish your plugin you should add a dependency on `leaflet` to your `package.json` file. This will automatically install Leaflet when your package is installed.
+
+Here is an example of a `package.json` file for a Leaflet plugin.
+
+```json
+{
+  "name": "my-leaflet-plugin",
+  "version": "1.0.0",
+  "description": "A simple leaflet plugin.",
+  "main": "my-plugin.js",
+  "author": "You",
+  "license": "IST",
+  "peerDependencies": {
+    "leaflet": "^1.0.0"
+  }
+}
+```
+
+If possible, do not commit your minified files (e.g. `dist`) to a repo; this can
+lead to confussion when trying to debug the wrong file. Instead, use `npm` to
+trigger a build/minification just before publishing your package with a
+[`prepublish` script](https://docs.npmjs.com/misc/scripts#common-uses), for example:
+
+```json
+{
+  "name": "my-leaflet-plugin",
+  ...
+  "scripts": {
+    "prepublish": "grunt build"
+  }
+}
+```
+
+You can then use the [`.gitignore`](https://help.github.com/articles/ignoring-files/)
+file to make sure the minified files are not versioned, and an
+[empty `.npmignore`](https://docs.npmjs.com/misc/developers#keeping-files-out-of-your-package)
+to ensure that they are published to NPM.
+
+## Module Loaders
+
+Module loaders such as [RequireJS](http://requirejs.org/) and [Browserify](http://browserify.org/) implement module systems like AMD (Asynchronous Module Definition) and CommonJS to allow developers to modularize and load their code.
+
+You can add support for AMD/CommonJS loaders to your Leaflet plugin by following this pattern based on the [Universal Module  Definition](https://github.com/umdjs/umd/blob/master/templates/returnExportsGlobal.js)
+
+```js
+(function (factory, window) {
+
+    // define an AMD module that relies on 'leaflet'
+    if (typeof define === 'function' && define.amd) {
+        define(['leaflet'], factory);
+
+    // define a Common JS module that relies on 'leaflet'
+    } else if (typeof exports === 'object') {
+        module.exports = factory(require('leaflet'));
+    }
+
+    // attach your plugin to the global 'L' variable
+    if (typeof window !== 'undefined' && window.L) {
+        window.L.YourPlugin = factory(L);
+    }
+}(function (L) {
+    var MyLeafletPlugin = {};
+    // implement your plugin
+
+    // return your plugin when you are done
+    return MyLeafletPlugin;
+}, window));
+```
+
+Now your plugin is available as an AMD and CommonJS module and can be used in module loaders like Browserify and RequireJS.
+
+
+## Adding to the plugins list
+
+Once your plugin is published, it is a good idea to add it to the [Leaflet plugins list](http://leafletjs.com/plugins.html). To do so:
+
+* [Fork](https://help.github.com/articles/fork-a-repo/) the Leaflet repo.
+* In the `docs/plugins.md` file, find the section your plugin should go in, and add a table row with information and links about your plugin.
+* Commit the code to your fork.
+* [Open a pull request](https://help.github.com/articles/creating-a-pull-request/) from your fork to Leaflet's original repo.
+
+Once the pull request is done, a Leaflet maintainer will have a quick look at your
+plugin and, if everything looks right, your plugin will appear in the list shortly thereafter.