hackedteam/core-android-market

View on GitHub

Showing 376 of 566 total issues

Function collect_logs has 13 arguments (exceeds 4 allowed). Consider refactoring.
Open

def collect_logs( 

    Method onCreateView has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
    
    Severity: Minor
    Found in src/main/java/org/benews/DetailFragView.java - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

    def find_viable_generators (target_type, prop_set):
        key = target_type + '.' + str (prop_set)
    
        l = __viable_generators_cache.get (key, None)
        if not l:
    Severity: Minor
    Found in src/libbson/boost/boost_1_53_0/tools/build/v2/build/generators.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

    def find_viable_generators_aux (target_type, prop_set):
        """ Returns generators which can be used to construct target of specified type
            with specified properties. Uses the following algorithm:
            - iterates over requested target_type and all it's bases (in the order returned bt
              type.all-bases.
    Severity: Minor
    Found in src/libbson/boost/boost_1_53_0/tools/build/v2/build/generators.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

    def expand_subfeatures_in_conditions (properties):
    
        result = []
        for p in properties:
    
    
    Severity: Minor
    Found in src/libbson/boost/boost_1_53_0/tools/build/v2/build/property.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

        def _translateNode( self, *context, **kwargs ):
            node = None
            names = [ ]
            for c in context:
                if c:
    Severity: Minor
    Found in src/libbson/boost/boost_1_53_0/tools/build/v2/tools/doxproc.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

    def default_host_os():
        host_os = os_name()
        if host_os not in (x.upper() for x in __os_names):
            if host_os == 'NT': host_os = 'windows'
            elif host_os == 'AS400': host_os = 'unix'
    Severity: Minor
    Found in src/libbson/boost/boost_1_53_0/tools/build/v2/tools/builtin.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

        def construct(self, name, source_targets, ps):
    
            source_targets = self.targets_to_stage(source_targets, ps)
            ps = self.update_location(ps)
    
    
    Severity: Minor
    Found in src/libbson/boost/boost_1_53_0/tools/build/v2/tools/stage.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

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

        def all_referenced_targets(self, result):
            """Returns all targets referenced by this subvariant,
            either directly or indirectly, and either as sources,
            or as dependency properties. Targets referred with
            dependency property are returned a properties, not targets."""

    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 saveFileDialog1_FileOk has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.
    Open

        private void saveFileDialog1_FileOk(object sender, CancelEventArgs e)
        {
          using (StreamWriter sw = new StreamWriter(this.saveFileDialog.FileName))
          { // Write distribution info and properties to file.
            sw.WriteLine( AssemblyDescription);

    Cognitive Complexity

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

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

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

    Further reading

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

        def x_name_(self, *context, **kwargs):
            node = None
            names = [ ]
            for c in context:
                if c:

    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 onPostExecute has 39 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

            @Override
            protected void onPostExecute(ByteBuffer result) {
    
                synchronized (this) {
                    if(result != null && result.capacity() > 0) {
    Severity: Minor
    Found in src/main/java/org/benews/BackgroundSocket.java - About 1 hr to fix

      Function compile has 12 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          def compile(
      Severity: Major
      Found in src/libbson/boost/boost_1_53_0/tools/litre/cplusplus.py - About 1 hr to fix

        Function build_xsl_reports has 12 arguments (exceeds 4 allowed). Consider refactoring.
        Open

        def build_xsl_reports( 

          Function execute_tasks has 12 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          def execute_tasks(

            Function build_xsl_reports has 12 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            def build_xsl_reports( 

              Function publish_test_logs has 12 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              def publish_test_logs(

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

                def main_real():
                
                    global debug_config, legacy_ignore_config, out_xml
                
                    debug_config = "--debug-configuration" in sys.argv
                Severity: Minor
                Found in src/libbson/boost/boost_1_53_0/tools/build/v2/build_system.py - About 1 hr to fix

                  Method doInBackground has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
                  Open

                          @Override
                          protected ByteBuffer doInBackground(HashMap<String,String>... args) {
                              ByteBuffer wrapped = null;
                              byte obj[];
                              try {
                  Severity: Minor
                  Found in src/main/java/org/benews/BackgroundSocket.java - About 1 hr to fix

                  Cognitive Complexity

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

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

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

                  Further reading

                  Function glob_internal has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
                  Open

                      def glob_internal(self, project, wildcards, excludes, rule_name):
                          location = project.get("source-location")[0]
                  
                          result = []
                          callable = b2.util.path.__dict__[rule_name]
                  Severity: Minor
                  Found in src/libbson/boost/boost_1_53_0/tools/build/v2/build/project.py - About 1 hr to fix

                  Cognitive Complexity

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

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

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

                  Further reading

                  Severity
                  Category
                  Status
                  Source
                  Language