highcharts-rails 5.0.14 → 6.0.0

data/app/assets/javascripts/highcharts/modules/broken-axis.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.14 (2017-07-28)
+ * @license Highcharts JS v6.0.0 (2017-10-04)
  *
  * (c) 2009-2017 Torstein Honsi
  *
@@ -384,7 +384,7 @@
              * @type {String}
              * @see [gapSize](plotOptions.series.gapSize)
              * @default relative
-             * @validvalues ["relative", "value"]
+             * @validvalue ["relative", "value"]
              * @since 5.0.13
              * @product highstock
              * @apioption plotOptions.series.gapUnit

data/app/assets/javascripts/highcharts/modules/bullet.js

@@ -0,0 +1,364 @@
+/**
+ * @license  Highcharts JS v6.0.0 (2017-10-04)
+ *
+ * Bullet graph series type for Highcharts
+ *
+ * (c) 2010-2017 Kacper Madej
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function(factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function(Highcharts) {
+    (function(H) {
+        /**
+         * (c) 2010-2017 Kacper Madej
+         *
+         * License: www.highcharts.com/license
+         */
+
+
+        var each = H.each,
+            pick = H.pick,
+            isNumber = H.isNumber,
+            relativeLength = H.relativeLength,
+            seriesType = H.seriesType,
+            columnProto = H.seriesTypes.column.prototype;
+
+        /**
+         * The bullet series type.
+         *
+         * @constructor seriesTypes.bullet
+         * @augments seriesTypes.column
+         */
+        seriesType('bullet', 'column',
+            /**
+             * A bullet graph is a variation of a bar graph. The bullet graph features
+             * a single measure, compares it to a target, and displays it in the context
+             * of qualitative ranges of performance that could be set using
+             * [plotBands](#yAxis.plotBands) on [yAxis](#yAxis).
+             * 
+             * @extends {plotOptions.column}
+             * @product highcharts
+             * @sample {highcharts} highcharts/demo/bullet-graph/ Bullet graph
+             * @since 6.0.0
+             * @excluding allAreas,boostThreshold,colorAxis,compare,compareBase
+             * @optionparent plotOptions.bullet
+             */
+            {
+                /**
+                 * All options related with look and positiong of targets.
+                 *
+                 * @sample {highcharts} highcharts/plotoptions/bullet-targetoptions/
+                 *                      Target options
+                 * 
+                 * @type {Object}
+                 * @since 6.0.0
+                 * @product highcharts
+                 */
+                targetOptions: {
+                    /**
+                     * The width of the rectangle representing the target. Could be set as
+                     * a pixel value or as a percentage of a column width.
+                     * 
+                     * @type {Number|String}
+                     * @since 6.0.0
+                     * @product highcharts
+                     */
+                    width: '140%',
+
+                    /**
+                     * The height of the rectangle representing the target.
+                     * 
+                     * @since 6.0.0
+                     * @product highcharts
+                     */
+                    height: 3,
+
+
+                    /**
+                     * The border width of the rectangle representing the target.
+                     *
+                     * In styled mode, use class `highcharts-bullet-target` instead.
+                     * 
+                     * @since 6.0.0
+                     * @product highcharts
+                     */
+                    borderWidth: 0
+
+                    /**
+                     * The border color of the rectangle representing the target. When
+                     * not set, the  point's border color is used.
+                     *
+                     * In styled mode, use class `highcharts-bullet-target` instead.
+                     * 
+                     * @type {Color}
+                     * @since 6.0.0
+                     * @product highcharts
+                     * @apioption plotOptions.bullet.targetOptions.borderColor
+                     */
+
+                    /**
+                     * The color of the rectangle representing the target. When not set,
+                     * point's color (if set in point's options -
+                     * [`color`](#series.bullet.data.color)) or zone of the target value
+                     * (if [`zones`](#plotOptions.bullet.zones) or
+                     * [`negativeColor`](#plotOptions.bullet.negativeColor) are set)
+                     * or the same color as the point has is used.
+                     *
+                     * In styled mode, use class `highcharts-bullet-target` instead.
+                     * 
+                     * @type {Color}
+                     * @since 6.0.0
+                     * @product highcharts
+                     * @apioption plotOptions.bullet.targetOptions.color
+                     */
+
+                },
+
+                tooltip: {
+
+                    pointFormat: '<span style="color:{series.color}">\u25CF</span> {series.name}: <b>{point.y}</b>. Target: <b>{point.target}</b><br/>'
+
+                }
+            }, {
+                pointArrayMap: ['y', 'target'],
+                parallelArrays: ['x', 'y', 'target'],
+
+                /**
+                 * Draws the targets. For inverted chart, the `series.group` is rotated,
+                 * so the same coordinates apply. This method is based on
+                 * column series drawPoints function.
+                 */
+                drawPoints: function() {
+                    var series = this,
+                        chart = series.chart,
+                        options = series.options,
+                        animationLimit = options.animationLimit || 250;
+
+                    columnProto.drawPoints.apply(this);
+
+                    each(series.points, function(point) {
+                        var pointOptions = point.options,
+                            shapeArgs,
+                            targetGraphic = point.targetGraphic,
+                            targetShapeArgs,
+                            targetVal = point.target,
+                            pointVal = point.y,
+                            width,
+                            height,
+                            targetOptions,
+                            y;
+
+                        if (isNumber(targetVal) && targetVal !== null) {
+                            targetOptions = H.merge(
+                                options.targetOptions,
+                                pointOptions.targetOptions
+                            );
+                            height = targetOptions.height;
+
+                            shapeArgs = point.shapeArgs;
+                            width = relativeLength(
+                                targetOptions.width,
+                                shapeArgs.width
+                            );
+                            y = series.yAxis.translate(
+                                targetVal,
+                                false,
+                                true,
+                                false,
+                                true
+                            ) - targetOptions.height / 2 - 0.5;
+
+                            targetShapeArgs = series.crispCol.apply({
+                                // Use fake series object to set borderWidth of target
+                                chart: chart,
+                                borderWidth: targetOptions.borderWidth,
+                                options: {
+                                    crisp: options.crisp
+                                }
+                            }, [
+                                shapeArgs.x + shapeArgs.width / 2 - width / 2,
+                                y,
+                                width,
+                                height
+                            ]);
+
+                            if (targetGraphic) {
+                                // Update
+                                targetGraphic[
+                                    chart.pointCount < animationLimit ?
+                                    'animate' :
+                                    'attr'
+                                ](targetShapeArgs);
+
+                                // Add or remove tooltip reference
+                                if (isNumber(pointVal) && pointVal !== null) {
+                                    targetGraphic.element.point = point;
+                                } else {
+                                    targetGraphic.element.point = undefined;
+                                }
+                            } else {
+                                point.targetGraphic = targetGraphic = chart.renderer
+                                    .rect()
+                                    .attr(targetShapeArgs)
+                                    .add(series.group);
+                            }
+
+                            // Presentational              
+                            targetGraphic.attr({
+                                fill: pick(
+                                    targetOptions.color,
+                                    pointOptions.color,
+                                    (series.zones.length && (point.getZone.call({
+                                        series: series,
+                                        x: point.x,
+                                        y: targetVal,
+                                        options: {}
+                                    }).color || series.color)) || undefined,
+                                    point.color,
+                                    series.color
+                                ),
+                                stroke: pick(
+                                    targetOptions.borderColor,
+                                    point.borderColor,
+                                    series.options.borderColor
+                                ),
+                                'stroke-width': targetOptions.borderWidth
+                            });
+
+
+                            // Add tooltip reference
+                            if (isNumber(pointVal) && pointVal !== null) {
+                                targetGraphic.element.point = point;
+                            }
+
+                            targetGraphic.addClass(point.getClassName() +
+                                ' highcharts-bullet-target', true);
+                        } else if (targetGraphic) {
+                            point.targetGraphic = targetGraphic.destroy(); // #1269
+                        }
+                    });
+                },
+
+                /**
+                 * Includes target values to extend extremes from y values.
+                 */
+                getExtremes: function(yData) {
+                    var series = this,
+                        targetData = series.targetData,
+                        yMax,
+                        yMin;
+
+                    columnProto.getExtremes.call(this, yData);
+
+                    if (targetData && targetData.length) {
+                        yMax = series.dataMax;
+                        yMin = series.dataMin;
+                        columnProto.getExtremes.call(this, targetData);
+                        series.dataMax = Math.max(series.dataMax, yMax);
+                        series.dataMin = Math.min(series.dataMin, yMin);
+                    }
+                }
+            }, /** @lends seriesTypes.ohlc.prototype.pointClass.prototype */ {
+                /**
+                 * Destroys target graphic.
+                 */
+                destroy: function() {
+                    if (this.targetGraphic) {
+                        this.targetGraphic = this.targetGraphic.destroy();
+                    }
+                    columnProto.pointClass.prototype.destroy.apply(this, arguments);
+                }
+            });
+
+
+        /**
+         * A `bullet` series. If the [type](#series.bullet.type) option is not
+         * specified, it is inherited from [chart.type](#chart.type).
+         * 
+         * For options that apply to multiple series, it is recommended to add
+         * them to the [plotOptions.series](#plotOptions.series) options structure.
+         * To apply to all series of this specific type, apply it to [plotOptions.
+         * bullet](#plotOptions.bullet).
+         * 
+         * @type {Object}
+         * @since 6.0.0
+         * @extends series,plotOptions.bullet
+         * @excluding dataParser,dataURL
+         * @product highcharts
+         * @apioption series.bullet
+         */
+
+        /**
+         * An array of data points for the series. For the `bullet` series type,
+         * points can be given in the following ways:
+         * 
+         * 1.  An array of arrays with 3 or 2 values. In this case, the values
+         * correspond to `x,y,target`. If the first value is a string,
+         * it is applied as the name of the point, and the `x` value is inferred.
+         * The `x` value can also be omitted, in which case the inner arrays
+         * should be of length 2\. Then the `x` value is automatically calculated,
+         * either starting at 0 and incremented by 1, or from `pointStart`
+         * and `pointInterval` given in the series options.
+         * 
+         *  ```js
+         *     data: [
+         *         [0, 40, 75],
+         *         [1, 50, 50],
+         *         [2, 60, 40]
+         *     ]
+         *  ```
+         * 
+         * 2.  An array of objects with named values. The objects are point
+         * configuration objects as seen below. If the total number of data
+         * points exceeds the series' [turboThreshold](#series.bullet.turboThreshold),
+         * this option is not available.
+         * 
+         *  ```js
+         *     data: [{
+         *         x: 0,
+         *         y: 40,
+         *         target: 75,
+         *         name: "Point1",
+         *         color: "#00FF00"
+         *     }, {
+         *         x: 1,
+         *         y: 60,
+         *         target: 40,
+         *         name: "Point2",
+         *         color: "#FF00FF"
+         *     }]
+         *  ```
+         * 
+         * @type {Array<Object|Array>}
+         * @since 6.0.0
+         * @extends series.column.data
+         * @product highcharts
+         * @apioption series.bullet.data
+         */
+
+        /**
+         * The target value of a point.
+         * 
+         * @type {Number}
+         * @since 6.0.0
+         * @product highcharts
+         * @apioption series.bullet.data.target
+         */
+
+        /**
+         * Individual target options for each point.
+         * 
+         * @extends series.bullet.targetOptions
+         * @product highcharts
+         * @apioption series.bullet.data.targetOptions
+         */
+
+    }(Highcharts));
+}));

