GeoNode/geonode-viewer

View on GitHub

Showing 95 of 95 total issues

File geonode.jsx has 264 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import React from 'react';
global.React = React;
import ReactDOM from 'react-dom';
global.ReactDOM = ReactDOM;
import 'core-js/fn/object/assign';
Severity: Minor
Found in src/components/geonode.jsx - About 2 hrs to fix

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    const server = (state = defaultState, action) => {
      switch(action.type) {
        case GET_SERVER_URL:
          return state.url;
        case SET_SERVER_URL:
    Severity: Major
    Found in src/state/server/reducers.js and 1 other location - About 1 hr to fix
    src/state/ol/reducers.js on lines 7..18

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 70.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    const olMap = (state = defaultState, action) => {
      switch(action.type) {
        case GET_OL_MAP:
          return state.olMap;
        case SET_OL_MAP:
    Severity: Major
    Found in src/state/ol/reducers.js and 1 other location - About 1 hr to fix
    src/state/server/reducers.js on lines 7..18

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 70.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Function updateMap has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

      updateMap(props) {
        if (props.config) {
          var tileServices = [];
          var errors = [];
          var filteredErrors = [];
    Severity: Minor
    Found in src/components/geonode.jsx - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function render has 39 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      render() {
        const {formatMessage} = this.props.intl;
        const actions = [
          <FlatButton className='save-btn' primary={true} label={formatMessage(messages.savemapbutton)} onTouchTap={this._handleSave.bind(this)} />,
          <FlatButton className='close-btn' label={formatMessage(messages.closebutton)} onTouchTap={this._handleClose.bind(this)} />
    Severity: Minor
    Found in src/components/saveView.jsx - About 1 hr to fix

      Function render has 35 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        render() {
          var error;
          if (this.state.errors.length > 0) {
            var msg = '';
            for (var i = 0, ii = this.state.errors.length; i < ii; i++) {
      Severity: Minor
      Found in src/components/geonode.jsx - About 1 hr to fix

        Function selectorFactory has 33 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        function selectorFactory(dispatch) {
          let result = {};
          const resetMapId = () => {
            dispatch(setMapId(undefined));
          }
        Severity: Minor
        Found in src/components/saveContainer.jsx - About 1 hr to fix

          Function map has 29 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          const map = (state = defaultState, action) => {
            switch(action.type) {
              case GET_MAP_ID:
                return state.id;
              case SET_MAP_ID:
          Severity: Minor
          Found in src/state/map/reducers.js - About 1 hr to fix

            Function createThumbnail has 28 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            export const createThumbnail = (obj_id, map) => {
              map.once('postcompose', function(evt) {
                var canvas = evt.context.canvas;
                canvas.toBlob(function(blob) {
                  var url = window.location.pathname.replace('/view', '');
            Severity: Minor
            Found in src/services/geonode.js - About 1 hr to fix

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                _handleSave() {
                  this.props.save(this.refs.maptitle.getValue(), this.refs.mapabstract.getValue());
                }
              Severity: Minor
              Found in src/components/saveView.jsx and 1 other location - About 55 mins to fix
              src/components/saveView.jsx on lines 100..102

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 54.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                _handleNewSave() {
                  this.props.saveAsNew(this.refs.maptitle.getValue(), this.refs.mapabstract.getValue());
                }
              Severity: Minor
              Found in src/components/saveView.jsx and 1 other location - About 55 mins to fix
              src/components/saveView.jsx on lines 97..99

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 54.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Function render has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
              Open

                render() {
                  var error;
                  if (this.state.errors.length > 0) {
                    var msg = '';
                    for (var i = 0, ii = this.state.errors.length; i < ii; i++) {
              Severity: Minor
              Found in src/components/geonode.jsx - About 35 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                    <FlatButton className='close-btn' label={formatMessage(messages.closebutton)} onTouchTap={this._handleClose.bind(this)} />
              Severity: Minor
              Found in src/components/saveView.jsx and 1 other location - About 35 mins to fix
              src/components/saveView.jsx on lines 110..110

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 46.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                    actions.unshift(<FlatButton className='save-btn' label={formatMessage(messages.savenewmapbutton)} onTouchTap={this._handleNewSave.bind(this)} />)
              Severity: Minor
              Found in src/components/saveView.jsx and 1 other location - About 35 mins to fix
              src/components/saveView.jsx on lines 107..107

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 46.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Expected indentation of 0 spaces but found 4.
              Open

                  ],
              Severity: Minor
              Found in webpack.config.js by eslint

              enforce consistent indentation (indent)

              There are several common guidelines which require specific indentation of nested blocks and statements, like:

              function hello(indentSize, type) {
                  if (indentSize === 4 && type !== 'tab') {
                      console.log('Each next indentation will increase on 4 spaces');
                  }
              }

              These are the most common scenarios recommended in different style guides:

              • Two spaces, not longer and no tabs: Google, npm, Node.js, Idiomatic, Felix
              • Tabs: jQuery
              • Four spaces: Crockford

              Rule Details

              This rule enforces a consistent indentation style. The default style is 4 spaces.

              Options

              This rule has a mixed option:

              For example, for 2-space indentation:

              {
                  "indent": ["error", 2]
              }

              Or for tabbed indentation:

              {
                  "indent": ["error", "tab"]
              }

              Examples of incorrect code for this rule with the default options:

              /*eslint indent: "error"*/
              
              if (a) {
                b=c;
                function foo(d) {
                  e=f;
                }
              }

              Examples of correct code for this rule with the default options:

              /*eslint indent: "error"*/
              
              if (a) {
                  b=c;
                  function foo(d) {
                      e=f;
                  }
              }

              This rule has an object option:

              • "SwitchCase" (default: 0) enforces indentation level for case clauses in switch statements
              • "VariableDeclarator" (default: 1) enforces indentation level for var declarators; can also take an object to define separate rules for var, let and const declarations.
              • "outerIIFEBody" (default: 1) enforces indentation level for file-level IIFEs.
              • "MemberExpression" (off by default) enforces indentation level for multi-line property chains (except in variable declarations and assignments)
              • "FunctionDeclaration" takes an object to define rules for function declarations.
                • parameters (off by default) enforces indentation level for parameters in a function declaration. This can either be a number indicating indentation level, or the string "first" indicating that all parameters of the declaration must be aligned with the first parameter.
                • body (default: 1) enforces indentation level for the body of a function declaration.
              • "FunctionExpression" takes an object to define rules for function expressions.
                • parameters (off by default) enforces indentation level for parameters in a function expression. This can either be a number indicating indentation level, or the string "first" indicating that all parameters of the expression must be aligned with the first parameter.
                • body (default: 1) enforces indentation level for the body of a function expression.
              • "CallExpression" takes an object to define rules for function call expressions.
                • arguments (off by default) enforces indentation level for arguments in a call expression. This can either be a number indicating indentation level, or the string "first" indicating that all arguments of the expression must be aligned with the first argument.
              • "ArrayExpression" (default: 1) enforces indentation level for elements in arrays. It can also be set to the string "first", indicating that all the elements in the array should be aligned with the first element.
              • "ObjectExpression" (default: 1) enforces indentation level for properties in objects. It can be set to the string "first", indicating that all properties in the object should be aligned with the first property.

              Level of indentation denotes the multiple of the indent specified. Example:

              • Indent of 4 spaces with VariableDeclarator set to 2 will indent the multi-line variable declarations with 8 spaces.
              • Indent of 2 spaces with VariableDeclarator set to 2 will indent the multi-line variable declarations with 4 spaces.
              • Indent of 2 spaces with VariableDeclarator set to {"var": 2, "let": 2, "const": 3} will indent the multi-line variable declarations with 4 spaces for var and let, 6 spaces for const statements.
              • Indent of tab with VariableDeclarator set to 2 will indent the multi-line variable declarations with 2 tabs.
              • Indent of 2 spaces with SwitchCase set to 0 will not indent case clauses with respect to switch statements.
              • Indent of 2 spaces with SwitchCase set to 1 will indent case clauses with 2 spaces with respect to switch statements.
              • Indent of 2 spaces with SwitchCase set to 2 will indent case clauses with 4 spaces with respect to switch statements.
              • Indent of tab with SwitchCase set to 2 will indent case clauses with 2 tabs with respect to switch statements.
              • Indent of 2 spaces with MemberExpression set to 0 will indent the multi-line property chains with 0 spaces.
              • Indent of 2 spaces with MemberExpression set to 1 will indent the multi-line property chains with 2 spaces.
              • Indent of 2 spaces with MemberExpression set to 2 will indent the multi-line property chains with 4 spaces.
              • Indent of 4 spaces with MemberExpression set to 0 will indent the multi-line property chains with 0 spaces.
              • Indent of 4 spaces with MemberExpression set to 1 will indent the multi-line property chains with 4 spaces.
              • Indent of 4 spaces with MemberExpression set to 2 will indent the multi-line property chains with 8 spaces.

              tab

              Examples of incorrect code for this rule with the "tab" option:

              /*eslint indent: ["error", "tab"]*/
              
              if (a) {
                   b=c;
              function foo(d) {
                         e=f;
               }
              }

              Examples of correct code for this rule with the "tab" option:

              /*eslint indent: ["error", "tab"]*/
              
              if (a) {
              /*tab*/b=c;
              /*tab*/function foo(d) {
              /*tab*//*tab*/e=f;
              /*tab*/}
              }

              SwitchCase

              Examples of incorrect code for this rule with the 2, { "SwitchCase": 1 } options:

              /*eslint indent: ["error", 2, { "SwitchCase": 1 }]*/
              
              switch(a){
              case "a":
                  break;
              case "b":
                  break;
              }

              Examples of correct code for this rule with the 2, { "SwitchCase": 1 } option:

              /*eslint indent: ["error", 2, { "SwitchCase": 1 }]*/
              
              switch(a){
                case "a":
                  break;
                case "b":
                  break;
              }

              VariableDeclarator

              Examples of incorrect code for this rule with the 2, { "VariableDeclarator": 1 } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": 1 }]*/
              /*eslint-env es6*/
              
              var a,
                  b,
                  c;
              let a,
                  b,
                  c;
              const a = 1,
                  b = 2,
                  c = 3;

              Examples of correct code for this rule with the 2, { "VariableDeclarator": 1 } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": 1 }]*/
              /*eslint-env es6*/
              
              var a,
                b,
                c;
              let a,
                b,
                c;
              const a = 1,
                b = 2,
                c = 3;

              Examples of correct code for this rule with the 2, { "VariableDeclarator": 2 } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": 2 }]*/
              /*eslint-env es6*/
              
              var a,
                  b,
                  c;
              let a,
                  b,
                  c;
              const a = 1,
                  b = 2,
                  c = 3;

              Examples of correct code for this rule with the 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }]*/
              /*eslint-env es6*/
              
              var a,
                  b,
                  c;
              let a,
                  b,
                  c;
              const a = 1,
                    b = 2,
                    c = 3;

              outerIIFEBody

              Examples of incorrect code for this rule with the options 2, { "outerIIFEBody": 0 }:

              /*eslint indent: ["error", 2, { "outerIIFEBody": 0 }]*/
              
              (function() {
              
                function foo(x) {
                  return x + 1;
                }
              
              })();
              
              
              if(y) {
              console.log('foo');
              }

              Examples of correct code for this rule with the options 2, {"outerIIFEBody": 0}:

              /*eslint indent: ["error", 2, { "outerIIFEBody": 0 }]*/
              
              (function() {
              
              function foo(x) {
                return x + 1;
              }
              
              })();
              
              
              if(y) {
                 console.log('foo');
              }

              MemberExpression

              Examples of incorrect code for this rule with the 2, { "MemberExpression": 1 } options:

              /*eslint indent: ["error", 2, { "MemberExpression": 1 }]*/
              
              foo
              .bar
              .baz()

              Examples of correct code for this rule with the 2, { "MemberExpression": 1 } option:

              /*eslint indent: ["error", 2, { "MemberExpression": 1 }]*/
              
              foo
                .bar
                .baz();
              
              // Any indentation is permitted in variable declarations and assignments.
              var bip = aardvark.badger
                                .coyote;

              FunctionDeclaration

              Examples of incorrect code for this rule with the 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/
              
              function foo(bar,
                baz,
                qux) {
                  qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/
              
              function foo(bar,
                  baz,
                  qux) {
                qux();
              }

              Examples of incorrect code for this rule with the 2, { "FunctionDeclaration": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/
              
              function foo(bar, baz,
                qux, boop) {
                qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionDeclaration": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/
              
              function foo(bar, baz,
                           qux, boop) {
                qux();
              }

              FunctionExpression

              Examples of incorrect code for this rule with the 2, { "FunctionExpression": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/
              
              var foo = function(bar,
                baz,
                qux) {
                  qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionExpression": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/
              
              var foo = function(bar,
                  baz,
                  qux) {
                qux();
              }

              Examples of incorrect code for this rule with the 2, { "FunctionExpression": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/
              
              var foo = function(bar, baz,
                qux, boop) {
                qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionExpression": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/
              
              var foo = function(bar, baz,
                                 qux, boop) {
                qux();
              }

              CallExpression

              Examples of incorrect code for this rule with the 2, { "CallExpression": {"arguments": 1} } option:

              /*eslint indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/
              
              foo(bar,
                  baz,
                    qux
              );

              Examples of correct code for this rule with the 2, { "CallExpression": {"arguments": 1} } option:

              /*eslint indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/
              
              foo(bar,
                baz,
                qux
              );

              Examples of incorrect code for this rule with the 2, { "CallExpression": {"arguments": "first"} } option:

              /*eslint indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/
              
              foo(bar, baz,
                baz, boop, beep);

              Examples of correct code for this rule with the 2, { "CallExpression": {"arguments": "first"} } option:

              /*eslint indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/
              
              foo(bar, baz,
                  baz, boop, beep);

              ArrayExpression

              Examples of incorrect code for this rule with the 2, { "ArrayExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ArrayExpression": 1 }]*/
              
              var foo = [
                  bar,
              baz,
                    qux
              ];

              Examples of correct code for this rule with the 2, { "ArrayExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ArrayExpression": 1 }]*/
              
              var foo = [
                bar,
                baz,
                qux
              ];

              Examples of incorrect code for this rule with the 2, { "ArrayExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ArrayExpression": "first"}]*/
              
              var foo = [bar,
                baz,
                qux
              ];

              Examples of correct code for this rule with the 2, { "ArrayExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ArrayExpression": "first"}]*/
              
              var foo = [bar,
                         baz,
                         qux
              ];

              ObjectExpression

              Examples of incorrect code for this rule with the 2, { "ObjectExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ObjectExpression": 1 }]*/
              
              var foo = {
                  bar: 1,
              baz: 2,
                    qux: 3
              };

              Examples of correct code for this rule with the 2, { "ObjectExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ObjectExpression": 1 }]*/
              
              var foo = {
                bar: 1,
                baz: 2,
                qux: 3
              };

              Examples of incorrect code for this rule with the 2, { "ObjectExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ObjectExpression": "first"}]*/
              
              var foo = { bar: 1,
                baz: 2 };

              Examples of correct code for this rule with the 2, { "ObjectExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ObjectExpression": "first"}]*/
              
              var foo = { bar: 1,
                          baz: 2 };

              Compatibility

              Values of 0 shouldn't have units specified.
              Open

                top: 0px;
              Severity: Minor
              Found in src/css/app.css by csslint

              There should be no space after '{'.
              Open

                plugins.push(new webpack.optimize.UglifyJsPlugin({ compress:{ warnings: true } }));
              Severity: Minor
              Found in webpack.config.js by eslint

              enforce consistent spacing inside braces (object-curly-spacing)

              While formatting preferences are very personal, a number of style guides require or disallow spaces between curly braces in the following situations:

              // simple object literals
              var obj = { foo: "bar" };
              
              // nested object literals
              var obj = { foo: { zoo: "bar" } };
              
              // destructuring assignment (EcmaScript 6)
              var { x, y } = y;
              
              // import/export declarations (EcmaScript 6)
              import { foo } from "bar";
              export { foo };

              Rule Details

              This rule enforce consistent spacing inside braces of object literals, destructuring assignments, and import/export specifiers.

              Options

              This rule has two options, a string option and an object option.

              String option:

              • "never" (default) disallows spacing inside of braces
              • "always" requires spacing inside of braces (except {})

              Object option:

              • "arraysInObjects": true requires spacing inside of braces of objects beginning and/or ending with an array element (applies when the first option is set to never)
              • "arraysInObjects": false disallows spacing inside of braces of objects beginning and/or ending with an array element (applies when the first option is set to always)
              • "objectsInObjects": true requires spacing inside of braces of objects beginning and/or ending with an object element (applies when the first option is set to never)
              • "objectsInObjects": false disallows spacing inside of braces of objects beginning and/or ending with an object element (applies when the first option is set to always)

              never

              Examples of incorrect code for this rule with the default "never" option:

              /*eslint object-curly-spacing: ["error", "never"]*/
              
              var obj = { 'foo': 'bar' };
              var obj = {'foo': 'bar' };
              var obj = { baz: {'foo': 'qux'}, bar};
              var obj = {baz: { 'foo': 'qux'}, bar};
              var {x } = y;
              import { foo } from 'bar';

              Examples of correct code for this rule with the default "never" option:

              /*eslint object-curly-spacing: ["error", "never"]*/
              
              var obj = {'foo': 'bar'};
              var obj = {'foo': {'bar': 'baz'}, 'qux': 'quxx'};
              var obj = {
                'foo': 'bar'
              };
              var obj = {'foo': 'bar'
              };
              var obj = {
                'foo':'bar'};
              var obj = {};
              var {x} = y;
              import {foo} from 'bar';

              always

              Examples of incorrect code for this rule with the "always" option:

              /*eslint object-curly-spacing: ["error", "always"]*/
              
              var obj = {'foo': 'bar'};
              var obj = {'foo': 'bar' };
              var obj = { baz: {'foo': 'qux'}, bar};
              var obj = {baz: { 'foo': 'qux' }, bar};
              var obj = {'foo': 'bar'
              };
              var obj = {
                'foo':'bar'};
              var {x} = y;
              import {foo } from 'bar';

              Examples of correct code for this rule with the "always" option:

              /*eslint object-curly-spacing: ["error", "always"]*/
              
              var obj = {};
              var obj = { 'foo': 'bar' };
              var obj = { 'foo': { 'bar': 'baz' }, 'qux': 'quxx' };
              var obj = {
                'foo': 'bar'
              };
              var { x } = y;
              import { foo } from 'bar';

              arraysInObjects

              Examples of additional correct code for this rule with the "never", { "arraysInObjects": true } options:

              /*eslint object-curly-spacing: ["error", "never", { "arraysInObjects": true }]*/
              
              var obj = {"foo": [ 1, 2 ] };
              var obj = {"foo": [ "baz", "bar" ] };

              Examples of additional correct code for this rule with the "always", { "arraysInObjects": false } options:

              /*eslint object-curly-spacing: ["error", "always", { "arraysInObjects": false }]*/
              
              var obj = { "foo": [ 1, 2 ]};
              var obj = { "foo": [ "baz", "bar" ]};

              objectsInObjects

              Examples of additional correct code for this rule with the "never", { "objectsInObjects": true } options:

              /*eslint object-curly-spacing: ["error", "never", { "objectsInObjects": true }]*/
              
              var obj = {"foo": {"baz": 1, "bar": 2} };

              Examples of additional correct code for this rule with the "always", { "objectsInObjects": false } options:

              /*eslint object-curly-spacing: ["error", "always", { "objectsInObjects": false }]*/
              
              var obj = { "foo": { "baz": 1, "bar": 2 }};

              When Not To Use It

              You can turn this rule off if you are not concerned with the consistency of spacing between curly braces.

              Related Rules

              Expected indentation of 0 spaces but found 2.
              Open

                },
              Severity: Minor
              Found in webpack.config.js by eslint

              enforce consistent indentation (indent)

              There are several common guidelines which require specific indentation of nested blocks and statements, like:

              function hello(indentSize, type) {
                  if (indentSize === 4 && type !== 'tab') {
                      console.log('Each next indentation will increase on 4 spaces');
                  }
              }

              These are the most common scenarios recommended in different style guides:

              • Two spaces, not longer and no tabs: Google, npm, Node.js, Idiomatic, Felix
              • Tabs: jQuery
              • Four spaces: Crockford

              Rule Details

              This rule enforces a consistent indentation style. The default style is 4 spaces.

              Options

              This rule has a mixed option:

              For example, for 2-space indentation:

              {
                  "indent": ["error", 2]
              }

              Or for tabbed indentation:

              {
                  "indent": ["error", "tab"]
              }

              Examples of incorrect code for this rule with the default options:

              /*eslint indent: "error"*/
              
              if (a) {
                b=c;
                function foo(d) {
                  e=f;
                }
              }

              Examples of correct code for this rule with the default options:

              /*eslint indent: "error"*/
              
              if (a) {
                  b=c;
                  function foo(d) {
                      e=f;
                  }
              }

              This rule has an object option:

              • "SwitchCase" (default: 0) enforces indentation level for case clauses in switch statements
              • "VariableDeclarator" (default: 1) enforces indentation level for var declarators; can also take an object to define separate rules for var, let and const declarations.
              • "outerIIFEBody" (default: 1) enforces indentation level for file-level IIFEs.
              • "MemberExpression" (off by default) enforces indentation level for multi-line property chains (except in variable declarations and assignments)
              • "FunctionDeclaration" takes an object to define rules for function declarations.
                • parameters (off by default) enforces indentation level for parameters in a function declaration. This can either be a number indicating indentation level, or the string "first" indicating that all parameters of the declaration must be aligned with the first parameter.
                • body (default: 1) enforces indentation level for the body of a function declaration.
              • "FunctionExpression" takes an object to define rules for function expressions.
                • parameters (off by default) enforces indentation level for parameters in a function expression. This can either be a number indicating indentation level, or the string "first" indicating that all parameters of the expression must be aligned with the first parameter.
                • body (default: 1) enforces indentation level for the body of a function expression.
              • "CallExpression" takes an object to define rules for function call expressions.
                • arguments (off by default) enforces indentation level for arguments in a call expression. This can either be a number indicating indentation level, or the string "first" indicating that all arguments of the expression must be aligned with the first argument.
              • "ArrayExpression" (default: 1) enforces indentation level for elements in arrays. It can also be set to the string "first", indicating that all the elements in the array should be aligned with the first element.
              • "ObjectExpression" (default: 1) enforces indentation level for properties in objects. It can be set to the string "first", indicating that all properties in the object should be aligned with the first property.

              Level of indentation denotes the multiple of the indent specified. Example:

              • Indent of 4 spaces with VariableDeclarator set to 2 will indent the multi-line variable declarations with 8 spaces.
              • Indent of 2 spaces with VariableDeclarator set to 2 will indent the multi-line variable declarations with 4 spaces.
              • Indent of 2 spaces with VariableDeclarator set to {"var": 2, "let": 2, "const": 3} will indent the multi-line variable declarations with 4 spaces for var and let, 6 spaces for const statements.
              • Indent of tab with VariableDeclarator set to 2 will indent the multi-line variable declarations with 2 tabs.
              • Indent of 2 spaces with SwitchCase set to 0 will not indent case clauses with respect to switch statements.
              • Indent of 2 spaces with SwitchCase set to 1 will indent case clauses with 2 spaces with respect to switch statements.
              • Indent of 2 spaces with SwitchCase set to 2 will indent case clauses with 4 spaces with respect to switch statements.
              • Indent of tab with SwitchCase set to 2 will indent case clauses with 2 tabs with respect to switch statements.
              • Indent of 2 spaces with MemberExpression set to 0 will indent the multi-line property chains with 0 spaces.
              • Indent of 2 spaces with MemberExpression set to 1 will indent the multi-line property chains with 2 spaces.
              • Indent of 2 spaces with MemberExpression set to 2 will indent the multi-line property chains with 4 spaces.
              • Indent of 4 spaces with MemberExpression set to 0 will indent the multi-line property chains with 0 spaces.
              • Indent of 4 spaces with MemberExpression set to 1 will indent the multi-line property chains with 4 spaces.
              • Indent of 4 spaces with MemberExpression set to 2 will indent the multi-line property chains with 8 spaces.

              tab

              Examples of incorrect code for this rule with the "tab" option:

              /*eslint indent: ["error", "tab"]*/
              
              if (a) {
                   b=c;
              function foo(d) {
                         e=f;
               }
              }

              Examples of correct code for this rule with the "tab" option:

              /*eslint indent: ["error", "tab"]*/
              
              if (a) {
              /*tab*/b=c;
              /*tab*/function foo(d) {
              /*tab*//*tab*/e=f;
              /*tab*/}
              }

              SwitchCase

              Examples of incorrect code for this rule with the 2, { "SwitchCase": 1 } options:

              /*eslint indent: ["error", 2, { "SwitchCase": 1 }]*/
              
              switch(a){
              case "a":
                  break;
              case "b":
                  break;
              }

              Examples of correct code for this rule with the 2, { "SwitchCase": 1 } option:

              /*eslint indent: ["error", 2, { "SwitchCase": 1 }]*/
              
              switch(a){
                case "a":
                  break;
                case "b":
                  break;
              }

              VariableDeclarator

              Examples of incorrect code for this rule with the 2, { "VariableDeclarator": 1 } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": 1 }]*/
              /*eslint-env es6*/
              
              var a,
                  b,
                  c;
              let a,
                  b,
                  c;
              const a = 1,
                  b = 2,
                  c = 3;

              Examples of correct code for this rule with the 2, { "VariableDeclarator": 1 } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": 1 }]*/
              /*eslint-env es6*/
              
              var a,
                b,
                c;
              let a,
                b,
                c;
              const a = 1,
                b = 2,
                c = 3;

              Examples of correct code for this rule with the 2, { "VariableDeclarator": 2 } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": 2 }]*/
              /*eslint-env es6*/
              
              var a,
                  b,
                  c;
              let a,
                  b,
                  c;
              const a = 1,
                  b = 2,
                  c = 3;

              Examples of correct code for this rule with the 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } } options:

              /*eslint indent: ["error", 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }]*/
              /*eslint-env es6*/
              
              var a,
                  b,
                  c;
              let a,
                  b,
                  c;
              const a = 1,
                    b = 2,
                    c = 3;

              outerIIFEBody

              Examples of incorrect code for this rule with the options 2, { "outerIIFEBody": 0 }:

              /*eslint indent: ["error", 2, { "outerIIFEBody": 0 }]*/
              
              (function() {
              
                function foo(x) {
                  return x + 1;
                }
              
              })();
              
              
              if(y) {
              console.log('foo');
              }

              Examples of correct code for this rule with the options 2, {"outerIIFEBody": 0}:

              /*eslint indent: ["error", 2, { "outerIIFEBody": 0 }]*/
              
              (function() {
              
              function foo(x) {
                return x + 1;
              }
              
              })();
              
              
              if(y) {
                 console.log('foo');
              }

              MemberExpression

              Examples of incorrect code for this rule with the 2, { "MemberExpression": 1 } options:

              /*eslint indent: ["error", 2, { "MemberExpression": 1 }]*/
              
              foo
              .bar
              .baz()

              Examples of correct code for this rule with the 2, { "MemberExpression": 1 } option:

              /*eslint indent: ["error", 2, { "MemberExpression": 1 }]*/
              
              foo
                .bar
                .baz();
              
              // Any indentation is permitted in variable declarations and assignments.
              var bip = aardvark.badger
                                .coyote;

              FunctionDeclaration

              Examples of incorrect code for this rule with the 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/
              
              function foo(bar,
                baz,
                qux) {
                  qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/
              
              function foo(bar,
                  baz,
                  qux) {
                qux();
              }

              Examples of incorrect code for this rule with the 2, { "FunctionDeclaration": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/
              
              function foo(bar, baz,
                qux, boop) {
                qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionDeclaration": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/
              
              function foo(bar, baz,
                           qux, boop) {
                qux();
              }

              FunctionExpression

              Examples of incorrect code for this rule with the 2, { "FunctionExpression": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/
              
              var foo = function(bar,
                baz,
                qux) {
                  qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionExpression": {"body": 1, "parameters": 2} } option:

              /*eslint indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/
              
              var foo = function(bar,
                  baz,
                  qux) {
                qux();
              }

              Examples of incorrect code for this rule with the 2, { "FunctionExpression": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/
              
              var foo = function(bar, baz,
                qux, boop) {
                qux();
              }

              Examples of correct code for this rule with the 2, { "FunctionExpression": {"parameters": "first"} } option:

              /*eslint indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/
              
              var foo = function(bar, baz,
                                 qux, boop) {
                qux();
              }

              CallExpression

              Examples of incorrect code for this rule with the 2, { "CallExpression": {"arguments": 1} } option:

              /*eslint indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/
              
              foo(bar,
                  baz,
                    qux
              );

              Examples of correct code for this rule with the 2, { "CallExpression": {"arguments": 1} } option:

              /*eslint indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/
              
              foo(bar,
                baz,
                qux
              );

              Examples of incorrect code for this rule with the 2, { "CallExpression": {"arguments": "first"} } option:

              /*eslint indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/
              
              foo(bar, baz,
                baz, boop, beep);

              Examples of correct code for this rule with the 2, { "CallExpression": {"arguments": "first"} } option:

              /*eslint indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/
              
              foo(bar, baz,
                  baz, boop, beep);

              ArrayExpression

              Examples of incorrect code for this rule with the 2, { "ArrayExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ArrayExpression": 1 }]*/
              
              var foo = [
                  bar,
              baz,
                    qux
              ];

              Examples of correct code for this rule with the 2, { "ArrayExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ArrayExpression": 1 }]*/
              
              var foo = [
                bar,
                baz,
                qux
              ];

              Examples of incorrect code for this rule with the 2, { "ArrayExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ArrayExpression": "first"}]*/
              
              var foo = [bar,
                baz,
                qux
              ];

              Examples of correct code for this rule with the 2, { "ArrayExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ArrayExpression": "first"}]*/
              
              var foo = [bar,
                         baz,
                         qux
              ];

              ObjectExpression

              Examples of incorrect code for this rule with the 2, { "ObjectExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ObjectExpression": 1 }]*/
              
              var foo = {
                  bar: 1,
              baz: 2,
                    qux: 3
              };

              Examples of correct code for this rule with the 2, { "ObjectExpression": 1 } option:

              /*eslint indent: ["error", 2, { "ObjectExpression": 1 }]*/
              
              var foo = {
                bar: 1,
                baz: 2,
                qux: 3
              };

              Examples of incorrect code for this rule with the 2, { "ObjectExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ObjectExpression": "first"}]*/
              
              var foo = { bar: 1,
                baz: 2 };

              Examples of correct code for this rule with the 2, { "ObjectExpression": "first" } option:

              /*eslint indent: ["error", 2, {"ObjectExpression": "first"}]*/
              
              var foo = { bar: 1,
                          baz: 2 };

              Compatibility

              There should be no space after '['.
              Open

                    'tests/tests.bundle.js': [ 'webpack', 'sourcemap' ]
              Severity: Minor
              Found in karma.conf.js by eslint

              Disallow or enforce spaces inside of brackets (array-bracket-spacing)

              A number of style guides require or disallow spaces between array brackets and other tokens. This rule applies to both array literals and destructuring assignments (ECMAScript 6).

              /*eslint-env es6*/
              
              var arr = [ 'foo', 'bar' ];
              var [ x, y ] = z;
              
              var arr = ['foo', 'bar'];
              var [x,y] = z;

              Rule Details

              This rule enforces consistent spacing inside array brackets.

              Options

              This rule has a string option:

              • "never" (default) disallows spaces inside array brackets
              • "always" requires one or more spaces or newlines inside array brackets

              This rule has an object option for exceptions to the "never" option:

              • "singleValue": true requires one or more spaces or newlines inside brackets of array literals that contain a single element
              • "objectsInArrays": true requires one or more spaces or newlines between brackets of array literals and braces of their object literal elements [ { or } ]
              • "arraysInArrays": true requires one or more spaces or newlines between brackets of array literals and brackets of their array literal elements [ [ or ] ]

              This rule has an object option for exceptions to the "always" option:

              • "singleValue": false disallows spaces inside brackets of array literals that contain a single element
              • "objectsInArrays": false disallows spaces between brackets of array literals and braces of their object literal elements [{ or }]
              • "arraysInArrays": false disallows spaces between brackets of array literals and brackets of their array literal elements [[ or ]]

              This rule has built-in exceptions:

              • "never" (and also the exceptions to the "always" option) allows newlines inside array brackets, because this is a common pattern
              • "always" does not require spaces or newlines in empty array literals []

              never

              Examples of incorrect code for this rule with the default "never" option:

              /*eslint array-bracket-spacing: ["error", "never"]*/
              /*eslint-env es6*/
              
              var arr = [ 'foo', 'bar' ];
              var arr = ['foo', 'bar' ];
              var arr = [ ['foo'], 'bar'];
              var arr = [[ 'foo' ], 'bar'];
              var arr = [ 'foo',
                'bar'
              ];
              var [ x, y ] = z;
              var [ x,y ] = z;
              var [ x, ...y ] = z;
              var [ ,,x, ] = z;

              Examples of correct code for this rule with the default "never" option:

              /*eslint array-bracket-spacing: ["error", "never"]*/
              /*eslint-env es6*/
              
              var arr = [];
              var arr = ['foo', 'bar', 'baz'];
              var arr = [['foo'], 'bar', 'baz'];
              var arr = [
                'foo',
                'bar',
                'baz'
              ];
              var arr = ['foo',
                'bar'
              ];
              var arr = [
                'foo',
                'bar'];
              
              var [x, y] = z;
              var [x,y] = z;
              var [x, ...y] = z;
              var [,,x,] = z;

              always

              Examples of incorrect code for this rule with the "always" option:

              /*eslint array-bracket-spacing: ["error", "always"]*/
              /*eslint-env es6*/
              
              var arr = ['foo', 'bar'];
              var arr = ['foo', 'bar' ];
              var arr = [ ['foo'], 'bar' ];
              var arr = ['foo',
                'bar'
              ];
              var arr = [
                'foo',
                'bar'];
              
              var [x, y] = z;
              var [x,y] = z;
              var [x, ...y] = z;
              var [,,x,] = z;

              Examples of correct code for this rule with the "always" option:

              /*eslint array-bracket-spacing: ["error", "always"]*/
              /*eslint-env es6*/
              
              var arr = [];
              var arr = [ 'foo', 'bar', 'baz' ];
              var arr = [ [ 'foo' ], 'bar', 'baz' ];
              var arr = [ 'foo',
                'bar'
              ];
              var arr = [
                'foo',
                'bar' ];
              var arr = [
                'foo',
                'bar',
                'baz'
              ];
              
              var [ x, y ] = z;
              var [ x,y ] = z;
              var [ x, ...y ] = z;
              var [ ,,x, ] = z;

              singleValue

              Examples of incorrect code for this rule with the "always", { "singleValue": false } options:

              /*eslint array-bracket-spacing: ["error", "always", { "singleValue": false }]*/
              
              var foo = [ 'foo' ];
              var foo = [ 'foo'];
              var foo = ['foo' ];
              var foo = [ 1 ];
              var foo = [ 1];
              var foo = [1 ];
              var foo = [ [ 1, 2 ] ];
              var foo = [ { 'foo': 'bar' } ];

              Examples of correct code for this rule with the "always", { "singleValue": false } options:

              /*eslint array-bracket-spacing: ["error", "always", { "singleValue": false }]*/
              
              var foo = ['foo'];
              var foo = [1];
              var foo = [[ 1, 1 ]];
              var foo = [{ 'foo': 'bar' }];

              objectsInArrays

              Examples of incorrect code for this rule with the "always", { "objectsInArrays": false } options:

              /*eslint array-bracket-spacing: ["error", "always", { "objectsInArrays": false }]*/
              
              var arr = [ { 'foo': 'bar' } ];
              var arr = [ {
                'foo': 'bar'
              } ]

              Examples of correct code for this rule with the "always", { "objectsInArrays": false } options:

              /*eslint array-bracket-spacing: ["error", "always", { "objectsInArrays": false }]*/
              
              var arr = [{ 'foo': 'bar' }];
              var arr = [{
                'foo': 'bar'
              }];

              arraysInArrays

              Examples of incorrect code for this rule with the "always", { "arraysInArrays": false } options:

              /*eslint array-bracket-spacing: ["error", "always", { "arraysInArrays": false }]*/
              
              var arr = [ [ 1, 2 ], 2, 3, 4 ];
              var arr = [ [ 1, 2 ], 2, [ 3, 4 ] ];

              Examples of correct code for this rule with the "always", { "arraysInArrays": false } options:

              /*eslint array-bracket-spacing: ["error", "always", { "arraysInArrays": false }]*/
              
              var arr = [[ 1, 2 ], 2, 3, 4 ];
              var arr = [[ 1, 2 ], 2, [ 3, 4 ]];

              When Not To Use It

              You can turn this rule off if you are not concerned with the consistency of spacing between array brackets.

              Related Rules

              • [space-in-parens](space-in-parens.md)
              • [object-curly-spacing](object-curly-spacing.md)
              • [computed-property-spacing](computed-property-spacing.md) Source: http://eslint.org/docs/rules/

              Strings must use singlequote.
              Open

                        credentials: "same-origin",
              Severity: Minor
              Found in src/services/geonode.js by eslint

              enforce the consistent use of either backticks, double, or single quotes (quotes)

              JavaScript allows you to define strings in one of three ways: double quotes, single quotes, and backticks (as of ECMAScript 6). For example:

              /*eslint-env es6*/
              
              var double = "double";
              var single = 'single';
              var backtick = `backtick`;    // ES6 only

              Each of these lines creates a string and, in some cases, can be used interchangeably. The choice of how to define strings in a codebase is a stylistic one outside of template literals (which allow embedded of expressions to be interpreted).

              Many codebases require strings to be defined in a consistent manner.

              Rule Details

              This rule enforces the consistent use of either backticks, double, or single quotes.

              Options

              This rule has two options, a string option and an object option.

              String option:

              • "double" (default) requires the use of double quotes wherever possible
              • "single" requires the use of single quotes wherever possible
              • "backtick" requires the use of backticks wherever possible

              Object option:

              • "avoidEscape": true allows strings to use single-quotes or double-quotes so long as the string contains a quote that would have to be escaped otherwise
              • "allowTemplateLiterals": true allows strings to use backticks

              Deprecated: The object property avoid-escape is deprecated; please use the object property avoidEscape instead.

              double

              Examples of incorrect code for this rule with the default "double" option:

              /*eslint quotes: ["error", "double"]*/
              
              var single = 'single';
              var unescaped = 'a string containing "double" quotes';

              Examples of correct code for this rule with the default "double" option:

              /*eslint quotes: ["error", "double"]*/
              /*eslint-env es6*/
              
              var double = "double";
              var backtick = `back\ntick`;  // backticks are allowed due to newline
              var backtick = tag`backtick`; // backticks are allowed due to tag

              single

              Examples of incorrect code for this rule with the "single" option:

              /*eslint quotes: ["error", "single"]*/
              
              var double = "double";
              var unescaped = "a string containing 'single' quotes";

              Examples of correct code for this rule with the "single" option:

              /*eslint quotes: ["error", "single"]*/
              /*eslint-env es6*/
              
              var single = 'single';
              var backtick = `back${x}tick`; // backticks are allowed due to substitution

              backticks

              Examples of incorrect code for this rule with the "backtick" option:

              /*eslint quotes: ["error", "backtick"]*/
              
              var single = 'single';
              var double = "double";
              var unescaped = 'a string containing `backticks`';

              Examples of correct code for this rule with the "backtick" option:

              /*eslint quotes: ["error", "backtick"]*/
              /*eslint-env es6*/
              
              var backtick = `backtick`;

              avoidEscape

              Examples of additional correct code for this rule with the "double", { "avoidEscape": true } options:

              /*eslint quotes: ["error", "double", { "avoidEscape": true }]*/
              
              var single = 'a string containing "double" quotes';

              Examples of additional correct code for this rule with the "single", { "avoidEscape": true } options:

              /*eslint quotes: ["error", "single", { "avoidEscape": true }]*/
              
              var double = "a string containing 'single' quotes";

              Examples of additional correct code for this rule with the "backtick", { "avoidEscape": true } options:

              /*eslint quotes: ["error", "backtick", { "avoidEscape": true }]*/
              
              var double = "a string containing `backtick` quotes"

              allowTemplateLiterals

              Examples of additional correct code for this rule with the "double", { "allowTemplateLiterals": true } options:

              /*eslint quotes: ["error", "double", { "allowTemplateLiterals": true }]*/
              
              var double = "double";
              var double = `double`;

              Examples of additional correct code for this rule with the "single", { "allowTemplateLiterals": true } options:

              /*eslint quotes: ["error", "single", { "allowTemplateLiterals": true }]*/
              
              var single = 'single';
              var single = `single`;

              When Not To Use It

              If you do not need consistency in your string styles, you can safely disable this rule. Source: http://eslint.org/docs/rules/

              Severity
              Category
              Status
              Source
              Language