def main():
from optparse import OptionParser
parser = OptionParser(usage='./cc.py command [options] *.py')
parser.add_option('-v', '--verbose',
dest='verbose', action='store_true', default=False,
help='print detailed statistics to stdout')
parser = CommandParser(parser, COMMANDS)
command, options, args = parser.parse_args()
items = set()
for arg in args:
if os.path.isdir(arg):
for f in glob(os.path.join(arg, '*.py')):
if os.path.isfile(f):
items.add(os.path.abspath(f))
elif os.path.isfile(arg):
items.add(os.path.abspath(arg))
else:
# this should be a package'
items.add(find_module(arg))
for item in items:
code = open(item).read()
if command in ('all', 'complexity'):
stats = cc.measure_complexity(code, item)
pp = cc.PrettyPrinter(sys.stdout, verbose=options.verbose)
pp.pprint(item, stats)
def main():
from optparse import OptionParser
parser = OptionParser(usage='./cc.py command [options] *.py')
parser.add_option('-v',
'--verbose',
dest='verbose',
action='store_true',
default=False,
help='print detailed statistics to stdout')
parser = CommandParser(parser, COMMANDS)
command, options, args = parser.parse_args()
items = set()
for arg in args:
if os.path.isdir(arg):
for f in glob(os.path.join(arg, '*.py')):
if os.path.isfile(f):
items.add(os.path.abspath(f))
elif os.path.isfile(arg):
items.add(os.path.abspath(arg))
else:
# this should be a package'
items.add(find_module(arg))
for item in items:
code = open(item).read()
if command in ('all', 'complexity'):
stats = cc.measure_complexity(code, item)
pp = cc.PrettyPrinter(sys.stdout, verbose=options.verbose)
pp.pprint(item, stats)
def test_empty_def():
code = dedent("""
def f():
pass
""")
stats = measure_complexity(code).flatStats
assert stats.complexity == 1
assert stats.functions[0].complexity == 1
def test_empty_def():
code = dedent("""
def f():
pass
""")
stats = measure_complexity(code)
assert stats.complexity == 1
assert stats.functions[0].complexity == 1
def test_module():
code = dedent('''
if True:
pass
else:
pass
''')
stats = measure_complexity(code)
assert stats.name == '<module>'
assert stats.classes == []
assert stats.functions == []
assert stats.complexity == 2
def test_module():
code = dedent('''
if True:
pass
else:
pass
''')
stats = measure_complexity(code).flatStats
assert stats.name == '<module>'
assert stats.classes == []
assert stats.functions == []
assert stats.complexity == 2
def test_class():
code = dedent('''
class A:
if True:
pass
def f(self):
if False:
pass
''')
stats = measure_complexity(code).flatStats
assert stats.name == '<module>'
assert stats.classes[0].name == 'A'
assert stats.classes[0].complexity == 2
def test_class():
code = dedent('''
class A:
if True:
pass
def f(self):
if False:
pass
''')
stats = measure_complexity(code)
assert stats.name == '<module>'
assert stats.classes[0].name == 'A'
assert stats.classes[0].complexity == 2
def test_def():
code = dedent('''
def f(a, b, c):
if a:
pass
else:
pass
''')
stats = measure_complexity(code)
assert stats.classes == []
assert len(stats.functions) == 1
assert stats.functions[0].name == 'f'
assert stats.functions[0].complexity == 2
def test_lambdas():
code = dedent('''
incr = lambda x: x + 1
decr = lambda x: x - 1
def f():
incr = lambda x: x + 1
decr = lambda x: x - 1
''')
stats = measure_complexity(code).flatStats
incr, decr, f = stats.functions
assert incr.complexity == 1
assert decr.complexity == 1
def test_lambdas():
code = dedent('''
incr = lambda x: x + 1
decr = lambda x: x - 1
def f():
incr = lambda x: x + 1
decr = lambda x: x - 1
''')
stats = measure_complexity(code)
incr, decr, f = stats.functions
assert incr.complexity == 1
assert decr.complexity == 1
def test_def():
code = dedent('''
def f(a, b, c):
if a:
pass
else:
pass
''')
stats = measure_complexity(code).flatStats
assert stats.classes == []
assert len(stats.functions) == 1
assert stats.functions[0].name == 'f'
assert stats.functions[0].complexity == 2
def test_nested_classes():
code = dedent('''
class A:
if True:
pass
class Inner:
if False:
pass
''')
stats = measure_complexity(code).flatStats
assert stats.classes[0].name == 'A'
assert stats.classes[0].complexity == 2
assert stats.classes[0].classes[0].name == 'Inner'
assert stats.classes[0].classes[0].complexity == 2
def test_nested_classes():
code = dedent('''
class A:
if True:
pass
class Inner:
if False:
pass
''')
stats = measure_complexity(code)
assert stats.classes[0].name == 'A'
assert stats.classes[0].complexity == 2
assert stats.classes[0].classes[0].name == 'Inner'
assert stats.classes[0].classes[0].complexity == 2
def test_loops():
code = dedent('''
def f(a):
while a < 10:
print a
def g(a):
for x in range(a):
print a
def h(a):
while a < 10:
for x in range(a):
if x % 2:
print 'odd'
''')
stats = measure_complexity(code)
f, g, h = stats.functions
assert f.complexity == 2
assert g.complexity == 2
assert h.complexity == 4
def test_loops():
code = dedent('''
def f(a):
while a < 10:
print a
def g(a):
for x in range(a):
print a
def h(a):
while a < 10:
for x in range(a):
if x % 2:
print 'odd'
''')
stats = measure_complexity(code).flatStats
f, g, h = stats.functions
assert f.complexity == 2
assert g.complexity == 2
assert h.complexity == 4
def cc(filename):
# Radon complexity method only applies to programs containing classes or functions.
# Using another API to other cases.
program = open(filename, 'r')
code = program.read()
try:
# Use radon
visitor = cc_visit(code)
if len(visitor) <= 0:
# Doesn't have functions or classes.
# Use cc.py
stats = measure_complexity(code)
cc = stats.complexity
else:
cc = 0
for i in range( len(visitor) ):
cc += visitor[i].complexity
except Exception as e:
# Failed
print("qcheck: unable to get cc")
cc = 0
program.close()
return cc
def main():
options, args = parse_cmd_args()
files = FileList(args, options.recurs).files
outFile = sys.stdout
fail = set()
if options.outFile:
outFile = open(options.outFile, 'w')
pp = cc.PrettyPrinter(outFile, options.complexity,
options.threshold, options.summary)
sumStats = cc.FlatStats()
for f in files:
if options.debug:
print "File being processed: ", f
code = open(f).read() + '\n'
stats = cc.measure_complexity(code, f)
if not stats:
fail.add(f)
continue
sumStats = sumStats + stats
pp.pprint(f, stats)
outFile.write("Total Cumulative Statistics\n")
outFile.write(str(sumStats))
outFile.write('\n')
print_fail_files(fail, outFile)
def _assert(expected_complexity, code):
stats = measure_complexity(code)
print stats.complexity, expected_complexity
assert stats.complexity == expected_complexity
def complexity(self):
return cc.measure_complexity("".join(["".join(line[1]) for line in self.lines])).functions[0].complexity
def _assert(expected_complexity, code):
stats = measure_complexity(code).flatStats
print stats.complexity, expected_complexity
assert stats.complexity == expected_complexity
