scratch – Diff between revs 75 and 125

Subversion Repositories:

?pathlinks?

Rev 75 – Details – Blame – Last modification – View Log

 })();
 module.exports = Dumper;
-},{"./Inline":5,"./Utils":9}],2:[function(require,module,exports){
+},{"./Inline":6,"./Utils":10}],2:[function(require,module,exports){
 })();
 module.exports = Escaper;
-},{"./Pattern":7}],3:[function(require,module,exports){
+},{"./Pattern":8}],3:[function(require,module,exports){
 var DumpException,
 module.exports = ParseException;
+},{}],5:[function(require,module,exports){
+var ParseMore,
+  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+  hasProp = {}.hasOwnProperty;
+ParseMore = (function(superClass) {
+  extend(ParseMore, superClass);
+  function ParseMore(message, parsedLine, snippet) {
+    this.message = message;
+    this.parsedLine = parsedLine;
+    this.snippet = snippet;
+  }
+  ParseMore.prototype.toString = function() {
+    if ((this.parsedLine != null) && (this.snippet != null)) {
+      return '<ParseMore> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
+    } else {
+      return '<ParseMore> ' + this.message;
+    }
+  };
+  return ParseMore;
+})(Error);
+module.exports = ParseMore;
-},{}],5:[function(require,module,exports){
+},{}],6:[function(require,module,exports){
-var DumpException, Escaper, Inline, ParseException, Pattern, Unescaper, Utils,
+var DumpException, Escaper, Inline, ParseException, ParseMore, Pattern, Unescaper, Utils,
 Utils = require('./Utils');
+ParseException = require('./Exception/ParseException');
-ParseException = require('./Exception/ParseException');
+ParseMore = require('./Exception/ParseMore');
   Inline.parseQuotedScalar = function(scalar, context) {
     var i, match, output;
     i = context.i;
     if (!(match = this.PATTERN_QUOTED_SCALAR.exec(scalar.slice(i)))) {
-      throw new ParseException('Malformed inline YAML string (' + scalar.slice(i) + ').');
+      throw new ParseMore('Malformed inline YAML string (' + scalar.slice(i) + ').');
+    }
     output = match[0].substr(1, match[0].length - 2);
     if ('"' === scalar.charAt(i)) {
       output = Unescaper.unescapeDoubleQuotedString(output);
           output.push(value);
           --i;
+      }
       ++i;
+    }
-    throw new ParseException('Malformed inline YAML string ' + sequence);
+    throw new ParseMore('Malformed inline YAML string ' + sequence);
   };
   Inline.parseMapping = function(mapping, context) {
     var done, i, key, len, output, shouldContinueWhileLoop, value;
         if (done) {
           break;
+        }
+      }
+    }
-    throw new ParseException('Malformed inline YAML string ' + mapping);
+    throw new ParseMore('Malformed inline YAML string ' + mapping);
   };
   Inline.evaluateScalar = function(scalar, context) {
     var cast, date, exceptionOnInvalidType, firstChar, firstSpace, firstWord, objectDecoder, raw, scalarLower, subValue, trimmedScalar;
 })();
 module.exports = Inline;
