mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-26 01:06:28 +08:00
165 lines
5.6 KiB
Python
165 lines
5.6 KiB
Python
"""
|
|
File: extract_code_python.py
|
|
Created Time: 2023-02-07
|
|
Author: Krahets (krahets@163.com)
|
|
"""
|
|
|
|
import re
|
|
import glob
|
|
import sys, os.path as osp
|
|
sys.path.append(osp.dirname(osp.dirname(osp.dirname(osp.abspath(__file__)))))
|
|
|
|
|
|
class ExtractCodeBlocksJava:
|
|
def __init__(self) -> None:
|
|
self.ind = 4
|
|
|
|
# Pattern to match function names and class names
|
|
self.func_pattern = r'(\s*)(public|private|)\s*(static|)\s*(\S+)\s+(\w+)(\(.*\))\s+\{'
|
|
self.class_pattern = r'(public|)\s*class\s+(\w+)\s*\{'
|
|
|
|
self.func_pattern_keys = ["total", "ind", "scope", "static", "return", "label", "args"]
|
|
self.class_pattern_keys = ["total", "scope", "label"]
|
|
|
|
# Pattern to match the start and end of a block
|
|
self.block_end_pattern = '^\s{ind}\}'
|
|
self.block_start_pattern = '^\s{ind}\/\*.+\*\/'
|
|
self.block_start_shift = 0
|
|
self.block_end_shift = 0
|
|
|
|
def extract(self, file_path):
|
|
"""
|
|
Extract classes and functions from a markdown document
|
|
"""
|
|
self.file_path = file_path
|
|
with open(file_path) as f:
|
|
self.lines = f.readlines()
|
|
self.content = "".join(self.lines)
|
|
|
|
# Detect and extract all the classes and fucntions
|
|
classes = self.extract_class_blocks()
|
|
funcs = self.extract_function_blocks()
|
|
|
|
self.post_process(classes, funcs)
|
|
|
|
return {
|
|
"classes": classes,
|
|
"funcs": funcs,
|
|
}
|
|
|
|
def search_block(self, header_line, indentation):
|
|
"""
|
|
Search class/function block given the header_line and indentation
|
|
"""
|
|
start_line, end_line = 0, len(self.lines)
|
|
|
|
block_end_pattern = re.compile(
|
|
self.block_end_pattern.replace("ind", str(indentation)))
|
|
block_start_pattern = re.compile(
|
|
self.block_start_pattern.replace("ind", str(indentation)))
|
|
|
|
# Search the code
|
|
for i in range(header_line + 1, len(self.lines)):
|
|
if re.match(block_end_pattern, self.lines[i]) is not None:
|
|
end_line = i + self.block_end_shift
|
|
break
|
|
# Search the header comment
|
|
for i in range(header_line - 1, -1, -1):
|
|
if re.search(block_start_pattern, self.lines[i]) is not None:
|
|
start_line = i + self.block_start_shift
|
|
break
|
|
|
|
return start_line, end_line, self.lines[start_line:end_line + 1]
|
|
|
|
def extract_function_blocks(self, indentation=0, start_line=-1, end_line=-1):
|
|
"""
|
|
Extract all the functions with given indentation
|
|
"""
|
|
funcs = {}
|
|
|
|
if start_line == -1:
|
|
start_line = 0
|
|
if end_line == -1:
|
|
end_line = len(self.lines) - 1
|
|
|
|
func_pattern = re.compile(self.func_pattern)
|
|
|
|
for line_num in range(start_line, end_line + 1):
|
|
# Search the function header
|
|
func_match = func_pattern.match(self.lines[line_num])
|
|
if func_match is None:
|
|
continue
|
|
# The function should match the input indentation
|
|
if len(func_match.group(self.func_pattern_keys.index("ind"))) != indentation:
|
|
continue
|
|
header_line = line_num
|
|
|
|
# Search the block from the header line
|
|
start_line, end_line, func_block = self.search_block(
|
|
header_line, indentation)
|
|
# Construct the funcs dict
|
|
func_label = func_match.group(self.func_pattern_keys.index("label"))
|
|
funcs[func_label] = {
|
|
"indentation": indentation,
|
|
"line_number": {
|
|
"start": start_line,
|
|
"end": end_line,
|
|
"header": header_line,
|
|
},
|
|
"block": func_block,
|
|
}
|
|
|
|
return funcs
|
|
|
|
def extract_class_blocks(self):
|
|
"""
|
|
Extract all the classes with given indentation
|
|
"""
|
|
classes = {}
|
|
|
|
class_pattern = re.compile(self.class_pattern)
|
|
|
|
for line_num, line in enumerate(self.lines):
|
|
# Search the class header
|
|
class_match = class_pattern.match(line)
|
|
if class_match is None:
|
|
continue
|
|
header_line = line_num
|
|
|
|
# Search the block from the header line
|
|
start_line, end_line, class_block = self.search_block(
|
|
header_line, 0)
|
|
# Construct the classes dict
|
|
class_label = class_match.group(self.class_pattern_keys.index("label"))
|
|
classes[class_label] = {
|
|
"indentation": 0,
|
|
"line_number": {
|
|
"start": start_line,
|
|
"end": end_line,
|
|
"header": header_line,
|
|
},
|
|
"block": class_block,
|
|
"funcs": self.extract_function_blocks(
|
|
indentation=self.ind, start_line=start_line, end_line=end_line)
|
|
}
|
|
|
|
return classes
|
|
|
|
def post_process(self, classes, funcs):
|
|
"""
|
|
Process the classes and functions
|
|
"""
|
|
def remove_keyword(func):
|
|
block = func["block"]
|
|
header_line = func["line_number"]["header"] - \
|
|
func["line_number"]["start"]
|
|
block[header_line] = block[header_line] \
|
|
.replace("static ", "").replace("public ", "").replace("private ", "")
|
|
for clas in classes.values():
|
|
for func in clas["funcs"].values():
|
|
remove_keyword(func)
|
|
for func in funcs.values():
|
|
remove_keyword(func)
|
|
|
|
# ext = ExtractCodeBlocksJava()
|
|
# ext.extract("codes/java/chapter_array_and_linkedlist/my_list.java")
|