File git-p4.py has 3465 lines of code (exceeds 250 allowed). Consider refactoring.

Open

#!/usr/bin/env python
#
# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
#
# Author: Simon Hausmann <simon@lst.de>

Function applyCommit has a Cognitive Complexity of 160 (exceeds 5 allowed). Consider refactoring.

Open

    def applyCommit(self, id):
        """Apply one commit, return True if it succeeded."""

        print("Applying", read_pipe(["git", "show", "-s",
                                     "--format=format:%h %s", id]))

• Read up
  Read up

Function run has a Cognitive Complexity of 131 (exceeds 5 allowed). Consider refactoring.

Open

    def run(self, args):
        if len(args) == 0:
            self.master = currentGitBranch()
        elif len(args) == 1:
            self.master = args[0]

• Read up
  Read up

Function run has a Cognitive Complexity of 118 (exceeds 5 allowed). Consider refactoring.

Open

    def run(self, args):
        if self.importIntoRemotes:
            self.refPrefix = "refs/remotes/p4/"
        else:
            self.refPrefix = "refs/heads/p4/"

• Read up
  Read up

Function importChanges has a Cognitive Complexity of 86 (exceeds 5 allowed). Consider refactoring.

Open

    def importChanges(self, changes, origin_revision=0):
        cnt = 1
        for change in changes:
            description = p4_describe(change)
            self.updateOptionDict(description)

• Read up
  Read up

Function p4CmdList has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring.

Open

def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None, skip_info=False,
        errors_as_exceptions=False, *k, **kw):

    cmd = p4_build_cmd(["-G"] + cmd)
    if verbose:

• Read up
  Read up

Function importRevisions has a Cognitive Complexity of 49 (exceeds 5 allowed). Consider refactoring.

Open

    def importRevisions(self, args, branch_arg_given):
        changes = []

        if len(self.changesFile) > 0:
            with open(self.changesFile) as f:

• Read up
  Read up

Function metadata_stream_to_writable_bytes has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.

Open

def metadata_stream_to_writable_bytes(s):
    encodingStrategy = gitConfig('git-p4.metadataDecodingStrategy') or defaultMetadataDecodingStrategy
    fallbackEncoding = gitConfig('git-p4.metadataFallbackEncoding') or defaultFallbackMetadataEncoding
    if not isinstance(s, bytes):
        return s.encode('utf_8')

• Read up
  Read up

Function handleLine has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.

Open

function handleLine(commit, group) {
    /*
       This is the structure of the HTML fragment we are working
       with:

• Read up
  Read up

Function importP4Labels has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.

Open

    def importP4Labels(self, stream, p4Labels):
        """Import p4 labels as git tags. A direct mapping does not exist, so
           assume that if all the files are at the same revision then we can
           use that, or it's something more complicated we should just ignore.
           """

• Read up
  Read up

Function commit has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.

Open

    def commit(self, details, files, branch, parent="", allow_empty=False):
        epoch = details["time"]
        author = details["user"]
        jobs = self.extractJobsFromCommit(details)

• Read up
  Read up

Function exportGitTags has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.

Open

    def exportGitTags(self, gitTags):
        """Export git tags as p4 labels. Create a p4 label and then tag with
           that.
           """

• Read up
  Read up

Function p4ChangesForPaths has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

def p4ChangesForPaths(depotPaths, changeRange, requestedBlockSize):
    assert depotPaths

    # Parse the change range into start and end. Try to find integer
    # revision ranges as these can be broken up into blocks to avoid

• Read up
  Read up

Function getBranchMapping has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.

Open

    def getBranchMapping(self):
        lostAndFoundBranches = set()

        user = gitConfig("git-p4.branchUser")

• Read up
  Read up

P4Sync has 37 functions (exceeds 20 allowed). Consider refactoring.

Open

class P4Sync(Command, P4UserMap):

    def __init__(self):
        Command.__init__(self)
        P4UserMap.__init__(self)

File blame_incremental.js has 361 lines of code (exceeds 250 allowed). Consider refactoring.

Open

// Copyright (C) 2007, Fredrik Kuivinen <frekui@gmail.com>
//               2007, Petr Baudis <pasky@suse.cz>
//          2008-2011, Jakub Narebski <jnareb@gmail.com>

/**

Function streamP4FilesCb has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.

Open

    def streamP4FilesCb(self, marshalled):
        """Handle another chunk of streaming data."""

        # catch p4 errors and complain
        err = None

• Read up
  Read up

Function prepareSubmitTemplate has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.

Open

    def prepareSubmitTemplate(self, changelist=None):
        """Run "p4 change -o" to grab a change specification template.

           This does not use "p4 -G", as it is nice to keep the submission
           template in original order, since a human might edit it.

• Read up
  Read up

Function createOrUpdateBranchesFromOrigin has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

def createOrUpdateBranchesFromOrigin(localRefPrefix="refs/remotes/p4/", silent=True):
    if not silent:
        print("Creating/updating branch(es) in %s based on origin branch(es)"
               % localRefPrefix)

• Read up
  Read up

Function main has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.

Open

def main():
    if len(sys.argv[1:]) == 0:
        printUsage(commands.keys())
        sys.exit(2)

• Read up
  Read up