data/app/assets/javascripts/highcharts/modules/data.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.14 (2017-07-28)
+ * @license Highcharts JS v6.0.0 (2017-10-04)
  * Data module
  *
  * (c) 2012-2017 Torstein Honsi
@@ -34,8 +34,311 @@
             inArray = Highcharts.inArray,
             isNumber = Highcharts.isNumber,
             splat = Highcharts.splat,
+            fireEvent = Highcharts.fireEvent,
+            some,
             SeriesBuilder;
 
+        // `some` function
+        if (!Array.prototype.some) {
+            some = function(arr, fn, ctx) { // legacy
+                var i = 0,
+                    len = arr.length;
+
+                for (; i < len; i++) {
+                    if (fn.call(ctx, arr[i], i, arr) === true) {
+                        return;
+                    }
+                }
+            };
+        } else {
+            some = function(arr, fn, ctx) {
+                Array.prototype.some.call(arr, fn, ctx);
+            };
+        }
+
+        /**
+         * The Data module provides a simplified interface for adding data to
+         * a chart from sources like CVS, HTML tables or grid views. See also
+         * the [tutorial article on the Data module](http://www.highcharts.com/docs/working-
+         * with-data/data-module).
+         *
+         * It requires the `modules/data.js` file to be loaded.
+         *
+         * Please note that the default way of adding data in Highcharts, without
+         * the need of a module, is through the [series.data](#series.data)
+         * option.
+         *
+         * @sample {highcharts} highcharts/demo/column-parsed/ HTML table
+         * @sample {highcharts} highcharts/data/csv/ CSV
+         * @since 4.0
+         * @product highcharts
+         * @apioption data
+         */
+
+        /**
+         * A two-dimensional array representing the input data on tabular form.
+         * This input can be used when the data is already parsed, for example
+         * from a grid view component. Each cell can be a string or number.
+         * If not switchRowsAndColumns is set, the columns are interpreted as
+         * series.
+         *
+         * @type {Array<Array<Mixed>>}
+         * @see [data.rows](#data.rows)
+         * @sample {highcharts} highcharts/data/columns/ Columns
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.columns
+         */
+
+        /**
+         * The callback that is evaluated when the data is finished loading,
+         * optionally from an external source, and parsed. The first argument
+         * passed is a finished chart options object, containing the series.
+         * These options can be extended with additional options and passed
+         * directly to the chart constructor.
+         *
+         * @type {Function}
+         * @see [data.parsed](#data.parsed)
+         * @sample {highcharts} highcharts/data/complete/ Modify data on complete
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.complete
+         */
+
+        /**
+         * A comma delimited string to be parsed. Related options are [startRow](#data.
+         * startRow), [endRow](#data.endRow), [startColumn](#data.startColumn)
+         * and [endColumn](#data.endColumn) to delimit what part of the table
+         * is used. The [lineDelimiter](#data.lineDelimiter) and [itemDelimiter](#data.
+         * itemDelimiter) options define the CSV delimiter formats.
+         *
+         * The built-in CSV parser doesn't support all flavours of CSV, so in
+         * some cases it may be necessary to use an external CSV parser. See
+         * [this example](http://jsfiddle.net/highcharts/u59176h4/) of parsing
+         * CSV through the MIT licensed [Papa Parse](http://papaparse.com/)
+         * library.
+         *
+         * @type {String}
+         * @sample {highcharts} highcharts/data/csv/ Data from CSV
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.csv
+         */
+
+        /**
+         * Which of the predefined date formats in Date.prototype.dateFormats
+         * to use to parse date values. Defaults to a best guess based on what
+         * format gives valid and ordered dates.
+         *
+         * Valid options include:
+         *
+         * *   `YYYY-mm-dd`
+         * *   `dd/mm/YYYY`
+         * *   `mm/dd/YYYY`
+         * *   `dd/mm/YY`
+         * *   `mm/dd/YY`
+         *
+         * @validvalue [undefined, "YYYY-mm-dd", "dd/mm/YYYY", "mm/dd/YYYY", "dd/mm/YYYY", "dd/mm/YY", "mm/dd/YY"]
+         * @type {String}
+         * @see [data.parseDate](#data.parseDate)
+         * @sample {highcharts} highcharts/data/dateformat-auto/ Best guess date format
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.dateFormat
+         */
+
+        /**
+         * The decimal point used for parsing numbers in the CSV.
+         *
+         * If both this and data.delimiter is set to false, the parser will
+         * attempt to deduce the decimal point automatically.
+         *
+         * @type {String}
+         * @sample {highcharts} highcharts/data/delimiters/ Comma as decimal point
+         * @default .
+         * @since 4.1.0
+         * @product highcharts
+         * @apioption data.decimalPoint
+         */
+
+        /**
+         * In tabular input data, the last column (indexed by 0) to use. Defaults
+         * to the last column containing data.
+         *
+         * @type {Number}
+         * @sample {highcharts} highcharts/data/start-end/ Limited data
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.endColumn
+         */
+
+        /**
+         * In tabular input data, the last row (indexed by 0) to use. Defaults
+         * to the last row containing data.
+         *
+         * @type {Number}
+         * @sample {highcharts} highcharts/data/start-end/ Limited data
+         * @since 4.0.4
+         * @product highcharts
+         * @apioption data.endRow
+         */
+
+        /**
+         * Whether to use the first row in the data set as series names.
+         *
+         * @type {Boolean}
+         * @sample {highcharts} highcharts/data/start-end/ Don't get series names from the CSV
+         * @sample {highstock} highcharts/data/start-end/ Don't get series names from the CSV
+         * @default true
+         * @since 4.1.0
+         * @product highcharts highstock
+         * @apioption data.firstRowAsNames
+         */
+
+        /**
+         * The key for a Google Spreadsheet to load. See [general information
+         * on GS](https://developers.google.com/gdata/samples/spreadsheet_sample).
+         *
+         * @type {String}
+         * @sample {highcharts} highcharts/data/google-spreadsheet/ Load a Google Spreadsheet
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.googleSpreadsheetKey
+         */
+
+        /**
+         * The Google Spreadsheet worksheet to use in combination with [googleSpreadsheetKey](#data.
+         * googleSpreadsheetKey). The available id's from your sheet can be
+         * read from `https://spreadsheets.google.com/feeds/worksheets/{key}/public/basic`
+         *
+         * @type {String}
+         * @sample {highcharts} highcharts/data/google-spreadsheet/ Load a Google Spreadsheet
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.googleSpreadsheetWorksheet
+         */
+
+        /**
+         * Item or cell delimiter for parsing CSV. Defaults to the tab character
+         * `\t` if a tab character is found in the CSV string, if not it defaults
+         * to `,`.
+         *
+         * If this is set to false or undefined, the parser will attempt to deduce
+         * the delimiter automatically.
+         *
+         * @type {String}
+         * @sample {highcharts} highcharts/data/delimiters/ Delimiters
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.itemDelimiter
+         */
+
+        /**
+         * Line delimiter for parsing CSV.
+         *
+         * @type {String}
+         * @sample {highcharts} highcharts/data/delimiters/ Delimiters
+         * @default \n
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.lineDelimiter
+         */
+
+        /**
+         * A callback function to parse string representations of dates into
+         * JavaScript timestamps. Should return an integer timestamp on success.
+         *
+         * @type {Function}
+         * @see [dateFormat](#data.dateFormat)
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.parseDate
+         */
+
+        /**
+         * A callback function to access the parsed columns, the two-dimentional
+         * input data array directly, before they are interpreted into series
+         * data and categories. Return `false` to stop completion, or call `this.
+         * complete()` to continue async.
+         *
+         * @type {Function}
+         * @see [data.complete](#data.complete)
+         * @sample {highcharts} highcharts/data/parsed/ Modify data after parse
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.parsed
+         */
+
+        /**
+         * The same as the columns input option, but defining rows intead of
+         * columns.
+         *
+         * @type {Array<Array<Mixed>>}
+         * @see [data.columns](#data.columns)
+         * @sample {highcharts} highcharts/data/rows/ Data in rows
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.rows
+         */
+
+        /**
+         * An array containing object with Point property names along with what
+         * column id the property should be taken from.
+         *
+         * @type {Array<Object>}
+         * @sample {highcharts} highcharts/data/seriesmapping-label/ Label from data set
+         * @since 4.0.4
+         * @product highcharts
+         * @apioption data.seriesMapping
+         */
+
+        /**
+         * In tabular input data, the first column (indexed by 0) to use.
+         *
+         * @type {Number}
+         * @sample {highcharts} highcharts/data/start-end/ Limited data
+         * @default 0
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.startColumn
+         */
+
+        /**
+         * In tabular input data, the first row (indexed by 0) to use.
+         *
+         * @type {Number}
+         * @sample {highcharts} highcharts/data/start-end/ Limited data
+         * @default 0
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.startRow
+         */
+
+        /**
+         * Switch rows and columns of the input data, so that `this.columns`
+         * effectively becomes the rows of the data set, and the rows are interpreted
+         * as series.
+         *
+         * @type {Boolean}
+         * @sample {highcharts} highcharts/data/switchrowsandcolumns/ Switch rows and columns
+         * @default false
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.switchRowsAndColumns
+         */
+
+        /**
+         * A HTML table or the id of such to be parsed as input data. Related
+         * options are `startRow`, `endRow`, `startColumn` and `endColumn` to
+         * delimit what part of the table is used.
+         *
+         * @type {String|HTMLElement}
+         * @sample {highcharts} highcharts/demo/column-parsed/ Parsed table
+         * @since 4.0
+         * @product highcharts
+         * @apioption data.table
+         */
+
 
         // The Data constructor
         var Data = function(dataOptions, chartOptions) {
@@ -74,14 +377,14 @@
                     // Parse a HTML table if options.table is given
                     this.parseTable();
 
-                    // Parse a Google Spreadsheet 
+                    // Parse a Google Spreadsheet
                     this.parseGoogleSpreadsheet();
                 }
 
             },
 
             /**
-             * Get the column distribution. For example, a line series takes a single column for 
+             * Get the column distribution. For example, a line series takes a single column for
              * Y values. A range series takes two columns for low and high values respectively,
              * and an OHLC series takes four columns.
              */
