Bug 1268974 - make css-parsing-utils eslint-clean; r=pbro
authorTom Tromey <tom@tromey.com>
Fri, 29 Apr 2016 14:13:14 -0600
changeset 335055 26fca47bf8dbfe7988468eef2dcf77cd4590690c
parent 335054 bf7a7e5b7a7d45f8b6b5d135d9f8453a6b60d7d7
child 335056 0f32a1437164606d15c1c26f3d870b011531453d
push id6249
push userjlund@mozilla.com
push dateMon, 01 Aug 2016 13:59:36 +0000
treeherdermozilla-beta@bad9d4f5bf7e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerspbro
bugs1268974
milestone49.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1268974 - make css-parsing-utils eslint-clean; r=pbro MozReview-Commit-ID: 4iPN37XMbIy
.eslintignore
devtools/client/shared/css-parsing-utils.js
--- a/.eslintignore
+++ b/.eslintignore
@@ -94,19 +94,26 @@ devtools/client/memory/**
 devtools/client/netmonitor/test/**
 devtools/client/netmonitor/har/test/**
 devtools/client/performance/**
 devtools/client/projecteditor/**
 devtools/client/promisedebugger/**
 devtools/client/responsivedesign/**
 devtools/client/scratchpad/**
 devtools/client/shadereditor/**
-devtools/client/shared/**
+devtools/client/shared/*.js
+devtools/client/shared/*.jsm
 !devtools/client/shared/css-color.js
 !devtools/client/shared/css-color-db.js
+!devtools/client/shared/css-parsing-utils.js
+devtools/client/shared/components/**
+devtools/client/shared/redux/**
+devtools/client/shared/test/**
+devtools/client/shared/vendor/**
+devtools/client/shared/widgets/**
 devtools/client/sourceeditor/**
 devtools/client/webaudioeditor/**
 devtools/client/webconsole/**
 !devtools/client/webconsole/panel.js
 !devtools/client/webconsole/jsterm.js
 devtools/client/webide/**
 devtools/server/**
 !devtools/server/actors/webbrowser.js
--- a/devtools/client/shared/css-parsing-utils.js
+++ b/devtools/client/shared/css-parsing-utils.js
@@ -509,17 +509,17 @@ function RuleRewriter(rule, inputString)
 
 RuleRewriter.prototype = {
   /**
    * An internal function to complete initialization and set some
    * properties for further processing.
    *
    * @param {Number} index The index of the property to modify
    */
