devstaff-crete/DevStaff-Heraklion

View on GitHub
meetups/meetup06-MobileDev/x-platform/js/reveal.js

Summary

Maintainability
F
3 wks
Test Coverage

File reveal.js has 2310 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * reveal.js
 * http://lab.hakim.se/reveal-js
 * MIT licensed
 *
Severity: Major
Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 6 days to fix

    Function slide has 77 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        function slide( h, v, f, o ) {
    
            // Remember where we were at before
            previousSlide = currentSlide;
    
    
    Severity: Major
    Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 3 hrs to fix

      Function updateBackground has 65 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          function updateBackground( includeAll ) {
      
              var currentBackground = null;
      
              // Reverse past/future classes when in RTL mode
      Severity: Major
      Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

        Function configure has 63 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            function configure( options ) {
        
                var numberOfSlides = dom.wrapper.querySelectorAll( SLIDES_SELECTOR ).length;
        
                dom.wrapper.classList.remove( config.transition );
        Severity: Major
        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

          Function updateSlides has 61 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              function updateSlides( selector, index ) {
          
                  // Select all slides and convert the NodeList result to
                  // an array
                  var slides = toArray( dom.wrapper.querySelectorAll( selector ) ),
          Severity: Major
          Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

            Function onDocumentKeyDown has 59 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                function onDocumentKeyDown( event ) {
            
                    // If there's a condition specified and it returns false,
                    // ignore this event
                    if( typeof config.keyboardCondition === 'function' && config.keyboardCondition() === false ) {
            Severity: Major
            Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

              Function onTouchMove has 55 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  function onTouchMove( event ) {
              
                      // Each touch should only trigger one action
                      if( !touch.captured ) {
                          onUserInput( event );
              Severity: Major
              Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

                Function createBackground has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    function createBackground( slide, container ) {
                
                        var data = {
                            background: slide.getAttribute( 'data-background' ),
                            backgroundSize: slide.getAttribute( 'data-background-size' ),
                Severity: Major
                Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

                  Function addEventListeners has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      function addEventListeners() {
                  
                          eventsAreBound = true;
                  
                          window.addEventListener( 'hashchange', onWindowHashChange, false );
                  Severity: Major
                  Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

                    Function layout has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        function layout() {
                    
                            if( dom.wrapper && !isPrintingPDF() ) {
                    
                                var size = getComputedSlideSize();
                    Severity: Minor
                    Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 2 hrs to fix

                      Function navigateFragment has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          function navigateFragment( index, offset ) {
                      
                              if( currentSlide && config.fragments ) {
                      
                                  var fragments = sortFragments( currentSlide.querySelectorAll( '.fragment' ) );
                      Severity: Minor
                      Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                        Function showSlide has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            function showSlide( slide ) {
                        
                                // Show the slide element
                                slide.style.display = 'block';
                        
                        
                        Severity: Minor
                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                              Playback.prototype.render = function() {
                          
                                  var progress = this.playing ? this.progress : 0,
                                      radius = ( this.diameter / 2 ) - this.thickness,
                                      x = this.diameter / 2,
                          Severity: Minor
                          Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                            Function load has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                function load() {
                            
                                    var scripts = [],
                                        scriptsAsync = [],
                                        scriptsToPreload = 0;
                            Severity: Minor
                            Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                              Function updateSlidesVisibility has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  function updateSlidesVisibility() {
                              
                                      // Select all slides and convert the NodeList result to
                                      // an array
                                      var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) ),
                              Severity: Minor
                              Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                Function activateOverview has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                    function activateOverview() {
                                
                                        // Only proceed if enabled in config
                                        if( config.overview ) {
                                
                                
                                Severity: Minor
                                Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                  Function colorToRgb has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      function colorToRgb( color ) {
                                  
                                          var hex3 = color.match( /^#([0-9a-f]{3})$/i );
                                          if( hex3 && hex3[1] ) {
                                              hex3 = hex3[1];
                                  Severity: Minor
                                  Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                    Function setupPDF has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                        function setupPDF() {
                                    
                                            var slideSize = getComputedSlideSize( window.innerWidth, window.innerHeight );
                                    
                                            // Dimensions of the PDF pages
                                    Severity: Minor
                                    Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                                          function cueAutoSlide() {
                                      
                                              cancelAutoSlide();
                                      
                                              if( currentSlide ) {
                                      Severity: Minor
                                      Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                        Function createBackgrounds has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            function createBackgrounds() {
                                        
                                                var printMode = isPrintingPDF();
                                        
                                                // Clear prior backgrounds
                                        Severity: Minor
                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                                              function removeEventListeners() {
                                          
                                                  eventsAreBound = false;
                                          
                                                  document.removeEventListener( 'keydown', onDocumentKeyDown, false );
                                          Severity: Minor
                                          Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                                                function showHelp() {
                                            
                                                    if( config.help ) {
                                            
                                                        closeOverlay();
                                            Severity: Minor
                                            Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                                                  function getProgress() {
                                              
                                                      var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) );
                                              
                                                      // The number of past and total slides
                                              Severity: Minor
                                              Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                                                    function updateControls() {
                                                
                                                        var routes = availableRoutes();
                                                        var fragments = availableFragments();
                                                
                                                
                                                Severity: Minor
                                                Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

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

                                                      function showPreview( url ) {
                                                  
                                                          closeOverlay();
                                                  
                                                          dom.overlay = document.createElement( 'div' );
                                                  Severity: Minor
                                                  Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                                    Function sortFragments has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                        function sortFragments( fragments ) {
                                                    
                                                            fragments = toArray( fragments );
                                                    
                                                            var ordered = [],
                                                    Severity: Minor
                                                    Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                                      Function getIndices has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          function getIndices( slide ) {
                                                      
                                                              // By default, return the current indices
                                                              var h = indexh,
                                                                  v = indexv,
                                                      Severity: Minor
                                                      Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                                        Consider simplifying this complex logical expression.
                                                        Open

                                                                    if( autoSlide && !autoSlidePaused && !isPaused() && !isOverview() && ( !Reveal.isLastSlide() || availableFragments().next || config.loop === true ) ) {
                                                                        autoSlideTimeout = setTimeout( navigateNext, autoSlide );
                                                                        autoSlideStartTime = Date.now();
                                                                    }
                                                        Severity: Major
                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                                          Consider simplifying this complex logical expression.
                                                          Open

                                                                  if( activeElementIsCE || activeElementIsInput || (event.shiftKey && event.keyCode !== 32) || event.altKey || event.ctrlKey || event.metaKey ) return;
                                                          Severity: Major
                                                          Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 1 hr to fix

                                                            Avoid deeply nested control flow statements.
                                                            Open

                                                                                if( config.fragments ) {
                                                                                    var futureFragments = toArray( element.querySelectorAll( '.fragment.visible' ) );
                                                            
                                                                                    // No fragments in future slides should be visible ahead of time
                                                                                    while( futureFragments.length ) {
                                                            Severity: Major
                                                            Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 45 mins to fix

                                                              Avoid deeply nested control flow statements.
                                                              Open

                                                                                      if( distanceX + distanceY < viewDistance ) {
                                                                                          showSlide( verticalSlide );
                                                                                      }
                                                                                      else {
                                                                                          hideSlide( verticalSlide );
                                                              Severity: Major
                                                              Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 45 mins to fix

                                                                Avoid deeply nested control flow statements.
                                                                Open

                                                                                        while( pastFragments.length ) {
                                                                                            var pastFragment = pastFragments.pop();
                                                                                            pastFragment.classList.add( 'visible' );
                                                                                            pastFragment.classList.remove( 'current-fragment' );
                                                                                        }
                                                                Severity: Major
                                                                Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 45 mins to fix

                                                                  Avoid deeply nested control flow statements.
                                                                  Open

                                                                                      if( touch.captured || isVerticalSlide( currentSlide ) ) {
                                                                                          event.preventDefault();
                                                                                      }
                                                                  Severity: Major
                                                                  Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 45 mins to fix

                                                                    Avoid too many return statements within this function.
                                                                    Open

                                                                            return value;
                                                                    Severity: Major
                                                                    Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 30 mins to fix

                                                                      Avoid too many return statements within this function.
                                                                      Open

                                                                              return null;
                                                                      Severity: Major
                                                                      Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js - About 30 mins to fix

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

                                                                                pointerEvents.forEach( function( eventName ) {
                                                                                    dom.controlsLeft.forEach( function( el ) { el.addEventListener( eventName, onNavigateLeftClicked, false ); } );
                                                                                    dom.controlsRight.forEach( function( el ) { el.addEventListener( eventName, onNavigateRightClicked, false ); } );
                                                                                    dom.controlsUp.forEach( function( el ) { el.addEventListener( eventName, onNavigateUpClicked, false ); } );
                                                                                    dom.controlsDown.forEach( function( el ) { el.addEventListener( eventName, onNavigateDownClicked, false ); } );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 day to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 982..989

                                                                        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 212.

                                                                        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

                                                                                [ 'touchstart', 'click' ].forEach( function( eventName ) {
                                                                                    dom.controlsLeft.forEach( function( el ) { el.removeEventListener( eventName, onNavigateLeftClicked, false ); } );
                                                                                    dom.controlsRight.forEach( function( el ) { el.removeEventListener( eventName, onNavigateRightClicked, false ); } );
                                                                                    dom.controlsUp.forEach( function( el ) { el.removeEventListener( eventName, onNavigateUpClicked, false ); } );
                                                                                    dom.controlsDown.forEach( function( el ) { el.removeEventListener( eventName, onNavigateDownClicked, false ); } );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 day to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 938..945

                                                                        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 212.

                                                                        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

                                                                                        else if( i > index ) {
                                                                                            // Any element subsequent to index is given the 'future' class
                                                                                            element.classList.add( reverse ? 'past' : 'future' );
                                                                        
                                                                                            if( config.fragments ) {
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 4 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2193..2222

                                                                        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 116.

                                                                        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

                                                                                        if( i < index ) {
                                                                                            // Any element previous to index is given the 'past' class
                                                                                            element.classList.add( reverse ? 'future' : 'past' );
                                                                        
                                                                                            if( config.fragments ) {
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 4 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2208..2222

                                                                        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 116.

                                                                        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

                                                                            function navigateRight() {
                                                                        
                                                                                // Reverse for RTL
                                                                                if( config.rtl ) {
                                                                                    if( ( isOverview() || previousFragment() === false ) && availableRoutes().right ) {
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 3 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3377..3390

                                                                        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 112.

                                                                        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

                                                                            function navigateLeft() {
                                                                        
                                                                                // Reverse for RTL
                                                                                if( config.rtl ) {
                                                                                    if( ( isOverview() || nextFragment() === false ) && availableRoutes().left ) {
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 3 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3392..3405

                                                                        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 112.

                                                                        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

                                                                                toArray( dom.slides.querySelectorAll( 'iframe[src*="youtube.com/embed/"]' ) ).forEach( function( el ) {
                                                                                    var src = el.getAttribute( 'src' );
                                                                                    if( !/enablejsapi\=1/gi.test( src ) ) {
                                                                                        el.setAttribute( 'src', src + ( !/\?/.test( src ) ? '?' : '&' ) + 'enablejsapi=1' );
                                                                                    }
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 3 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2709..2714

                                                                        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 100.

                                                                        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

                                                                                toArray( dom.slides.querySelectorAll( 'iframe[src*="player.vimeo.com/"]' ) ).forEach( function( el ) {
                                                                                    var src = el.getAttribute( 'src' );
                                                                                    if( !/api\=1/gi.test( src ) ) {
                                                                                        el.setAttribute( 'src', src + ( !/\?/.test( src ) ? '?' : '&' ) + 'api=1' );
                                                                                    }
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 3 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2701..2706

                                                                        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 100.

                                                                        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

                                                                                    else {
                                                                                        if( fragments.prev ) dom.controlsLeft.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
                                                                                        if( fragments.next ) dom.controlsRight.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
                                                                                    }
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2388..2391

                                                                        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 93.

                                                                        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

                                                                                    if( isVerticalSlide( currentSlide ) ) {
                                                                                        if( fragments.prev ) dom.controlsUp.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
                                                                                        if( fragments.next ) dom.controlsDown.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
                                                                                    }
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2392..2395

                                                                        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 93.

                                                                        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

                                                                                features.transforms3d = 'WebkitPerspective' in document.body.style ||
                                                                                                        'MozPerspective' in document.body.style ||
                                                                                                        'msPerspective' in document.body.style ||
                                                                                                        'OPerspective' in document.body.style ||
                                                                                                        'perspective' in document.body.style;
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 283..287

                                                                        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 87.

                                                                        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

                                                                                features.transforms2d = 'WebkitTransform' in document.body.style ||
                                                                                                        'MozTransform' in document.body.style ||
                                                                                                        'msTransform' in document.body.style ||
                                                                                                        'OTransform' in document.body.style ||
                                                                                                        'transform' in document.body.style;
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 277..281

                                                                        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 87.

                                                                        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 3 locations. Consider refactoring.
                                                                        Open

                                                                            function onPointerDown( event ) {
                                                                        
                                                                                if( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === "touch" ) {
                                                                                    event.touches = [{ clientX: event.clientX, clientY: event.clientY }];
                                                                                    onTouchStart( event );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 2 other locations - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3773..3780
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3785..3792

                                                                        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 83.

                                                                        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 3 locations. Consider refactoring.
                                                                        Open

                                                                            function onPointerMove( event ) {
                                                                        
                                                                                if( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === "touch" )  {
                                                                                    event.touches = [{ clientX: event.clientX, clientY: event.clientY }];
                                                                                    onTouchMove( event );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 2 other locations - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3761..3768
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3785..3792

                                                                        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 83.

                                                                        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 3 locations. Consider refactoring.
                                                                        Open

                                                                            function onPointerUp( event ) {
                                                                        
                                                                                if( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === "touch" )  {
                                                                                    event.touches = [{ clientX: event.clientX, clientY: event.clientY }];
                                                                                    onTouchEnd( event );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 2 other locations - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3761..3768
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3773..3780

                                                                        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 83.

                                                                        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

                                                                                    toArray( slide.querySelectorAll( 'iframe[src*="player.vimeo.com/"]' ) ).forEach( function( el ) {
                                                                                        if( !el.hasAttribute( 'data-ignore' ) && typeof el.contentWindow.postMessage === 'function' ) {
                                                                                            el.contentWindow.postMessage( '{"method":"pause"}', '*' );
                                                                                        }
                                                                                    });
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2774..2778

                                                                        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 79.

                                                                        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

                                                                                    toArray( slide.querySelectorAll( 'iframe[src*="youtube.com/embed/"]' ) ).forEach( function( el ) {
                                                                                        if( !el.hasAttribute( 'data-ignore' ) && typeof el.contentWindow.postMessage === 'function' ) {
                                                                                            el.contentWindow.postMessage( '{"event":"command","func":"pauseVideo","args":""}', '*' );
                                                                                        }
                                                                                    });
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 2 hrs to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2781..2785

                                                                        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 79.

                                                                        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

                                                                            function toggleOverview( override ) {
                                                                        
                                                                                if( typeof override === 'boolean' ) {
                                                                                    override ? activateOverview() : deactivateOverview();
                                                                                }
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 1850..1859

                                                                        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 63.

                                                                        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

                                                                            function togglePause( override ) {
                                                                        
                                                                                if( typeof override === 'boolean' ) {
                                                                                    override ? pause() : resume();
                                                                                }
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 1750..1759

                                                                        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 63.

                                                                        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

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

                                                                                    touch.startSpan = distanceBetween( {
                                                                                        x: event.touches[1].clientX,
                                                                                        y: event.touches[1].clientY
                                                                                    }, {
                                                                                        x: touch.startX,
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3679..3685

                                                                        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 60.

                                                                        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

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

                                                                                        var currentSpan = distanceBetween( {
                                                                                            x: event.touches[1].clientX,
                                                                                            y: event.touches[1].clientY
                                                                                        }, {
                                                                                            x: touch.startX,
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3651..3657

                                                                        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 60.

                                                                        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

                                                                                    toArray( slide.querySelectorAll( 'iframe[src*="youtube.com/embed/"]' ) ).forEach( function( el ) {
                                                                                        if( el.hasAttribute( 'data-autoplay' ) ) {
                                                                                            el.contentWindow.postMessage( '{"event":"command","func":"playVideo","args":""}', '*' );
                                                                                        }
                                                                                    });
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2745..2749

                                                                        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 59.

                                                                        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

                                                                                    toArray( slide.querySelectorAll( 'iframe[src*="player.vimeo.com/"]' ) ).forEach( function( el ) {
                                                                                        if( el.hasAttribute( 'data-autoplay' ) ) {
                                                                                            el.contentWindow.postMessage( '{"method":"play"}', '*' );
                                                                                        }
                                                                                    });
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2738..2742

                                                                        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 59.

                                                                        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

                                                                                    if( window.navigator.pointerEnabled ) {
                                                                                        // IE 11 uses un-prefixed version of pointer events
                                                                                        dom.wrapper.addEventListener( 'pointerdown', onPointerDown, false );
                                                                                        dom.wrapper.addEventListener( 'pointermove', onPointerMove, false );
                                                                                        dom.wrapper.addEventListener( 'pointerup', onPointerUp, false );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 893..898

                                                                        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 57.

                                                                        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

                                                                                    else if( window.navigator.msPointerEnabled ) {
                                                                                        // IE 10 uses prefixed version of pointer events
                                                                                        dom.wrapper.addEventListener( 'MSPointerDown', onPointerDown, false );
                                                                                        dom.wrapper.addEventListener( 'MSPointerMove', onPointerMove, false );
                                                                                        dom.wrapper.addEventListener( 'MSPointerUp', onPointerUp, false );
                                                                        Severity: Major
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 1 hr to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 887..898

                                                                        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 57.

                                                                        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

                                                                                if( config.rtl ) {
                                                                                    dom.wrapper.classList.add( 'rtl' );
                                                                                }
                                                                                else {
                                                                                    dom.wrapper.classList.remove( 'rtl' );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 55 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/ionic/js/ionic.js on lines 2394..2398

                                                                        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 53.

                                                                        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

                                                                                anchors.forEach( function( element ) {
                                                                                    if( /^(http|www)/gi.test( element.getAttribute( 'href' ) ) ) {
                                                                                        element.addEventListener( 'click', onPreviewLinkClicked, false );
                                                                                    }
                                                                                } );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 55 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 1329..1333

                                                                        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 53.

                                                                        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

                                                                                anchors.forEach( function( element ) {
                                                                                    if( /^(http|www)/gi.test( element.getAttribute( 'href' ) ) ) {
                                                                                        element.removeEventListener( 'click', onPreviewLinkClicked, false );
                                                                                    }
                                                                                } );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 55 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 1314..1318

                                                                        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 53.

                                                                        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

                                                                                else if( window.navigator.msPointerEnabled ) {
                                                                                    dom.wrapper.removeEventListener( 'MSPointerDown', onPointerDown, false );
                                                                                    dom.wrapper.removeEventListener( 'MSPointerMove', onPointerMove, false );
                                                                                    dom.wrapper.removeEventListener( 'MSPointerUp', onPointerUp, false );
                                                                                }
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 50 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 966..970

                                                                        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 52.

                                                                        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

                                                                                if( window.navigator.pointerEnabled ) {
                                                                                    dom.wrapper.removeEventListener( 'pointerdown', onPointerDown, false );
                                                                                    dom.wrapper.removeEventListener( 'pointermove', onPointerMove, false );
                                                                                    dom.wrapper.removeEventListener( 'pointerup', onPointerUp, false );
                                                                                }
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 50 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 972..976

                                                                        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 52.

                                                                        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

                                                                            function navigateUp() {
                                                                        
                                                                                // Prioritize hiding fragments
                                                                                if( ( isOverview() || previousFragment() === false ) && availableRoutes().up ) {
                                                                                    slide( indexh, indexv - 1 );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 45 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3416..3423

                                                                        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 50.

                                                                        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

                                                                                addEventListener: function( type, listener, useCapture ) {
                                                                                    if( 'addEventListener' in window ) {
                                                                                        ( dom.wrapper || document.querySelector( '.reveal' ) ).addEventListener( type, listener, useCapture );
                                                                                    }
                                                                                },
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 45 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 4262..4266

                                                                        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 50.

                                                                        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

                                                                                removeEventListener: function( type, listener, useCapture ) {
                                                                                    if( 'addEventListener' in window ) {
                                                                                        ( dom.wrapper || document.querySelector( '.reveal' ) ).removeEventListener( type, listener, useCapture );
                                                                                    }
                                                                                },
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 45 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 4257..4261

                                                                        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 50.

                                                                        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

                                                                            function navigateDown() {
                                                                        
                                                                                // Prioritize revealing fragments
                                                                                if( ( isOverview() || nextFragment() === false ) && availableRoutes().down ) {
                                                                                    slide( indexh, indexv + 1 );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 45 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 3407..3414

                                                                        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 50.

                                                                        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

                                                                                    toArray( slide.querySelectorAll( 'iframe' ) ).forEach( function( el ) {
                                                                                        el.contentWindow.postMessage( 'slide:stop', '*' );
                                                                                    });
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 40 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2733..2735

                                                                        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 49.

                                                                        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

                                                                                    toArray( slide.querySelectorAll( 'iframe' ) ).forEach( function( el ) {
                                                                                        el.contentWindow.postMessage( 'slide:start', '*' );
                                                                                    });
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 40 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 2769..2771

                                                                        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 49.

                                                                        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

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

                                                                                    dom.overlay.querySelector( '.close' ).addEventListener( 'click', function( event ) {
                                                                                        closeOverlay();
                                                                                        event.preventDefault();
                                                                                    }, false );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 35 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 1364..1367

                                                                        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 47.

                                                                        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

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

                                                                                dom.overlay.querySelector( '.close' ).addEventListener( 'click', function( event ) {
                                                                                    closeOverlay();
                                                                                    event.preventDefault();
                                                                                }, false );
                                                                        Severity: Minor
                                                                        Found in meetups/meetup06-MobileDev/x-platform/js/reveal.js and 1 other location - About 35 mins to fix
                                                                        meetups/meetup06-MobileDev/x-platform/js/reveal.js on lines 1411..1414

                                                                        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 47.

                                                                        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

                                                                        There are no issues that match your filters.

                                                                        Category
                                                                        Status