blob: e49d0923117b6592322e0389393d7f8bd34ca654 [file] [log] [blame]
#!/usr/bin/env python
#
# Copyright (C) 2022 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from sys import exit
from typing import List
from glob import glob
from pathlib import Path
from collections import defaultdict
from difflib import Differ
from re import split
from tqdm import tqdm
import argparse
DIFFER_CODE_LEN = 2
class DifferCodes:
COMMON = ' '
UNIQUE_FIRST = '- '
UNIQUE_SECOND = '+ '
DIFF_IDENT = '? '
class FilesDiffAnalyzer:
def __init__(self, args) -> None:
self.out_dir = args.out_dir
self.show_diff = args.show_diff
self.skip_words = args.skip_words
self.first_dir = args.first_dir
self.second_dir = args.second_dir
self.include_common = args.include_common
self.first_dir_files = self.get_files(self.first_dir)
self.second_dir_files = self.get_files(self.second_dir)
self.common_file_map = defaultdict(set)
self.map_common_files(self.first_dir_files, self.first_dir)
self.map_common_files(self.second_dir_files, self.second_dir)
def get_files(self, dir: str) -> List[str]:
"""Get all files directory in the input directory including the files in the subdirectories
Recursively finds all files in the input directory.
Returns a list of file directory strings, which do not include directories but only files.
List is sorted in alphabetical order of the file directories.
Args:
dir: Directory to get the files. String.
Returns:
A list of file directory strings within the input directory.
Sorted in Alphabetical order.
Raises:
FileNotFoundError: An error occurred accessing the non-existing directory
"""
if not dir_exists(dir):
raise FileNotFoundError("Directory does not exist")
if dir[:-2] != "**":
if dir[:-1] != "/":
dir += "/"
dir += "**"
return [file for file in sorted(glob(dir, recursive=True)) if Path(file).is_file()]
def map_common_files(self, files: List[str], dir: str) -> None:
for file in files:
file_name = file.split(dir, 1)[-1]
self.common_file_map[file_name].add(dir)
return
def compare_file_contents(self, first_file: str, second_file: str) -> List[str]:
"""Compare the contents of the files and return different lines
Given two file directory strings, compare the contents of the two files
and return the list of file contents string prepended with unique identifier codes.
The identifier codes include:
- ' '(two empty space characters): Line common to two files
- '- '(minus followed by a space) : Line unique to first file
- '+ '(plus followed by a space) : Line unique to second file
Args:
first_file: First file directory string to compare the content
second_file: Second file directory string to compare the content
Returns:
A list of the file content strings. For example:
[
" Foo",
"- Bar",
"+ Baz"
]
"""
d = Differ()
first_file_contents = sort_methods(get_file_contents(first_file))
second_file_contents = sort_methods(get_file_contents(second_file))
diff = list(d.compare(first_file_contents, second_file_contents))
ret = [f"diff {first_file} {second_file}"]
idx = 0
while idx < len(diff):
line = diff[idx]
line_code = line[:DIFFER_CODE_LEN]
match line_code:
case DifferCodes.COMMON:
if self.include_common:
ret.append(line)
case DifferCodes.UNIQUE_FIRST:
# Should compare line
if (idx < len(diff) - 1 and
(next_line_code := diff[idx + 1][:DIFFER_CODE_LEN])
not in (DifferCodes.UNIQUE_FIRST, DifferCodes.COMMON)):
delta = 1 if next_line_code == DifferCodes.UNIQUE_SECOND else 2
line_to_compare = diff[idx + delta]
if self.lines_differ(line, line_to_compare):
ret.extend([line, line_to_compare])
else:
if self.include_common:
ret.append(DifferCodes.COMMON +
line[DIFFER_CODE_LEN:])
idx += delta
else:
ret.append(line)
case DifferCodes.UNIQUE_SECOND:
ret.append(line)
case DifferCodes.DIFF_IDENT:
pass
idx += 1
return ret
def lines_differ(self, line1: str, line2: str) -> bool:
"""Check if the input lines are different or not
Compare the two lines word by word and check if the two lines are different or not.
If the different words in the comparing lines are included in skip_words,
the lines are not considered different.
Args:
line1: first line to compare
line2: second line to compare
Returns:
Boolean value indicating if the two lines are different or not
"""
# Split by '.' or ' '(whitespace)
def split_words(line: str) -> List[str]:
return split('\\s|\\.', line[DIFFER_CODE_LEN:])
line1_words, line2_words = split_words(line1), split_words(line2)
if len(line1_words) != len(line2_words):
return True
for word1, word2 in zip(line1_words, line2_words):
if word1 != word2:
# not check if words are equal to skip word, but
# check if words contain skip word as substring
if all(sw not in word1 and sw not in word2 for sw in self.skip_words):
return True
return False
def analyze(self) -> None:
"""Analyze file contents in both directories and write to output or console.
"""
for file in tqdm(sorted(self.common_file_map.keys())):
val = self.common_file_map[file]
# When file exists in both directories
lines = list()
if val == set([self.first_dir, self.second_dir]):
lines = self.compare_file_contents(
self.first_dir + file, self.second_dir + file)
else:
existing_dir, not_existing_dir = (
(self.first_dir, self.second_dir) if self.first_dir in val
else (self.second_dir, self.first_dir))
lines = [f"{not_existing_dir}{file} does not exist."]
if self.show_diff:
lines.append(f"Content of {existing_dir}{file}: \n")
lines.extend(get_file_contents(existing_dir + file))
self.write(lines)
def write(self, lines: List[str]) -> None:
if self.out_dir == "":
pprint(lines)
else:
write_lines(self.out_dir, lines)
###
# Helper functions
###
def sort_methods(lines: List[str]) -> List[str]:
"""Sort class methods in the file contents by alphabetical order
Given lines of Java file contents, return lines with class methods sorted in alphabetical order.
Also omit empty lines or lines with spaces.
For example:
l = [
"package android.test;",
"",
"public static final int ORANGE = 1;",
"",
"public class TestClass {",
"public TestClass() { throw new RuntimeException("Stub!"); }",
"public void foo() { throw new RuntimeException("Stub!"); }",
"public void bar() { throw new RuntimeException("Stub!"); }",
"}"
]
sort_methods(l) returns
[
"package android.test;",
"public static final int ORANGE = 1;",
"public class TestClass {",
"public TestClass() { throw new RuntimeException("Stub!"); }",
"public void bar() { throw new RuntimeException("Stub!"); }",
"public void foo() { throw new RuntimeException("Stub!"); }",
"}"
]
Args:
lines: List of strings consisted of Java file contents.
Returns:
A list of string with sorted class methods.
"""
def is_not_blank(l: str) -> bool:
return bool(l) and not l.isspace()
ret = list()
in_class = False
buffer = list()
for line in lines:
if not in_class:
if "class" in line:
in_class = True
ret.append(line)
else:
# Adding static variables, package info, etc.
# Skipping empty or space lines.
if is_not_blank(line):
ret.append(line)
else:
# End of class
if line and line[0] == "}":
in_class = False
ret.extend(sorted(buffer))
buffer = list()
ret.append(line)
else:
if is_not_blank(line):
buffer.append(line)
return ret
def get_file_contents(file_path: str) -> List[str]:
lines = list()
with open(file_path) as f:
lines = [line.rstrip('\n') for line in f]
f.close()
return lines
def pprint(l: List[str]) -> None:
for line in l:
print(line)
def write_lines(out_dir: str, lines: List[str]) -> None:
with open(out_dir, "a") as f:
f.writelines(line + '\n' for line in lines)
f.write("\n")
f.close()
def dir_exists(dir: str) -> bool:
return Path(dir).exists()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('first_dir', action='store', type=str,
help="first path to compare file directory and contents")
parser.add_argument('second_dir', action='store', type=str,
help="second path to compare file directory and contents")
parser.add_argument('--out', dest='out_dir',
action='store', default="", type=str,
help="optional directory to write log. If not set, will print to console")
parser.add_argument('--show-diff-file', dest='show_diff',
action=argparse.BooleanOptionalAction,
help="optional flag. If passed, will print out the content of the file unique to each directories")
parser.add_argument('--include-common', dest='include_common',
action=argparse.BooleanOptionalAction,
help="optional flag. If passed, will print out the contents common to both files as well,\
instead of printing only diff lines.")
parser.add_argument('--skip-words', nargs='+',
dest='skip_words', default=[], help="optional words to skip in comparison")
args = parser.parse_args()
if not args.first_dir or not args.second_dir:
parser.print_usage()
exit(0)
analyzer = FilesDiffAnalyzer(args)
analyzer.analyze()