-  completeInitialization: function(index) {
+  completeInitialization: function (index) {
     if (index < 0) {
       throw new Error("Invalid index " + index + ". Expected positive integer");
     }
     // |decl| is the declaration to be rewritten, or null if there is no
     // declaration corresponding to |index|.
     // |result| is used to accumulate the result text.
     if (index < this.declarations.length) {
       this.decl = this.declarations[index];
@@ -535,17 +535,17 @@ RuleRewriter.prototype = {
    * examines the rule's existing text to guess the indentation to use;
    * unlike |getDefaultIndentation|, which examines the entire style
    * sheet.
    *
    * @param {String} string the input text
    * @param {Number} offset the offset at which to compute the indentation
    * @return {String} the indentation at the indicated position
    */
-  getIndentation: function(string, offset) {
+  getIndentation: function (string, offset) {
     let originalOffset = offset;
     for (--offset; offset >= 0; --offset) {
       let c = string[offset];
       if (c === "\r" || c === "\n" || c === "\f") {
         return string.substring(offset + 1, originalOffset);
       }
       if (c !== " " && c !== "\t") {
         // Found some non-whitespace character before we found a newline
@@ -568,17 +568,17 @@ RuleRewriter.prototype = {
    *
    * @param {String} text The input text.  This should include the trailing ";".
    * @return {Array} An array of the form [anySanitized, text], where
    *                 |anySanitized| is a boolean that indicates
    *                  whether anything substantive has changed; and
    *                  where |text| is the text that has been rewritten
    *                  to be "lexically safe".
    */
-  sanitizePropertyValue: function(text) {
+  sanitizePropertyValue: function (text) {
     let lexer = DOMUtils.getCSSLexer(text);
 
     let result = "";
     let previousOffset = 0;
     let braceDepth = 0;
     let anySanitized = false;
     while (true) {
       let token = lexer.nextToken();
@@ -631,33 +631,33 @@ RuleRewriter.prototype = {
    * Start at |index| and skip whitespace
    * backward in |string|.  Return the index of the first
    * non-whitespace character, or -1 if the entire string was
    * whitespace.
    * @param {String} string the input string
    * @param {Number} index the index at which to start
    * @return {Number} index of the first non-whitespace character, or -1
    */
-  skipWhitespaceBackward: function(string, index) {
+  skipWhitespaceBackward: function (string, index) {
     for (--index;
          index >= 0 && (string[index] === " " || string[index] === "\t");
          --index) {
       // Nothing.
     }
     return index;
   },
 
   /**
    * Terminate a given declaration, if needed.
    *
    * @param {Number} index The index of the rule to possibly
    *                       terminate.  It might be invalid, so this
    *                       function must check for that.
    */
-  maybeTerminateDecl: function(index) {
+  maybeTerminateDecl: function (index) {
     if (index < 0 || index >= this.declarations.length
         // No need to rewrite declarations in comments.
         || ("commentOffsets" in this.declarations[index])) {
       return;
     }
 
     let termDecl = this.declarations[index];
     let endIndex = termDecl.offsets[1];
@@ -695,48 +695,48 @@ RuleRewriter.prototype = {
    * Sanitize the given property value and return the sanitized form.
    * If the property is rewritten during sanitization, make a note in
    * |changedDeclarations|.
    *
    * @param {String} text The property text.
    * @param {Number} index The index of the property.
    * @return {String} The sanitized text.
    */
-  sanitizeText: function(text, index) {
+  sanitizeText: function (text, index) {
     let [anySanitized, sanitizedText] = this.sanitizePropertyValue(text);
     if (anySanitized) {
       this.changedDeclarations[index] = sanitizedText;
     }
     return sanitizedText;
   },
 
   /**
    * Rename a declaration.
    *
    * @param {Number} index index of the property in the rule.
    * @param {String} name current name of the property
    * @param {String} newName new name of the property
    */
-  renameProperty: function(index, name, newName) {
+  renameProperty: function (index, name, newName) {
     this.completeInitialization(index);
     this.result += CSS.escape(newName);
     // We could conceivably compute the name offsets instead so we
     // could preserve white space and comments on the LHS of the ":".
     this.completeCopying(this.decl.colonOffsets[0]);
   },
 
   /**
    * Enable or disable a declaration
    *
    * @param {Number} index index of the property in the rule.
    * @param {String} name current name of the property
    * @param {Boolean} isEnabled true if the property should be enabled;
    *                        false if it should be disabled
    */
-  setPropertyEnabled: function(index, name, isEnabled) {
+  setPropertyEnabled: function (index, name, isEnabled) {
     this.completeInitialization(index);
     const decl = this.decl;
     let copyOffset = decl.offsets[1];
     if (isEnabled) {
       // Enable it.  First see if the comment start can be deleted.
       let commentStart = decl.commentOffsets[0];
       if (EMPTY_COMMENT_START_RX.test(this.result.substring(commentStart))) {
         this.result = this.result.substring(0, commentStart);
@@ -780,33 +780,33 @@ RuleRewriter.prototype = {
   /**
    * Return a promise that will be resolved to the default indentation
    * of the rule.  This is a helper for internalCreateProperty.
    *
    * @return {Promise} a promise that will be resolved to a string
    *         that holds the default indentation that should be used
    *         for edits to the rule.
    */
-  getDefaultIndentation: function() {
+  getDefaultIndentation: function () {
     return this.rule.parentStyleSheet.guessIndentation();
   },
 
   /**
    * An internal function to create a new declaration.  This does all
    * the work of |createProperty|.
    *
    * @param {Number} index index of the property in the rule.
    * @param {String} name name of the new property
    * @param {String} value value of the new property
    * @param {String} priority priority of the new property; either
    *                          the empty string or "important"
    * @return {Promise} a promise that is resolved when the edit has
    *                   completed
    */
-  internalCreateProperty: Task.async(function*(index, name, value, priority) {
+  internalCreateProperty: Task.async(function* (index, name, value, priority) {
     this.completeInitialization(index);
     let newIndentation = "";
     if (this.hasNewLine) {
       if (this.declarations.length > 0) {
         newIndentation = this.getIndentation(this.inputString,
                                              this.declarations[0].offsets[0]);
       } else if (this.defaultIndentation) {
         newIndentation = this.defaultIndentation;
@@ -854,17 +854,17 @@ RuleRewriter.prototype = {
    * Create a new declaration.
    *
    * @param {Number} index index of the property in the rule.
    * @param {String} name name of the new property
    * @param {String} value value of the new property
    * @param {String} priority priority of the new property; either
    *                          the empty string or "important"
    */
-  createProperty: function(index, name, value, priority) {
+  createProperty: function (index, name, value, priority) {
     this.editPromise = this.internalCreateProperty(index, name, value,
                                                    priority);
   },
 
   /**
    * Set a declaration's value.
    *
    * @param {Number} index index of the property in the rule.
@@ -872,22 +872,23 @@ RuleRewriter.prototype = {
    *                       the rule does not support setRuleText;
    *                       generally for setting properties
    *                       on an element's style.
    * @param {String} name the property's name
    * @param {String} value the property's value
    * @param {String} priority the property's priority, either the empty
    *                          string or "important"
    */
-  setProperty: function(index, name, value, priority) {
+  setProperty: function (index, name, value, priority) {
     this.completeInitialization(index);
     // We might see a "set" on a previously non-existent property; in
     // that case, act like "create".
     if (!this.decl) {
-      return this.createProperty(index, name, value, priority);
+      this.createProperty(index, name, value, priority);
+      return;
     }
 
     // Note that this assumes that "set" never operates on disabled
     // properties.
     this.result += this.inputString.substring(this.decl.offsets[0],
                                               this.decl.colonOffsets[1]) +
       this.sanitizeText(value, index);
 
@@ -899,17 +900,17 @@ RuleRewriter.prototype = {
   },
 
   /**
    * Remove a declaration.
    *
    * @param {Number} index index of the property in the rule.
    * @param {String} name the name of the property to remove
    */
-  removeProperty: function(index, name) {
+  removeProperty: function (index, name) {
     this.completeInitialization(index);
     let copyOffset = this.decl.offsets[1];
     // Maybe removing this rule left us with a completely blank
     // line.  In this case, we'll delete the whole thing.  We only
     // bother with this if we're looking at sources that already
     // have a newline somewhere.
     if (this.hasNewLine) {
       let nlOffset = this.skipWhitespaceBackward(this.result,
@@ -929,44 +930,44 @@ RuleRewriter.prototype = {
 
   /**
    * An internal function to copy any trailing text to the output
    * string.
    *
    * @param {Number} copyOffset Offset into |inputString| of the
    *        final text to copy to the output string.
    */
-  completeCopying: function(copyOffset) {
+  completeCopying: function (copyOffset) {
     // Add the trailing text.
     this.result += this.inputString.substring(copyOffset);
   },
 
   /**
    * Apply the modifications in this object to the associated rule.
    *
    * @return {Promise} A promise which will be resolved when the modifications
    *         are complete.
    */
-  apply: function() {
+  apply: function () {
     return promise.resolve(this.editPromise).then(() => {
       return this.rule.setRuleText(this.result);
     });
   },
 
   /**
    * Get the result of the rewriting.  This is used for testing.
    *
    * @return {object} an object of the form {changed: object, text: string}
    *                  |changed| is an object where each key is
    *                  the index of a property whose value had to be
    *                  rewritten during the sanitization process, and
    *                  whose value is the new text of the property.
    *                  |text| is the rewritten text of the rule.
    */
-  getResult: function() {
+  getResult: function () {
     return {changed: this.changedDeclarations, text: this.result};
   },
 };
 
 /**
  * Returns an array of the parsed CSS selector value and type given a string.
  *
  * The components making up the CSS selector can be extracted into 3 different