-},{"./Escaper":2,"./Exception/DumpException":3,"./Exception/ParseException":4,"./Pattern":7,"./Unescaper":8,"./Utils":9}],6:[function(require,module,exports){
+},{"./Escaper":2,"./Exception/DumpException":3,"./Exception/ParseException":4,"./Exception/ParseMore":5,"./Pattern":8,"./Unescaper":9,"./Utils":10}],7:[function(require,module,exports){
-var Inline, ParseException, Parser, Pattern, Utils;
+var Inline, ParseException, ParseMore, Parser, Pattern, Utils;
+Inline = require('./Inline');
-Inline = require('./Inline');
+Pattern = require('./Pattern');
-Pattern = require('./Pattern');
+Utils = require('./Utils');
   Parser.prototype.PATTERN_INDENT_SPACES = new Pattern('^ +');
   Parser.prototype.PATTERN_TRAILING_LINES = new Pattern('(\n*)$');
-  Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n');
+  Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n', 'm');
-  Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+');
+  Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+', 'm');
     while (this.moveToNextLine()) {
       indent = this.getCurrentLineIndentation();
       if (indent === newIndent) {
         removeComments = !removeCommentsPattern.test(this.currentLine);
+      }
-      if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent === newIndent) {
-        this.moveToPreviousLine();
+      if (removeComments && this.isCurrentLineComment()) {
-        break;
+        continue;
+      }
       if (this.isCurrentLineBlank()) {
         data.push(this.currentLine.slice(newIndent));
         continue;
+      }
-      if (removeComments && this.isCurrentLineComment()) {
+      if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent === newIndent) {
-        if (indent === newIndent) {
+        this.moveToPreviousLine();
-          continue;
-        }
+        break;
+      }
       if (indent >= newIndent) {
         data.push(this.currentLine.slice(newIndent));
       } else if (Utils.ltrim(this.currentLine).charAt(0) === '#') {
   Parser.prototype.moveToPreviousLine = function() {
     this.currentLine = this.lines[--this.currentLineNb];
   };
   Parser.prototype.parseValue = function(value, exceptionOnInvalidType, objectDecoder) {
-    var e, error, error1, foldedIndent, matches, modifiers, pos, ref, ref1, val;
+    var e, error, foldedIndent, matches, modifiers, pos, ref, ref1, val;
     if (0 === value.indexOf('*')) {
       pos = value.indexOf('#');
       if (pos !== -1) {
         value = value.substr(1, pos - 2);
         return Inline.parseScalar(matches.type + ' ' + val);
       } else {
         return val;
+      }
+    }
-    try {
-      return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
+    if ((ref1 = value.charAt(0)) === '[' || ref1 === '{' || ref1 === '"' || ref1 === "'") {
-    } catch (error) {
+      while (true) {
-      e = error;
-      if (((ref1 = value.charAt(0)) === '[' || ref1 === '{') && e instanceof ParseException && this.isNextLineIndented()) {
-        value += "\n" + this.getNextEmbedBlock();
         try {
           return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
-        } catch (error1) {
+        } catch (error) {
-          e = error1;
+          e = error;
+          if (e instanceof ParseMore && this.moveToNextLine()) {
+            value += "\n" + Utils.trim(this.currentLine, ' ');
+          } else {
-          e.parsedLine = this.getRealCurrentLineNb() + 1;
+            e.parsedLine = this.getRealCurrentLineNb() + 1;
-          e.snippet = this.currentLine;
+            e.snippet = this.currentLine;
-          throw e;
+            throw e;
+          }
+        }
-      } else {
-        e.parsedLine = this.getRealCurrentLineNb() + 1;
-        e.snippet = this.currentLine;
-        throw e;
+      }
+    } else {
+      if (this.isNextLineIndented()) {
+        value += "\n" + this.getNextEmbedBlock();
+      }
+      return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
+    }
   };
   Parser.prototype.parseFoldedScalar = function(separator, indicator, indentation) {
 })();
 module.exports = Parser;
-},{"./Exception/ParseException":4,"./Inline":5,"./Pattern":7,"./Utils":9}],7:[function(require,module,exports){
+},{"./Exception/ParseException":4,"./Exception/ParseMore":5,"./Inline":6,"./Pattern":8,"./Utils":10}],8:[function(require,module,exports){
+    }
     this.regex.lastIndex = 0;
     count = 0;
     while (this.regex.test(str) && (limit === 0 || count < limit)) {
       this.regex.lastIndex = 0;
-      str = str.replace(this.regex, '');
+      str = str.replace(this.regex, replacement);
       count++;
+    }
     return [str, count];
   };
 })();
 module.exports = Pattern;
-},{}],8:[function(require,module,exports){
+},{}],9:[function(require,module,exports){
 })();
 module.exports = Unescaper;
 },{"./Pattern":8,"./Utils":10}],10:[function(require,module,exports){
-},{"./Pattern":7,"./Utils":9}],9:[function(require,module,exports){
+var Pattern, Utils,
-var Pattern, Utils;
+  hasProp = {}.hasOwnProperty;
   Utils.trim = function(str, _char) {
     var regexLeft, regexRight;
     if (_char == null) {
       _char = '\\s';
+    }
-    return str.trim();
     regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
     if (regexLeft == null) {
       this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
+    }
     regexLeft.lastIndex = 0;
     regexRight.lastIndex = 0;
     return str.replace(regexRight, '');
   };
   Utils.isEmpty = function(value) {
+    return !value || value === '' || value === '0' || (value instanceof Array && value.length === 0) || this.isEmptyObject(value);
+  };
+  Utils.isEmptyObject = function(value) {
+    var k;
+    return value instanceof Object && ((function() {
+      var results;
+      results = [];
+      for (k in value) {
+        if (!hasProp.call(value, k)) continue;
+        results.push(k);
+      }
+      return results;
-    return !value || value === '' || value === '0' || (value instanceof Array && value.length === 0);
+    })()).length === 0;
   };
   Utils.subStrCount = function(string, subString, start, length) {
         tz_offset *= -1;
+      }
+    }
     date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
     if (tz_offset) {
-      date.setTime(date.getTime() + tz_offset);
+      date.setTime(date.getTime() - tz_offset);
+    }
     return date;
   };
 })();
 module.exports = Utils;
-},{"./Pattern":7}],10:[function(require,module,exports){
+},{"./Pattern":8}],11:[function(require,module,exports){
     yaml = new Dumper();
     yaml.indentation = indent;
     return yaml.dump(input, inline, 0, exceptionOnInvalidType, objectEncoder);
   };
-  Yaml.register = function() {
-    var require_handler;
-    require_handler = function(module, filename) {
-      return module.exports = YAML.parseFile(filename);
-    };
-    if ((typeof require !== "undefined" && require !== null ? require.extensions : void 0) != null) {
-      require.extensions['.yml'] = require_handler;
-      return require.extensions['.yaml'] = require_handler;
-    }
-  };
   Yaml.stringify = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
     return this.dump(input, inline, indent, exceptionOnInvalidType, objectEncoder);
   };
+}
 module.exports = Yaml;