@@ -138,7 +441,7 @@
                     // Add missing columns
                     for (i = 0; i < numberOfValueColumnsNeeded; i++) {
                         if (!builder.hasReader(pointArrayMap[i])) {
-                            //builder.addNextColumnReader(pointArrayMap[i]);
+                            // builder.addNextColumnReader(pointArrayMap[i]);
                             // Create and add a column reader for the next free column index
                             builder.addColumnReader(undefined, pointArrayMap[i]);
                         }
@@ -190,18 +493,369 @@
             /**
              * Parse a CSV input string
              */
-            parseCSV: function() {
+            parseCSV: function(inOptions) {
                 var self = this,
-                    options = this.options,
+                    options = this.options || inOptions,
                     csv = options.csv,
-                    columns = this.columns,
+                    columns,
                     startRow = options.startRow || 0,
                     endRow = options.endRow || Number.MAX_VALUE,
                     startColumn = options.startColumn || 0,
                     endColumn = options.endColumn || Number.MAX_VALUE,
                     itemDelimiter,
                     lines,
-                    activeRowNo = 0;
+                    rowIt = 0,
+                    // activeRowNo = 0,
+                    dataTypes = [],
+                    // We count potential delimiters in the prepass, and use the
+                    // result as the basis of half-intelligent guesses.
+                    potDelimiters = {
+                        ',': 0,
+                        ';': 0,
+                        '\t': 0
+                    };
+
+                columns = this.columns = this.columns || [];
+
+                /*
+                	This implementation is quite verbose. It will be shortened once
+                	it's stable and passes all the test.
+
+                	It's also not written with speed in mind, instead everything is
+                	very seggregated, and there a several redundant loops.
+                	This is to make it easier to stabilize the code initially.
+
+                	We do a pre-pass on the first 4 rows to make some intelligent
+                	guesses on the set. Guessed delimiters are in this pass counted.
+
+                	Auto detecting delimiters
+                		- If we meet a quoted string, the next symbol afterwards
+                		  (that's not \s, \t) is the delimiter
+                		- If we meet a date, the next symbol afterwards is the delimiter
+
+                	Date formats
+                		- If we meet a column with date formats, check all of them to
+                		  see if one of the potential months crossing 12. If it does,
+                		  we now know the format
+
+                	It would make things easier to guess the delimiter before
+                	doing the actual parsing.
+
+                	General rules:
+                		- Quoting is allowed, e.g: "Col 1",123,321
+                		- Quoting is optional, e.g.: Col1,123,321
+                		- Doubble quoting is escaping, e.g. "Col ""Hello world""",123
+                		- Spaces are considered part of the data: Col1 ,123
+                		- New line is always the row delimiter
+                		- Potential column delimiters are , ; \t
+                		- First row may optionally contain headers
+                		- The last row may or may not have a row delimiter
+                		- Comments are optionally supported, in which case the comment
+                		  must start at the first column, and the rest of the line will
+                		  be ignored
+                */
+
+                // Parse a single row
+                function parseRow(columnStr, rowNumber, noAdd, callbacks) {
+                    var i = 0,
+                        c = '',
+                        cl = '',
+                        cn = '',
+                        token = '',
+                        column = 0;
+
+                    function read(j) {
+                        c = columnStr[j];
+                        cl = columnStr[j - 1];
+                        cn = columnStr[j + 1];
+                    }
+
+                    function pushType(type) {
+                        if (dataTypes.length < column + 1) {
+                            dataTypes.push([type]);
+                        }
+                        if (dataTypes[column][dataTypes[column].length - 1] !== type) {
+                            dataTypes[column].push(type);
+                        }
+                    }
+
+                    function push() {
+                        if (startColumn > column || column > endColumn) {
+                            // Skip this column
+                            return;
+                        }
+
+                        if (!isNaN(parseFloat(token)) && isFinite(token)) {
+                            token = parseFloat(token);
+                            pushType('number');
+                        } else if (!isNaN(Date.parse(token))) {
+                            token = token.replace(/\//g, '-');
+                            pushType('date');
+                        } else {
+                            pushType('string');
+                        }
+
+                        if (columns.length < column + 1) {
+                            columns.push([]);
+                        }
+
+                        if (!noAdd) {
+                            columns[column].push(token);
+                        }
+
+                        token = '';
+                        ++column;
+                    }
+
+                    if (!columnStr.trim().length) {
+                        return;
+                    }
+
+                    if (columnStr.trim()[0] === '#') {
+                        return;
+                    }
+
+                    for (; i < columnStr.length; i++) {
+                        read(i);
+
+                        // Quoted string
+                        if (c === '#') {
+                            // The rest of the row is a comment
+                            return;
+                        } else if (c === '"') {
+                            read(++i);
+
+                            while (i < columnStr.length) {
+                                if (c === '"' && cl !== '"' && cn !== '"') {
+                                    break;
+                                }
+
+                                if (c !== '"' || (c === '"' && cl !== '"')) {
+                                    token += c;
+                                }
+
+                                read(++i);
+                            }
+
+                            // Perform "plugin" handling
+                        } else if (callbacks && callbacks[c]) {
+                            if (callbacks[c](c, token)) {
+                                push();
+                            }
+
+                            // Delimiter - push current token
+                        } else if (c === itemDelimiter) {
+                            push();
+
+                            // Actual column data
+                        } else {
+                            token += c;
+                        }
+                    }
+
+                    push();
+
+                    if (column < columns.length) {
+                        // There might be an issue.
+                        // This set is either
+
+                        // Fill in
+                        if (!noAdd) {
+                            for (var z = column; z < columns.length; z++) {
+                                columns[z].push(0);
+                            }
+                        }
+                    }
+                }
+
+                // Attempt to guess the delimiter
+                function guessDelimiter(lines) {
+                    var points = 0,
+                        commas = 0,
+                        guessed = false,
+                        handler = function(c, token) {
+                            if (c === ',') {
+                                commas++;
+                            }
+                            if (c === '.') {
+                                points++;
+                            }
+
+                            if (typeof potDelimiters[c] !== 'undefined') {
+                                // Check what we have in token now
+
+                                if (
+                                    // We can't make a deduction when token is a number,
+                                    // since the decimal delimiter may interfere.
+                                    (isNaN(parseFloat(token)) || !isFinite(token)) &&
+                                    (
+                                        // Highcharts.isString(token) ||
+                                        !isNaN(Date.parse(token))
+                                    )
+                                ) {
+                                    potDelimiters[c]++;
+                                    return true;
+                                }
+                            }
+                        },
+                        callbacks = {
+                            ';': handler,
+                            ',': handler,
+                            '\t': handler
+                        };
+
+                    some(lines, function(columnStr, i) {
+                        // We should be able to detect dateformats within 13 rows
+                        if (i > 13) {
+                            return true;
+                        }
+                        parseRow(columnStr, i, true, callbacks);
+                    });
+
+                    // Count the potential delimiters.
+                    // This could be improved by checking if the number of delimiters
+                    // equals the number of columns - 1
+                    if (potDelimiters[';'] > potDelimiters[',']) {
+                        guessed = ';';
+                    } else if (potDelimiters[','] > potDelimiters[';']) {
+                        guessed = ',';
+                    } else {
+                        // No good guess could be made..
+                        guessed = ',';
+                    }
+
+                    // Try to deduce the decimal point if it's not explicitly set.
+                    // If both commas or points is > 0 there is likely an issue
+                    if (!options.decimalPoint) {
+                        if (points > commas) {
+                            options.decimalPoint = '.';
+                        } else {
+                            options.decimalPoint = ',';
+                        }
+
+                        // Apply a new decimal regex based on the pressumed decimal sep.
+                        self.decimalRegex = new RegExp(
+                            '^(-?[0-9]+)' +
+                            options.decimalPoint +
+                            '([0-9]+)$'
+                        );
+                    }
+
+                    return guessed;
+                }
+
+                /* Tries to guess the date format
+                 *	- Check if either month candidate exceeds 12
+                 *  - Check if year is missing (use current year)
+                 *  - Check if a shortened year format is used (e.g. 1/1/99)
+                 *  - If no guess can be made, the user must be prompted
+                 * data is the data to deduce a format based on
+                 */
+                function deduceDateFormat(data, limit) {
+                    var format = 'YYYY-mm-dd',
+                        thing,
+                        guessedFormat,
+                        calculatedFormat,
+                        i = 0,
+                        madeDeduction = false,
+                        // candidates = {},
+                        stable = [],
+                        max = [],
+                        j;
+
+                    if (!limit || limit > data.length) {
+                        limit = data.length;
+                    }
+
+                    for (; i < limit; i++) {
+                        if (typeof data[i] !== 'undefined' && data[i] && data[i].length) {
+                            thing = data[i]
+                                .trim()
+                                .replace(/\//g, ' ')
+                                .replace(/\-/g, ' ')
+                                .split(' ');
+
+                            guessedFormat = [
+                                '',
+                                '',
+                                ''
+                            ];
+
+
+                            for (j = 0; j < thing.length; j++) {
+                                if (j < guessedFormat.length) {
+                                    thing[j] = parseInt(thing[j], 10);
+
+                                    if (thing[j]) {
+
+                                        max[j] = (!max[j] || max[j] < thing[j]) ? thing[j] : max[j];
+
+                                        if (typeof stable[j] !== 'undefined') {
+                                            if (stable[j] !== thing[j]) {
+                                                stable[j] = false;
+                                            }
+                                        } else {
+                                            stable[j] = thing[j];
+                                        }
+
+                                        if (thing[j] > 31) {
+                                            if (thing[j] < 100) {
+                                                guessedFormat[j] = 'YY';
+                                            } else {
+                                                guessedFormat[j] = 'YYYY';
+                                            }
+                                            // madeDeduction = true;
+                                        } else if (thing[j] > 12 && thing[j] <= 31) {
+                                            guessedFormat[j] = 'dd';
+                                            madeDeduction = true;
+                                        } else if (!guessedFormat[j].length) {
+                                            guessedFormat[j] = 'mm';
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    if (madeDeduction) {
+
+                        // This handles a few edge cases with hard to guess dates
+                        for (j = 0; j < stable.length; j++) {
+                            if (stable[j] !== false) {
+                                if (max[j] > 12 && guessedFormat[j] !== 'YY' && guessedFormat[j] !== 'YYYY') {
+                                    guessedFormat[j] = 'YY';
+                                }
+                            } else if (max[j] > 12 && guessedFormat[j] === 'mm') {
+                                guessedFormat[j] = 'dd';
+                            }
+                        }
+
+                        calculatedFormat = guessedFormat.join('/');
+
+
+                        // If the caculated format is not valid, we need to present an error.
+
+                        if (!(options.dateFormats || self.dateFormats)[calculatedFormat]) {
+                            // This should emit an event instead
+                            fireEvent('invalidDateFormat');
+                            Highcharts.error('Could not deduce date format');
+                            return format;
+                        }
+
+                        return calculatedFormat;
+                    }
+
+                    return format;
+                }
+
+                /* Figure out the best axis types for the data
+                 * - If the first column is a number, we're good
+                 * - If the first column is a date, set to date/time
+                 * - If the first column is a string, set to categories
+                 */
+                function deduceAxisTypes() {
+
+                }
 
                 if (csv) {
 
@@ -210,31 +864,67 @@
                         .replace(/\r/g, '\n') // Mac
                         .split(options.lineDelimiter || '\n');
 
-                    itemDelimiter = options.itemDelimiter || (csv.indexOf('\t') !== -1 ? '\t' : ',');
+                    if (!startRow || startRow < 0) {
+                        startRow = 0;
+                    }
 
-                    each(lines, function(line, rowNo) {
-                        var trimmed = self.trim(line),
-                            isComment = trimmed.indexOf('#') === 0,
-                            isBlank = trimmed === '',
-                            items;
+                    if (!endRow || endRow > lines.length) {
+                        endRow = lines.length;
+                    }
 
-                        if (rowNo >= startRow && rowNo <= endRow && !isComment && !isBlank) {
-                            items = line.split(itemDelimiter);
-                            each(items, function(item, colNo) {
-                                if (colNo >= startColumn && colNo <= endColumn) {
-                                    if (!columns[colNo - startColumn]) {
-                                        columns[colNo - startColumn] = [];
-                                    }
+                    if (options.itemDelimiter) {
+                        itemDelimiter = options.itemDelimiter;
+                    } else {
+                        itemDelimiter = null;
+                        itemDelimiter = guessDelimiter(lines);
+                    }
 
-                                    columns[colNo - startColumn][activeRowNo] = item;
-                                }
-                            });
-                            activeRowNo += 1;
-                        }
-                    });
+                    for (rowIt = startRow; rowIt < endRow; rowIt++) {
+                        parseRow(lines[rowIt], rowIt);
+                    }
+
+                    // //Make sure that there's header columns for everything
+                    // each(columns, function (col) {
+
+                    // });
+
+                    deduceAxisTypes();
+
+                    if ((!options.columnTypes || options.columnTypes.length === 0) &&
+                        dataTypes.length &&
+                        dataTypes[0].length &&
+                        dataTypes[0][1] === 'date' &&
+                        !options.dateFormat) {
+                        options.dateFormat = deduceDateFormat(columns[0]);
+                    }
+
+
+                    // each(lines, function (line, rowNo) {
+                    //	var trimmed = self.trim(line),
+                    //		isComment = trimmed.indexOf('#') === 0,
+                    //		isBlank = trimmed === '',
+                    //		items;
+
+                    //	if (rowNo >= startRow && rowNo <= endRow && !isComment && !isBlank) {
+                    //		items = line.split(itemDelimiter);
+                    //		each(items, function (item, colNo) {
+                    //			if (colNo >= startColumn && colNo <= endColumn) {
+                    //				if (!columns[colNo - startColumn]) {
+                    //					columns[colNo - startColumn] = [];
+                    //				}
+
+                    //				columns[colNo - startColumn][activeRowNo] = item;
+                    //			}
+                    //		});
+                    //		activeRowNo += 1;
+                    //	}
+                    // });
+                    //
 
                     this.dataFound();
                 }
+
+                return columns;
             },
 
             /**
@@ -274,6 +964,7 @@
             },
 
             /**
+             * Parse a Google spreadsheet.
              */
             parseGoogleSpreadsheet: function() {
                 var self = this,
@@ -303,7 +994,7 @@
                                 rowCount = 0,
                                 i;
 
-                            // First, find the total number of columns and rows that 
+                            // First, find the total number of columns and rows that
                             // are actually filled with data
                             for (i = 0; i < cellCount; i++) {
                                 cell = cells[i];
@@ -423,7 +1114,7 @@
 
                     // Disable number or date parsing by setting the X axis type to category
                     if (forceCategory || (row === 0 && firstRowAsNames)) {
-                        column[row] = trimVal;
+                        column[row] = '' + trimVal;
 
                     } else if (+trimInsideVal === floatVal) { // is numeric
 
@@ -449,7 +1140,7 @@
                             column[row] = dateVal;
                             column.isDatetime = true;
 
-                            // Check if the dates are uniformly descending or ascending. If they 
+                            // Check if the dates are uniformly descending or ascending. If they
                             // are not, chances are that they are a different time format, so check
                             // for alternative.
                             if (column[row + 1] !== undefined) {
@@ -476,14 +1167,14 @@
                 }
 
                 // If strings are intermixed with numbers or dates in a parsed column, it is an indication
-                // that parsing went wrong or the data was not intended to display as numbers or dates and 
-                // parsing is too aggressive. Fall back to categories. Demonstrated in the 
+                // that parsing went wrong or the data was not intended to display as numbers or dates and
+                // parsing is too aggressive. Fall back to categories. Demonstrated in the
                 // highcharts/demo/column-drilldown sample.
                 if (isXColumn && column.mixed) {
                     columns[col] = rawColumns[col];
                 }
 
-                // If the 0 column is date or number and descending, reverse all columns. 
+                // If the 0 column is date or number and descending, reverse all columns.
                 if (isXColumn && descending && this.options.sort) {
                     for (col = 0; col < columns.length; col++) {
                         columns[col].reverse();
@@ -505,6 +1196,12 @@
                         return Date.UTC(+match[1], match[2] - 1, +match[3]);
                     }
                 },
+                'YYYY/mm/dd': {
+                    regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
+                    parser: function(match) {
+                        return Date.UTC(+match[1], match[2] - 1, +match[3]);
+                    }
+                },
                 'dd/mm/YYYY': {
                     regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
                     parser: function(match) {
@@ -521,7 +1218,16 @@
                 'dd/mm/YY': {
                     regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
                     parser: function(match) {
-                        return Date.UTC(+match[3] + 2000, match[2] - 1, +match[1]);
+                        var year = +match[3],
+                            d = new Date();
+
+                        if (year > (d.getFullYear() - 2000)) {
+                            year += 1900;
+                        } else {
+                            year += 2000;
+                        }
+
+                        return Date.UTC(year, match[2] - 1, +match[1]);
                     },
                     alternative: 'mm/dd/YY' // different format with the same regex
                 },
@@ -563,12 +1269,20 @@
                         // Next time, use the one previously found
                     } else {
                         format = this.dateFormats[dateFormat];
+
+
+                        if (!format) {
+                            // The selected format is invalid
+                            format = this.dateFormats['YYYY-mm-dd'];
+                        }
+
                         match = val.match(format.regex);
                         if (match) {
                             ret = format.parser(match);
                         }
+
                     }
-                    // Fall back to Date.parse		
+                    // Fall back to Date.parse
                     if (!match) {
                         match = Date.parse(val);
                         // External tools like Date.js and MooTools extend Date object and
@@ -652,7 +1366,7 @@
             },
 
             /**
-             * If a complete callback function is provided in the options, interpret the 
+             * If a complete callback function is provided in the options, interpret the
              * columns into a Highcharts options object.
              */
             complete: function() {
@@ -790,6 +1504,19 @@
                         options.afterComplete(chartOptions);
                     }
                 }
+
+            },
+
+            update: function(options, redraw) {
+                var chart = this.chart;
+                if (options) {
+                    // Set the complete handler
+                    options.afterComplete = function(dataOptions) {
+                        chart.update(dataOptions, redraw);
+                    };
+                    // Apply it
+                    Highcharts.data(options);
+                }
             }
         });
 
@@ -805,7 +1532,7 @@
             var chart = this;
 
             if (userOptions && userOptions.data) {
-                Highcharts.data(Highcharts.extend(userOptions.data, {
+                chart.data = new Data(Highcharts.extend(userOptions.data, {
 
                     afterComplete: function(dataOptions) {
                         var i, series;
@@ -829,6 +1556,7 @@
                         proceed.call(chart, userOptions, callback);
                     }
                 }), userOptions);
+                chart.data.chart = chart;
             } else {
                 proceed.call(chart, userOptions, callback);
             }
@@ -840,7 +1568,7 @@
          * Ex: A series builder can be constructed to read column 3 as 'x' and
          * column 7 and 8 as 'y1' and 'y2'.
          * The output would then be points/rows of the form {x: 11, y1: 22, y2: 33}
-         * 
+         *
          * The name of the builder is taken from the second column. In the above
          * example it would be the column with index 7.
          * @constructor