Repository: couchdb-fauxton Updated Branches: refs/heads/master e41b78536 -> f1a20274b
Add papaparse.js library http://papaparse.com/ Project: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/repo Commit: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/commit/f1a20274 Tree: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/tree/f1a20274 Diff: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/diff/f1a20274 Branch: refs/heads/master Commit: f1a20274b24a3951af45e7ef70f41f54dfaff2bd Parents: e41b785 Author: Michelle Phung <michel...@apache.org> Authored: Fri Sep 11 17:04:36 2015 -0400 Committer: Michelle Phung <michel...@apache.org> Committed: Mon Sep 14 12:29:12 2015 -0400 ---------------------------------------------------------------------- assets/js/libs/papaparse.js | 1403 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 1403 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/blob/f1a20274/assets/js/libs/papaparse.js ---------------------------------------------------------------------- diff --git a/assets/js/libs/papaparse.js b/assets/js/libs/papaparse.js new file mode 100755 index 0000000..809f33d --- /dev/null +++ b/assets/js/libs/papaparse.js @@ -0,0 +1,1403 @@ +/*! + Papa Parse + v4.1.2 + https://github.com/mholt/PapaParse +*/ +(function(global) +{ + "use strict"; + + var IS_WORKER = !global.document && !!global.postMessage, + IS_PAPA_WORKER = IS_WORKER && /(\?|&)papaworker(=|&|$)/.test(global.location.search), + LOADED_SYNC = false, AUTO_SCRIPT_PATH; + var workers = {}, workerIdCounter = 0; + + var Papa = {}; + + Papa.parse = CsvToJson; + Papa.unparse = JsonToCsv; + + Papa.RECORD_SEP = String.fromCharCode(30); + Papa.UNIT_SEP = String.fromCharCode(31); + Papa.BYTE_ORDER_MARK = "\ufeff"; + Papa.BAD_DELIMITERS = ["\r", "\n", "\"", Papa.BYTE_ORDER_MARK]; + Papa.WORKERS_SUPPORTED = !IS_WORKER && !!global.Worker; + Papa.SCRIPT_PATH = null; // Must be set by your code if you use workers and this lib is loaded asynchronously + + // Configurable chunk sizes for local and remote files, respectively + Papa.LocalChunkSize = 1024 * 1024 * 10; // 10 MB + Papa.RemoteChunkSize = 1024 * 1024 * 5; // 5 MB + Papa.DefaultDelimiter = ","; // Used if not specified and detection fails + + // Exposed for testing and development only + Papa.Parser = Parser; + Papa.ParserHandle = ParserHandle; + Papa.NetworkStreamer = NetworkStreamer; + Papa.FileStreamer = FileStreamer; + Papa.StringStreamer = StringStreamer; + + if (typeof module !== 'undefined' && module.exports) + { + // Export to Node... + module.exports = Papa; + } + else if (isFunction(global.define) && global.define.amd) + { + // Wireup with RequireJS + define(function() { return Papa; }); + } + else + { + // ...or as browser global + global.Papa = Papa; + } + + if (global.jQuery) + { + var $ = global.jQuery; + $.fn.parse = function(options) + { + var config = options.config || {}; + var queue = []; + + this.each(function(idx) + { + var supported = $(this).prop('tagName').toUpperCase() == "INPUT" + && $(this).attr('type').toLowerCase() == "file" + && global.FileReader; + + if (!supported || !this.files || this.files.length == 0) + return true; // continue to next input element + + for (var i = 0; i < this.files.length; i++) + { + queue.push({ + file: this.files[i], + inputElem: this, + instanceConfig: $.extend({}, config) + }); + } + }); + + parseNextFile(); // begin parsing + return this; // maintains chainability + + + function parseNextFile() + { + if (queue.length == 0) + { + if (isFunction(options.complete)) + options.complete(); + return; + } + + var f = queue[0]; + + if (isFunction(options.before)) + { + var returned = options.before(f.file, f.inputElem); + + if (typeof returned === 'object') + { + if (returned.action == "abort") + { + error("AbortError", f.file, f.inputElem, returned.reason); + return; // Aborts all queued files immediately + } + else if (returned.action == "skip") + { + fileComplete(); // parse the next file in the queue, if any + return; + } + else if (typeof returned.config === 'object') + f.instanceConfig = $.extend(f.instanceConfig, returned.config); + } + else if (returned == "skip") + { + fileComplete(); // parse the next file in the queue, if any + return; + } + } + + // Wrap up the user's complete callback, if any, so that ours also gets executed + var userCompleteFunc = f.instanceConfig.complete; + f.instanceConfig.complete = function(results) + { + if (isFunction(userCompleteFunc)) + userCompleteFunc(results, f.file, f.inputElem); + fileComplete(); + }; + + Papa.parse(f.file, f.instanceConfig); + } + + function error(name, file, elem, reason) + { + if (isFunction(options.error)) + options.error({name: name}, file, elem, reason); + } + + function fileComplete() + { + queue.splice(0, 1); + parseNextFile(); + } + } + } + + + if (IS_PAPA_WORKER) + { + global.onmessage = workerThreadReceivedMessage; + } + else if (Papa.WORKERS_SUPPORTED) + { + AUTO_SCRIPT_PATH = getScriptPath(); + + // Check if the script was loaded synchronously + if (!document.body) + { + // Body doesn't exist yet, must be synchronous + LOADED_SYNC = true; + } + else + { + document.addEventListener('DOMContentLoaded', function () { + LOADED_SYNC = true; + }, true); + } + } + + + + + function CsvToJson(_input, _config) + { + _config = _config || {}; + + if (_config.worker && Papa.WORKERS_SUPPORTED) + { + var w = newWorker(); + + w.userStep = _config.step; + w.userChunk = _config.chunk; + w.userComplete = _config.complete; + w.userError = _config.error; + + _config.step = isFunction(_config.step); + _config.chunk = isFunction(_config.chunk); + _config.complete = isFunction(_config.complete); + _config.error = isFunction(_config.error); + delete _config.worker; // prevent infinite loop + + w.postMessage({ + input: _input, + config: _config, + workerId: w.id + }); + + return; + } + + var streamer = null; + if (typeof _input === 'string') + { + if (_config.download) + streamer = new NetworkStreamer(_config); + else + streamer = new StringStreamer(_config); + } + else if ((global.File && _input instanceof File) || _input instanceof Object) // ...Safari. (see issue #106) + streamer = new FileStreamer(_config); + + return streamer.stream(_input); + } + + + + + + + function JsonToCsv(_input, _config) + { + var _output = ""; + var _fields = []; + + // Default configuration + + /** whether to surround every datum with quotes */ + var _quotes = false; + + /** delimiting character */ + var _delimiter = ","; + + /** newline character(s) */ + var _newline = "\r\n"; + + unpackConfig(); + + if (typeof _input === 'string') + _input = JSON.parse(_input); + + if (_input instanceof Array) + { + if (!_input.length || _input[0] instanceof Array) + return serialize(null, _input); + else if (typeof _input[0] === 'object') + return serialize(objectKeys(_input[0]), _input); + } + else if (typeof _input === 'object') + { + if (typeof _input.data === 'string') + _input.data = JSON.parse(_input.data); + + if (_input.data instanceof Array) + { + if (!_input.fields) + _input.fields = _input.data[0] instanceof Array + ? _input.fields + : objectKeys(_input.data[0]); + + if (!(_input.data[0] instanceof Array) && typeof _input.data[0] !== 'object') + _input.data = [_input.data]; // handles input like [1,2,3] or ["asdf"] + } + + return serialize(_input.fields || [], _input.data || []); + } + + // Default (any valid paths should return before this) + throw "exception: Unable to serialize unrecognized input"; + + + function unpackConfig() + { + if (typeof _config !== 'object') + return; + + if (typeof _config.delimiter === 'string' + && _config.delimiter.length == 1 + && Papa.BAD_DELIMITERS.indexOf(_config.delimiter) == -1) + { + _delimiter = _config.delimiter; + } + + if (typeof _config.quotes === 'boolean' + || _config.quotes instanceof Array) + _quotes = _config.quotes; + + if (typeof _config.newline === 'string') + _newline = _config.newline; + } + + + /** Turns an object's keys into an array */ + function objectKeys(obj) + { + if (typeof obj !== 'object') + return []; + var keys = []; + for (var key in obj) + keys.push(key); + return keys; + } + + /** The double for loop that iterates the data and writes out a CSV string including header row */ + function serialize(fields, data) + { + var csv = ""; + + if (typeof fields === 'string') + fields = JSON.parse(fields); + if (typeof data === 'string') + data = JSON.parse(data); + + var hasHeader = fields instanceof Array && fields.length > 0; + var dataKeyedByField = !(data[0] instanceof Array); + + // If there a header row, write it first + if (hasHeader) + { + for (var i = 0; i < fields.length; i++) + { + if (i > 0) + csv += _delimiter; + csv += safe(fields[i], i); + } + if (data.length > 0) + csv += _newline; + } + + // Then write out the data + for (var row = 0; row < data.length; row++) + { + var maxCol = hasHeader ? fields.length : data[row].length; + + for (var col = 0; col < maxCol; col++) + { + if (col > 0) + csv += _delimiter; + var colIdx = hasHeader && dataKeyedByField ? fields[col] : col; + csv += safe(data[row][colIdx], col); + } + + if (row < data.length - 1) + csv += _newline; + } + + return csv; + } + + /** Encloses a value around quotes if needed (makes a value safe for CSV insertion) */ + function safe(str, col) + { + if (typeof str === "undefined" || str === null) + return ""; + + str = str.toString().replace(/"/g, '""'); + + var needsQuotes = (typeof _quotes === 'boolean' && _quotes) + || (_quotes instanceof Array && _quotes[col]) + || hasAny(str, Papa.BAD_DELIMITERS) + || str.indexOf(_delimiter) > -1 + || str.charAt(0) == ' ' + || str.charAt(str.length - 1) == ' '; + + return needsQuotes ? '"' + str + '"' : str; + } + + function hasAny(str, substrings) + { + for (var i = 0; i < substrings.length; i++) + if (str.indexOf(substrings[i]) > -1) + return true; + return false; + } + } + + /** ChunkStreamer is the base prototype for various streamer implementations. */ + function ChunkStreamer(config) + { + this._handle = null; + this._paused = false; + this._finished = false; + this._input = null; + this._baseIndex = 0; + this._partialLine = ""; + this._rowCount = 0; + this._start = 0; + this._nextChunk = null; + this.isFirstChunk = true; + this._completeResults = { + data: [], + errors: [], + meta: {} + }; + replaceConfig.call(this, config); + + this.parseChunk = function(chunk) + { + // First chunk pre-processing + if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) + { + var modifiedChunk = this._config.beforeFirstChunk(chunk); + if (modifiedChunk !== undefined) + chunk = modifiedChunk; + } + this.isFirstChunk = false; + + // Rejoin the line we likely just split in two by chunking the file + var aggregate = this._partialLine + chunk; + this._partialLine = ""; + + var results = this._handle.parse(aggregate, this._baseIndex, !this._finished); + + if (this._handle.paused() || this._handle.aborted()) + return; + + var lastIndex = results.meta.cursor; + + if (!this._finished) + { + this._partialLine = aggregate.substring(lastIndex - this._baseIndex); + this._baseIndex = lastIndex; + } + + if (results && results.data) + this._rowCount += results.data.length; + + var finishedIncludingPreview = this._finished || (this._config.preview && this._rowCount >= this._config.preview); + + if (IS_PAPA_WORKER) + { + global.postMessage({ + results: results, + workerId: Papa.WORKER_ID, + finished: finishedIncludingPreview + }); + } + else if (isFunction(this._config.chunk)) + { + this._config.chunk(results, this._handle); + if (this._paused) + return; + results = undefined; + this._completeResults = undefined; + } + + if (!this._config.step && !this._config.chunk) { + this._completeResults.data = this._completeResults.data.concat(results.data); + this._completeResults.errors = this._completeResults.errors.concat(results.errors); + this._completeResults.meta = results.meta; + } + + if (finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted)) + this._config.complete(this._completeResults); + + if (!finishedIncludingPreview && (!results || !results.meta.paused)) + this._nextChunk(); + + return results; + }; + + this._sendError = function(error) + { + if (isFunction(this._config.error)) + this._config.error(error); + else if (IS_PAPA_WORKER && this._config.error) + { + global.postMessage({ + workerId: Papa.WORKER_ID, + error: error, + finished: false + }); + } + }; + + function replaceConfig(config) + { + // Deep-copy the config so we can edit it + var configCopy = copy(config); + configCopy.chunkSize = parseInt(configCopy.chunkSize); // parseInt VERY important so we don't concatenate strings! + if (!config.step && !config.chunk) + configCopy.chunkSize = null; // disable Range header if not streaming; bad values break IIS - see issue #196 + this._handle = new ParserHandle(configCopy); + this._handle.streamer = this; + this._config = configCopy; // persist the copy to the caller + } + } + + + function NetworkStreamer(config) + { + config = config || {}; + if (!config.chunkSize) + config.chunkSize = Papa.RemoteChunkSize; + ChunkStreamer.call(this, config); + + var xhr; + + if (IS_WORKER) + { + this._nextChunk = function() + { + this._readChunk(); + this._chunkLoaded(); + }; + } + else + { + this._nextChunk = function() + { + this._readChunk(); + }; + } + + this.stream = function(url) + { + this._input = url; + this._nextChunk(); // Starts streaming + }; + + this._readChunk = function() + { + if (this._finished) + { + this._chunkLoaded(); + return; + } + + xhr = new XMLHttpRequest(); + + if (!IS_WORKER) + { + xhr.onload = bindFunction(this._chunkLoaded, this); + xhr.onerror = bindFunction(this._chunkError, this); + } + + xhr.open("GET", this._input, !IS_WORKER); + + if (this._config.chunkSize) + { + var end = this._start + this._config.chunkSize - 1; // minus one because byte range is inclusive + xhr.setRequestHeader("Range", "bytes="+this._start+"-"+end); + xhr.setRequestHeader("If-None-Match", "webkit-no-cache"); // https://bugs.webkit.org/show_bug.cgi?id=82672 + } + + try { + xhr.send(); + } + catch (err) { + this._chunkError(err.message); + } + + if (IS_WORKER && xhr.status == 0) + this._chunkError(); + else + this._start += this._config.chunkSize; + } + + this._chunkLoaded = function() + { + if (xhr.readyState != 4) + return; + + if (xhr.status < 200 || xhr.status >= 400) + { + this._chunkError(); + return; + } + + this._finished = !this._config.chunkSize || this._start > getFileSize(xhr); + this.parseChunk(xhr.responseText); + } + + this._chunkError = function(errorMessage) + { + var errorText = xhr.statusText || errorMessage; + this._sendError(errorText); + } + + function getFileSize(xhr) + { + var contentRange = xhr.getResponseHeader("Content-Range"); + return parseInt(contentRange.substr(contentRange.lastIndexOf("/") + 1)); + } + } + NetworkStreamer.prototype = Object.create(ChunkStreamer.prototype); + NetworkStreamer.prototype.constructor = NetworkStreamer; + + + function FileStreamer(config) + { + config = config || {}; + if (!config.chunkSize) + config.chunkSize = Papa.LocalChunkSize; + ChunkStreamer.call(this, config); + + var reader, slice; + + // FileReader is better than FileReaderSync (even in worker) - see http://stackoverflow.com/q/24708649/1048862 + // But Firefox is a pill, too - see issue #76: https://github.com/mholt/PapaParse/issues/76 + var usingAsyncReader = typeof FileReader !== 'undefined'; // Safari doesn't consider it a function - see issue #105 + + this.stream = function(file) + { + this._input = file; + slice = file.slice || file.webkitSlice || file.mozSlice; + + if (usingAsyncReader) + { + reader = new FileReader(); // Preferred method of reading files, even in workers + reader.onload = bindFunction(this._chunkLoaded, this); + reader.onerror = bindFunction(this._chunkError, this); + } + else + reader = new FileReaderSync(); // Hack for running in a web worker in Firefox + + this._nextChunk(); // Starts streaming + }; + + this._nextChunk = function() + { + if (!this._finished && (!this._config.preview || this._rowCount < this._config.preview)) + this._readChunk(); + } + + this._readChunk = function() + { + var input = this._input; + if (this._config.chunkSize) + { + var end = Math.min(this._start + this._config.chunkSize, this._input.size); + input = slice.call(input, this._start, end); + } + var txt = reader.readAsText(input, this._config.encoding); + if (!usingAsyncReader) + this._chunkLoaded({ target: { result: txt } }); // mimic the async signature + } + + this._chunkLoaded = function(event) + { + // Very important to increment start each time before handling results + this._start += this._config.chunkSize; + this._finished = !this._config.chunkSize || this._start >= this._input.size; + this.parseChunk(event.target.result); + } + + this._chunkError = function() + { + this._sendError(reader.error); + } + + } + FileStreamer.prototype = Object.create(ChunkStreamer.prototype); + FileStreamer.prototype.constructor = FileStreamer; + + + function StringStreamer(config) + { + config = config || {}; + ChunkStreamer.call(this, config); + + var string; + var remaining; + this.stream = function(s) + { + string = s; + remaining = s; + return this._nextChunk(); + } + this._nextChunk = function() + { + if (this._finished) return; + var size = this._config.chunkSize; + var chunk = size ? remaining.substr(0, size) : remaining; + remaining = size ? remaining.substr(size) : ''; + this._finished = !remaining; + return this.parseChunk(chunk); + } + } + StringStreamer.prototype = Object.create(StringStreamer.prototype); + StringStreamer.prototype.constructor = StringStreamer; + + + + // Use one ParserHandle per entire CSV file or string + function ParserHandle(_config) + { + // One goal is to minimize the use of regular expressions... + var FLOAT = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i; + + var self = this; + var _stepCounter = 0; // Number of times step was called (number of rows parsed) + var _input; // The input being parsed + var _parser; // The core parser being used + var _paused = false; // Whether we are paused or not + var _aborted = false; // Whether the parser has aborted or not + var _delimiterError; // Temporary state between delimiter detection and processing results + var _fields = []; // Fields are from the header row of the input, if there is one + var _results = { // The last results returned from the parser + data: [], + errors: [], + meta: {} + }; + + if (isFunction(_config.step)) + { + var userStep = _config.step; + _config.step = function(results) + { + _results = results; + + if (needsHeaderRow()) + processResults(); + else // only call user's step function after header row + { + processResults(); + + // It's possbile that this line was empty and there's no row here after all + if (_results.data.length == 0) + return; + + _stepCounter += results.data.length; + if (_config.preview && _stepCounter > _config.preview) + _parser.abort(); + else + userStep(_results, self); + } + }; + } + + /** + * Parses input. Most users won't need, and shouldn't mess with, the baseIndex + * and ignoreLastRow parameters. They are used by streamers (wrapper functions) + * when an input comes in multiple chunks, like from a file. + */ + this.parse = function(input, baseIndex, ignoreLastRow) + { + if (!_config.newline) + _config.newline = guessLineEndings(input); + + _delimiterError = false; + if (!_config.delimiter) + { + var delimGuess = guessDelimiter(input); + if (delimGuess.successful) + _config.delimiter = delimGuess.bestDelimiter; + else + { + _delimiterError = true; // add error after parsing (otherwise it would be overwritten) + _config.delimiter = Papa.DefaultDelimiter; + } + _results.meta.delimiter = _config.delimiter; + } + + var parserConfig = copy(_config); + if (_config.preview && _config.header) + parserConfig.preview++; // to compensate for header row + + _input = input; + _parser = new Parser(parserConfig); + _results = _parser.parse(_input, baseIndex, ignoreLastRow); + processResults(); + return _paused ? { meta: { paused: true } } : (_results || { meta: { paused: false } }); + }; + + this.paused = function() + { + return _paused; + }; + + this.pause = function() + { + _paused = true; + _parser.abort(); + _input = _input.substr(_parser.getCharIndex()); + }; + + this.resume = function() + { + _paused = false; + self.streamer.parseChunk(_input); + }; + + this.aborted = function () { + return _aborted; + } + + this.abort = function() + { + _aborted = true; + _parser.abort(); + _results.meta.aborted = true; + if (isFunction(_config.complete)) + _config.complete(_results); + _input = ""; + }; + + function processResults() + { + if (_results && _delimiterError) + { + addError("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '"+Papa.DefaultDelimiter+"'"); + _delimiterError = false; + } + + if (_config.skipEmptyLines) + { + for (var i = 0; i < _results.data.length; i++) + if (_results.data[i].length == 1 && _results.data[i][0] == "") + _results.data.splice(i--, 1); + } + + if (needsHeaderRow()) + fillHeaderFields(); + + return applyHeaderAndDynamicTyping(); + } + + function needsHeaderRow() + { + return _config.header && _fields.length == 0; + } + + function fillHeaderFields() + { + if (!_results) + return; + for (var i = 0; needsHeaderRow() && i < _results.data.length; i++) + for (var j = 0; j < _results.data[i].length; j++) + _fields.push(_results.data[i][j]); + _results.data.splice(0, 1); + } + + function applyHeaderAndDynamicTyping() + { + if (!_results || (!_config.header && !_config.dynamicTyping)) + return _results; + + for (var i = 0; i < _results.data.length; i++) + { + var row = {}; + + for (var j = 0; j < _results.data[i].length; j++) + { + if (_config.dynamicTyping) + { + var value = _results.data[i][j]; + if (value == "true" || value == "TRUE") + _results.data[i][j] = true; + else if (value == "false" || value == "FALSE") + _results.data[i][j] = false; + else + _results.data[i][j] = tryParseFloat(value); + } + + if (_config.header) + { + if (j >= _fields.length) + { + if (!row["__parsed_extra"]) + row["__parsed_extra"] = []; + row["__parsed_extra"].push(_results.data[i][j]); + } + else + row[_fields[j]] = _results.data[i][j]; + } + } + + if (_config.header) + { + _results.data[i] = row; + if (j > _fields.length) + addError("FieldMismatch", "TooManyFields", "Too many fields: expected " + _fields.length + " fields but parsed " + j, i); + else if (j < _fields.length) + addError("FieldMismatch", "TooFewFields", "Too few fields: expected " + _fields.length + " fields but parsed " + j, i); + } + } + + if (_config.header && _results.meta) + _results.meta.fields = _fields; + return _results; + } + + function guessDelimiter(input) + { + var delimChoices = [",", "\t", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP]; + var bestDelim, bestDelta, fieldCountPrevRow; + + for (var i = 0; i < delimChoices.length; i++) + { + var delim = delimChoices[i]; + var delta = 0, avgFieldCount = 0; + fieldCountPrevRow = undefined; + + var preview = new Parser({ + delimiter: delim, + preview: 10 + }).parse(input); + + for (var j = 0; j < preview.data.length; j++) + { + var fieldCount = preview.data[j].length; + avgFieldCount += fieldCount; + + if (typeof fieldCountPrevRow === 'undefined') + { + fieldCountPrevRow = fieldCount; + continue; + } + else if (fieldCount > 1) + { + delta += Math.abs(fieldCount - fieldCountPrevRow); + fieldCountPrevRow = fieldCount; + } + } + + if (preview.data.length > 0) + avgFieldCount /= preview.data.length; + + if ((typeof bestDelta === 'undefined' || delta < bestDelta) + && avgFieldCount > 1.99) + { + bestDelta = delta; + bestDelim = delim; + } + } + + _config.delimiter = bestDelim; + + return { + successful: !!bestDelim, + bestDelimiter: bestDelim + } + } + + function guessLineEndings(input) + { + input = input.substr(0, 1024*1024); // max length 1 MB + + var r = input.split('\r'); + + if (r.length == 1) + return '\n'; + + var numWithN = 0; + for (var i = 0; i < r.length; i++) + { + if (r[i][0] == '\n') + numWithN++; + } + + return numWithN >= r.length / 2 ? '\r\n' : '\r'; + } + + function tryParseFloat(val) + { + var isNumber = FLOAT.test(val); + return isNumber ? parseFloat(val) : val; + } + + function addError(type, code, msg, row) + { + _results.errors.push({ + type: type, + code: code, + message: msg, + row: row + }); + } + } + + + + + + /** The core parser implements speedy and correct CSV parsing */ + function Parser(config) + { + // Unpack the config object + config = config || {}; + var delim = config.delimiter; + var newline = config.newline; + var comments = config.comments; + var step = config.step; + var preview = config.preview; + var fastMode = config.fastMode; + + // Delimiter must be valid + if (typeof delim !== 'string' + || Papa.BAD_DELIMITERS.indexOf(delim) > -1) + delim = ","; + + // Comment character must be valid + if (comments === delim) + throw "Comment character same as delimiter"; + else if (comments === true) + comments = "#"; + else if (typeof comments !== 'string' + || Papa.BAD_DELIMITERS.indexOf(comments) > -1) + comments = false; + + // Newline must be valid: \r, \n, or \r\n + if (newline != '\n' && newline != '\r' && newline != '\r\n') + newline = '\n'; + + // We're gonna need these at the Parser scope + var cursor = 0; + var aborted = false; + + this.parse = function(input, baseIndex, ignoreLastRow) + { + // For some reason, in Chrome, this speeds things up (!?) + if (typeof input !== 'string') + throw "Input must be a string"; + + // We don't need to compute some of these every time parse() is called, + // but having them in a more local scope seems to perform better + var inputLen = input.length, + delimLen = delim.length, + newlineLen = newline.length, + commentsLen = comments.length; + var stepIsFunction = typeof step === 'function'; + + // Establish starting state + cursor = 0; + var data = [], errors = [], row = [], lastCursor = 0; + + if (!input) + return returnable(); + + if (fastMode || (fastMode !== false && input.indexOf('"') === -1)) + { + var rows = input.split(newline); + for (var i = 0; i < rows.length; i++) + { + var row = rows[i]; + cursor += row.length; + if (i !== rows.length - 1) + cursor += newline.length; + else if (ignoreLastRow) + return returnable(); + if (comments && row.substr(0, commentsLen) == comments) + continue; + if (stepIsFunction) + { + data = []; + pushRow(row.split(delim)); + doStep(); + if (aborted) + return returnable(); + } + else + pushRow(row.split(delim)); + if (preview && i >= preview) + { + data = data.slice(0, preview); + return returnable(true); + } + } + return returnable(); + } + + var nextDelim = input.indexOf(delim, cursor); + var nextNewline = input.indexOf(newline, cursor); + + // Parser loop + for (;;) + { + // Field has opening quote + if (input[cursor] == '"') + { + // Start our search for the closing quote where the cursor is + var quoteSearch = cursor; + + // Skip the opening quote + cursor++; + + for (;;) + { + // Find closing quote + var quoteSearch = input.indexOf('"', quoteSearch+1); + + if (quoteSearch === -1) + { + if (!ignoreLastRow) { + // No closing quote... what a pity + errors.push({ + type: "Quotes", + code: "MissingQuotes", + message: "Quoted field unterminated", + row: data.length, // row has yet to be inserted + index: cursor + }); + } + return finish(); + } + + if (quoteSearch === inputLen-1) + { + // Closing quote at EOF + var value = input.substring(cursor, quoteSearch).replace(/""/g, '"'); + return finish(value); + } + + // If this quote is escaped, it's part of the data; skip it + if (input[quoteSearch+1] == '"') + { + quoteSearch++; + continue; + } + + if (input[quoteSearch+1] == delim) + { + // Closing quote followed by delimiter + row.push(input.substring(cursor, quoteSearch).replace(/""/g, '"')); + cursor = quoteSearch + 1 + delimLen; + nextDelim = input.indexOf(delim, cursor); + nextNewline = input.indexOf(newline, cursor); + break; + } + + if (input.substr(quoteSearch+1, newlineLen) === newline) + { + // Closing quote followed by newline + row.push(input.substring(cursor, quoteSearch).replace(/""/g, '"')); + saveRow(quoteSearch + 1 + newlineLen); + nextDelim = input.indexOf(delim, cursor); // because we may have skipped the nextDelim in the quoted field + + if (stepIsFunction) + { + doStep(); + if (aborted) + return returnable(); + } + + if (preview && data.length >= preview) + return returnable(true); + + break; + } + } + + continue; + } + + // Comment found at start of new line + if (comments && row.length === 0 && input.substr(cursor, commentsLen) === comments) + { + if (nextNewline == -1) // Comment ends at EOF + return returnable(); + cursor = nextNewline + newlineLen; + nextNewline = input.indexOf(newline, cursor); + nextDelim = input.indexOf(delim, cursor); + continue; + } + + // Next delimiter comes before next newline, so we've reached end of field + if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1)) + { + row.push(input.substring(cursor, nextDelim)); + cursor = nextDelim + delimLen; + nextDelim = input.indexOf(delim, cursor); + continue; + } + + // End of row + if (nextNewline !== -1) + { + row.push(input.substring(cursor, nextNewline)); + saveRow(nextNewline + newlineLen); + + if (stepIsFunction) + { + doStep(); + if (aborted) + return returnable(); + } + + if (preview && data.length >= preview) + return returnable(true); + + continue; + } + + break; + } + + + return finish(); + + + function pushRow(row) + { + data.push(row); + lastCursor = cursor; + } + + /** + * Appends the remaining input from cursor to the end into + * row, saves the row, calls step, and returns the results. + */ + function finish(value) + { + if (ignoreLastRow) + return returnable(); + if (typeof value === 'undefined') + value = input.substr(cursor); + row.push(value); + cursor = inputLen; // important in case parsing is paused + pushRow(row); + if (stepIsFunction) + doStep(); + return returnable(); + } + + /** + * Appends the current row to the results. It sets the cursor + * to newCursor and finds the nextNewline. The caller should + * take care to execute user's step function and check for + * preview and end parsing if necessary. + */ + function saveRow(newCursor) + { + cursor = newCursor; + pushRow(row); + row = []; + nextNewline = input.indexOf(newline, cursor); + } + + /** Returns an object with the results, errors, and meta. */ + function returnable(stopped) + { + return { + data: data, + errors: errors, + meta: { + delimiter: delim, + linebreak: newline, + aborted: aborted, + truncated: !!stopped, + cursor: lastCursor + (baseIndex || 0) + } + }; + } + + /** Executes the user's step function and resets data & errors. */ + function doStep() + { + step(returnable()); + data = [], errors = []; + } + }; + + /** Sets the abort flag */ + this.abort = function() + { + aborted = true; + }; + + /** Gets the cursor position */ + this.getCharIndex = function() + { + return cursor; + }; + } + + + // If you need to load Papa Parse asynchronously and you also need worker threads, hard-code + // the script path here. See: https://github.com/mholt/PapaParse/issues/87#issuecomment-57885358 + function getScriptPath() + { + var scripts = document.getElementsByTagName('script'); + return scripts.length ? scripts[scripts.length - 1].src : ''; + } + + function newWorker() + { + if (!Papa.WORKERS_SUPPORTED) + return false; + if (!LOADED_SYNC && Papa.SCRIPT_PATH === null) + throw new Error( + 'Script path cannot be determined automatically when Papa Parse is loaded asynchronously. ' + + 'You need to set Papa.SCRIPT_PATH manually.' + ); + var workerUrl = Papa.SCRIPT_PATH || AUTO_SCRIPT_PATH; + // Append "papaworker" to the search string to tell papaparse that this is our worker. + workerUrl += (workerUrl.indexOf('?') !== -1 ? '&' : '?') + 'papaworker'; + var w = new global.Worker(workerUrl); + w.onmessage = mainThreadReceivedMessage; + w.id = workerIdCounter++; + workers[w.id] = w; + return w; + } + + /** Callback when main thread receives a message */ + function mainThreadReceivedMessage(e) + { + var msg = e.data; + var worker = workers[msg.workerId]; + var aborted = false; + + if (msg.error) + worker.userError(msg.error, msg.file); + else if (msg.results && msg.results.data) + { + var abort = function() { + aborted = true; + completeWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } }); + }; + + var handle = { + abort: abort, + pause: notImplemented, + resume: notImplemented + }; + + if (isFunction(worker.userStep)) + { + for (var i = 0; i < msg.results.data.length; i++) + { + worker.userStep({ + data: [msg.results.data[i]], + errors: msg.results.errors, + meta: msg.results.meta + }, handle); + if (aborted) + break; + } + delete msg.results; // free memory ASAP + } + else if (isFunction(worker.userChunk)) + { + worker.userChunk(msg.results, handle, msg.file); + delete msg.results; + } + } + + if (msg.finished && !aborted) + completeWorker(msg.workerId, msg.results); + } + + function completeWorker(workerId, results) { + var worker = workers[workerId]; + if (isFunction(worker.userComplete)) + worker.userComplete(results); + worker.terminate(); + delete workers[workerId]; + } + + function notImplemented() { + throw "Not implemented."; + } + + /** Callback when worker thread receives a message */ + function workerThreadReceivedMessage(e) + { + var msg = e.data; + + if (typeof Papa.WORKER_ID === 'undefined' && msg) + Papa.WORKER_ID = msg.workerId; + + if (typeof msg.input === 'string') + { + global.postMessage({ + workerId: Papa.WORKER_ID, + results: Papa.parse(msg.input, msg.config), + finished: true + }); + } + else if ((global.File && msg.input instanceof File) || msg.input instanceof Object) // thank you, Safari (see issue #106) + { + var results = Papa.parse(msg.input, msg.config); + if (results) + global.postMessage({ + workerId: Papa.WORKER_ID, + results: results, + finished: true + }); + } + } + + /** Makes a deep copy of an array or object (mostly) */ + function copy(obj) + { + if (typeof obj !== 'object') + return obj; + var cpy = obj instanceof Array ? [] : {}; + for (var key in obj) + cpy[key] = copy(obj[key]); + return cpy; + } + + function bindFunction(f, self) + { + return function() { f.apply(self, arguments); }; + } + + function isFunction(func) + { + return typeof func === 'function'; + } +})(typeof window !== 'undefined' ? window : this); \ No newline at end of file
