WordPress.org
Get WordPress

Make WordPress Core

Changeset 41974


Ignore:
Timestamp:
10/23/2017 07:54:33 PM (9 years ago)
Author:
westonruter
Message:

Code Editor: Keep linting and its error reporting configured when lint option is changed dynamically.

Also explicitly disable lint option for SCSS and LESS.

See #12423.

Location:
trunk/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-admin/js/code-editor.js

    r41852 r41974  
    3737         */
    3838        function configureLinting( editor, settings ) { // eslint-disable-line complexity
    39                 var lintOptions = editor.getOption( 'lint' ), currentErrorAnnotations = [], updateErrorNotice, previouslyShownErrorAnnotations = [];
    40                 if ( ! lintOptions ) {
    41                         return;
    42                 }
    43 
    44                 if ( true === lintOptions ) {
    45                         lintOptions = {};
    46                 } else {
    47                         lintOptions = $.extend( {}, lintOptions );
    48                 }
    49 
    50                 // Note that rules must be sent in the "deprecated" lint.options property to prevent linter from complaining about unrecognized options. See <https://github.com/codemirror/CodeMirror/pull/4944>.
    51                 if ( ! lintOptions.options ) {
    52                         lintOptions.options = {};
    53                 }
    54 
    55                 // Configure JSHint.
    56                 if ( 'javascript' === settings.codemirror.mode && settings.jshint ) {
    57                         $.extend( lintOptions.options, settings.jshint );
    58                 }
    59 
    60                 // Configure CSSLint.
    61                 if ( 'css' === settings.codemirror.mode && settings.csslint ) {
    62                         $.extend( lintOptions.options, settings.csslint );
    63                 }
    64 
    65                 // Configure HTMLHint.
    66                 if ( 'htmlmixed' === settings.codemirror.mode && settings.htmlhint ) {
    67                         lintOptions.options.rules = $.extend( {}, settings.htmlhint );
    68 
    69                         if ( settings.jshint ) {
    70                                 lintOptions.options.rules.jshint = settings.jshint;
    71                         }
    72                         if ( settings.csslint ) {
    73                                 lintOptions.options.rules.csslint = settings.csslint;
    74                         }
    75                 }
     39                var currentErrorAnnotations = [], previouslyShownErrorAnnotations = [];
    7640
    7741                /**
    … …  
    8044                 * @returns {void}
    8145                 */
    82                 updateErrorNotice = function() {
     46                function updateErrorNotice() {
    8347                        if ( settings.onUpdateErrorNotice && ! _.isEqual( currentErrorAnnotations, previouslyShownErrorAnnotations ) ) {
    8448                                settings.onUpdateErrorNotice( currentErrorAnnotations, editor );
    8549                                previouslyShownErrorAnnotations = currentErrorAnnotations;
    8650                        }
    87                 };
    88 
    89                 // Wrap the onUpdateLinting CodeMirror event to route to onChangeLintingErrors and onUpdateErrorNotice.
    90                 lintOptions.onUpdateLinting = (function( onUpdateLintingOverridden ) {
    91                         return function( annotations, annotationsSorted, cm ) {
    92                                 var errorAnnotations = _.filter( annotations, function( annotation ) {
    93                                         return 'error' === annotation.severity;
    94                                 } );
    95 
    96                                 if ( onUpdateLintingOverridden ) {
    97                                         onUpdateLintingOverridden.apply( annotations, annotationsSorted, cm );
    98                                 }
    99 
    100                                 // Skip if there are no changes to the errors.
    101                                 if ( _.isEqual( errorAnnotations, currentErrorAnnotations ) ) {
    102                                         return;
    103                                 }
    104 
    105                                 currentErrorAnnotations = errorAnnotations;
    106 
    107                                 if ( settings.onChangeLintingErrors ) {
    108                                         settings.onChangeLintingErrors( errorAnnotations, annotations, annotationsSorted, cm );
    109                                 }
    110 
    111                                 /*
    112                                  * Update notifications when the editor is not focused to prevent error message
    113                                  * from overwhelming the user during input, unless there are now no errors or there
    114                                  * were previously errors shown. In these cases, update immediately so they can know
    115                                  * that they fixed the errors.
    116                                  */
    117                                 if ( ! cm.state.focused || 0 === currentErrorAnnotations.length || previouslyShownErrorAnnotations.length > 0 ) {
    118                                         updateErrorNotice();
    119                                 }
    120                         };
    121                 })( lintOptions.onUpdateLinting );
    122 
    123                 editor.setOption( 'lint', lintOptions );
     51                }
     52
     53                /**
     54                 * Get lint options.
     55                 *
     56                 * @returns {object} Lint options.
     57                 */
     58                function getLintOptions() { // eslint-disable-line complexity
     59                        var options = editor.getOption( 'lint' );
     60
     61                        if ( ! options ) {
     62                                return false;
     63                        }
     64
     65                        if ( true === options ) {
     66                                options = {};
     67                        } else if ( _.isObject( options ) ) {
     68                                options = $.extend( {}, options );
     69                        }
     70
     71                        // Note that rules must be sent in the "deprecated" lint.options property to prevent linter from complaining about unrecognized options. See <https://github.com/codemirror/CodeMirror/pull/4944>.
     72                        if ( ! options.options ) {
     73                                options.options = {};
     74                        }
     75
     76                        // Configure JSHint.
     77                        if ( 'javascript' === settings.codemirror.mode && settings.jshint ) {
     78                                $.extend( options.options, settings.jshint );
     79                        }
     80
     81                        // Configure CSSLint.
     82                        if ( 'css' === settings.codemirror.mode && settings.csslint ) {
     83                                $.extend( options.options, settings.csslint );
     84                        }
     85
     86                        // Configure HTMLHint.
     87                        if ( 'htmlmixed' === settings.codemirror.mode && settings.htmlhint ) {
     88                                options.options.rules = $.extend( {}, settings.htmlhint );
     89
     90                                if ( settings.jshint ) {
     91                                        options.options.rules.jshint = settings.jshint;
     92                                }
     93                                if ( settings.csslint ) {
     94                                        options.options.rules.csslint = settings.csslint;
     95                                }
     96                        }
     97
     98                        // Wrap the onUpdateLinting CodeMirror event to route to onChangeLintingErrors and onUpdateErrorNotice.
     99                        options.onUpdateLinting = (function( onUpdateLintingOverridden ) {
     100                                return function( annotations, annotationsSorted, cm ) {
     101                                        var errorAnnotations = _.filter( annotations, function( annotation ) {
     102                                                return 'error' === annotation.severity;
     103                                        } );
     104
     105                                        if ( onUpdateLintingOverridden ) {
     106                                                onUpdateLintingOverridden.apply( annotations, annotationsSorted, cm );
     107                                        }
     108
     109                                        // Skip if there are no changes to the errors.
     110                                        if ( _.isEqual( errorAnnotations, currentErrorAnnotations ) ) {
     111                                                return;
     112                                        }
     113
     114                                        currentErrorAnnotations = errorAnnotations;
     115
     116                                        if ( settings.onChangeLintingErrors ) {
     117                                                settings.onChangeLintingErrors( errorAnnotations, annotations, annotationsSorted, cm );
     118                                        }
     119
     120                                        /*
     121                                         * Update notifications when the editor is not focused to prevent error message
     122                                         * from overwhelming the user during input, unless there are now no errors or there
     123                                         * were previously errors shown. In these cases, update immediately so they can know
     124                                         * that they fixed the errors.
     125                                         */
     126                                        if ( ! editor.state.focused || 0 === currentErrorAnnotations.length || previouslyShownErrorAnnotations.length > 0 ) {
     127                                                updateErrorNotice();
     128                                        }
     129                                };
     130                        })( options.onUpdateLinting );
     131
     132                        return options;
     133                }
     134
     135                editor.setOption( 'lint', getLintOptions() );
     136
     137                // Keep lint options populated.
     138                editor.on( 'optionChange', function( cm, option ) {
     139                        var options;
     140                        if ( 'lint' !== option ) {
     141                                return;
     142                        }
     143                        options = editor.getOption( 'lint' );
     144                        if ( true === options ) {
     145                                editor.setOption( 'lint', getLintOptions() ); // Expand to include linting options.
     146                        }
     147
     148                        // Force update on error notice to show or hide.
     149                        if ( editor.getOption( 'lint' ) ) {
     150                                editor.performLint();
     151                        } else {
     152                                currentErrorAnnotations = [];
     153                                updateErrorNotice();
     154                        }
     155                } );
    124156
    125157                // Update error notice when leaving the editor.

  • trunk/src/wp-includes/general-template.php

    r41728 r41974  
    33123312                $settings['codemirror'] = array_merge( $settings['codemirror'], array(
    33133313                        'mode' => $type,
     3314                        'lint' => false,
    33143315                        'autoCloseBrackets' => true,
    33153316                        'matchBrackets' => true,
Note: See TracChangeset for help on using the changeset viewer.