meteor/meteor

View on GitHub
npm-packages/cordova-plugin-meteor-webapp/src/android/WebAppLocalServer.java

Summary

Maintainability
D
2 days
Test Coverage

File WebAppLocalServer.java has 402 lines of code (exceeds 250 allowed). Consider refactoring.
Open

package com.meteor.webapp;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.AssetManager;

    WebAppLocalServer has 35 methods (exceeds 20 allowed). Consider refactoring.
    Open

    public class WebAppLocalServer extends CordovaPlugin implements AssetBundleManager.Callback {
        private static final String LOG_TAG = "MeteorWebApp";
        public static final String PREFS_NAME = "MeteorWebApp";
    
        private static final String LOCAL_FILESYSTEM_PATH = "/local-filesystem";

      Method initializeResourceHandlers has 52 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          private void initializeResourceHandlers() {
              // Serve files from the current asset bundle
              resourceHandlers.add(new WebResourceHandler() {
                  @Override
                  public Uri remapUri(Uri uri) {

        Method initializeAssetBundles has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
        Open

            void initializeAssetBundles() throws WebAppException {
                // The initial asset bundle consists of the assets bundled with the app
                AssetBundle initialAssetBundle = new AssetBundle(resourceApi, applicationDirectoryUri);
                Log.d(LOG_TAG, "Initial bundle loaded " + initialAssetBundle.getVersion());
        
        

        Cognitive Complexity

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

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

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

        Further reading

        Method initializeAssetBundles has 33 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            void initializeAssetBundles() throws WebAppException {
                // The initial asset bundle consists of the assets bundled with the app
                AssetBundle initialAssetBundle = new AssetBundle(resourceApi, applicationDirectoryUri);
                Log.d(LOG_TAG, "Initial bundle loaded " + initialAssetBundle.getVersion());
        
        

          Method getPathHandler has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
          Open

              @Override
              public CordovaPluginPathHandler getPathHandler() {
                  return new CordovaPluginPathHandler(new androidx.webkit.WebViewAssetLoader.PathHandler() {
                      @Nullable
                      @Override

          Cognitive Complexity

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

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

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

          Further reading

          Method remapUri has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

              @Override
              public Uri remapUri(Uri uri) {
                  if (!(uri.getScheme().equals("http") && uri.getHost().equals("localhost") && uri.getPort() == localServerPort)) return null;
          
                  Uri remappedUri = null;

          Cognitive Complexity

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

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

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

          Further reading

          Method execute has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
          Open

              @Override
              public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
                  if ("checkForUpdates".equals(action)) {
                      checkForUpdates(callbackContext);
                      return true;

          Cognitive Complexity

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

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

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

          Further reading

          Avoid too many return statements within this method.
          Open

                              return asset.getFileUri();

            Avoid too many return statements within this method.
            Open

                        return testingDelegate.execute(action, args, callbackContext);

              Avoid too many return statements within this method.
              Open

                      return true;

                Avoid too many return statements within this method.
                Open

                        return false;

                  Avoid too many return statements within this method.
                  Open

                              return true;

                    Method handle has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                    Open

                                @Nullable
                                @Override
                                public WebResourceResponse handle(@NonNull String path) {
                                    Uri remappedUri = null;
                                    for (WebResourceHandler handler : resourceHandlers) {

                    Cognitive Complexity

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

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

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

                    Further reading

                    Method revertToLastKnownGoodVersion has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                    Open

                        private void revertToLastKnownGoodVersion() {
                            // Blacklist the current version, so we don't update to it again right away
                            configuration.addBlacklistedVersion(currentAssetBundle.getVersion());
                    
                            // If there is a last known good version and we can load the bundle, revert to it

                    Cognitive Complexity

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

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

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

                    Further reading

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

                        private void onError(CallbackContext callbackContext) {
                            PluginResult pluginResult = new PluginResult(PluginResult.Status.NO_RESULT);
                            pluginResult.setKeepCallback(true);
                            callbackContext.sendPluginResult(pluginResult);
                    
                    
                    npm-packages/cordova-plugin-meteor-webapp/src/android/WebAppLocalServer.java on lines 280..286

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

                    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

                        private void onNewVersionReady(CallbackContext callbackContext) {
                            PluginResult pluginResult = new PluginResult(PluginResult.Status.NO_RESULT);
                            pluginResult.setKeepCallback(true);
                            callbackContext.sendPluginResult(pluginResult);
                    
                    
                    npm-packages/cordova-plugin-meteor-webapp/src/android/WebAppLocalServer.java on lines 296..302

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

                    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