/// <summary>
/// Takes either a file directory or a filename and optional variables and initiates a scan for duplicate code.
/// </summary>
/// <param name="filepath">the name of the directory to scan</param>
/// <param name="verbose">(optinoal) the verbosity of the output. True = verbose, False = normal</param>
public static List <DuplicateInstance> CheckForDuplicates(string filepath, ICodeComparer comparer, bool verbose = false)
{
if (verbose)
{
Logger.Log("Beginning execution of CheckForDuplicates");
}
if (string.IsNullOrWhiteSpace(filepath))
{
throw new ArgumentNullException("Either a filename or a directory must be provided.");
}
var results = new List <DuplicateInstance>();
var cmcdResults = Run(filepath, comparer);
foreach (var result in cmcdResults)
{
// Decide if we rule this a duplicate
if (result.Score < 50)
{
// Method A
results.Add(new DuplicateInstance(result.MethodA));
// Method B
results.Add(new DuplicateInstance(result.MethodB));
}
}
if (verbose)
{
Logger.Log("Finishing execution of CheckForDuplicates");
}
return(results);
}
public GameController(ICodeCreator builder, ICodeComparer comparer, IGuessTranslator trans, IGameIO consoleIO)
{
_guessTranslate = trans;
_codeComparer = comparer;
_builder = builder;
_consoleIO = consoleIO;
_guesses = new List <List <int> >();
_feedbacks = new List <string>();
}
/// <summary>
/// Method to run the CMCD algorithm
/// </summary>
/// <param name="filepath">The directory to operate in</param>
/// <param name="comparer">The code comparer</param>
public static List <DuplicateResult> Run(string filepath, ICodeComparer comparer)
{
var comparisonResults = new List <DuplicateResult>();
try
{
var allMethods = new List <Method>();
var attr = File.GetAttributes(filepath);
var files = attr.HasFlag(FileAttributes.Directory) ? Directory.GetFiles(filepath, "*.cs", SearchOption.AllDirectories).ToList() : new List <string>()
{
filepath
};
foreach (var file in files)
{
var methods = GetMethods(file).Select(c =>
new Method()
{
FilePath = Path.GetFullPath(file),
FileName = Path.GetFileName(file),
MethodNode = c
});
allMethods.AddRange(methods);
}
for (int i = 0; i < allMethods.Count; i++)
{
for (int j = i + 1; j < allMethods.Count; j++)
{
try
{
var methodA = allMethods[i];
var methodB = allMethods[j];
var compareResult = comparer.Compare(methodA, methodB);
comparisonResults.Add(new DuplicateResult()
{
MethodA = new MethodInfo(methodA),
MethodB = new MethodInfo(methodB),
Score = compareResult
});
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
return(comparisonResults);
}
public AbstractComparer(T sourceElement, T targetElement, ICodeComparer parent)
{
if (sourceElement.GetType() != targetElement.GetType())
{
throw new CodeCompareException(string.Format("Cannot compare {0} with {1}.", sourceElement, targetElement));
}
SourceElementDefinition = sourceElement;
TargetElementDefinition = targetElement;
Differences = new List <ICodeDifference>();
DescendantComparers = new List <ICodeComparer>();
Parent = parent;
Compare();
}
public CodeFileComparer(CodeFile sourceCodeFile, CodeFile targetCodeFile, ICodeComparer parent) :
base(sourceCodeFile, targetCodeFile, parent)
{
}
public ParameterComparer(DeclaredParameter sourceParameter, DeclaredParameter targetParameter, ICodeComparer parent) :
base(sourceParameter, targetParameter, parent)
{
}
public NamespaceComparer(NamespaceDefinition sourceNamespace, NamespaceDefinition targetNamespace, ICodeComparer parent) :
base(sourceNamespace, targetNamespace, parent)
{
}
public AttributeComparer(DeclaredAttribute sourceAttribute, DeclaredAttribute targetAttribute, ICodeComparer parent) :
base(sourceAttribute, targetAttribute, parent)
{
}
public FieldComparer(FieldDefinition sourceFieldDefinition, FieldDefinition targetFieldDefinition, ICodeComparer parent) :
base(sourceFieldDefinition, targetFieldDefinition, parent)
{
}
public MethodComparer(MethodDefinition sourceMethod, MethodDefinition targetMethod, ICodeComparer parent) :
base(sourceMethod, targetMethod, parent)
{
}
public ElementComparer(TElement sourceElement, TElement targetElement, ICodeComparer parent) : base(sourceElement, targetElement, parent)
{
}
public MemberComparer(TMember sourceMember, TMember targetMember, ICodeComparer parent) : base(sourceMember, targetMember, parent)
{
}
public PropertyComparer(PropertyDefinition sourceProperty, PropertyDefinition targetProperty, ICodeComparer parent) :
base(sourceProperty, targetProperty, parent)
{
}
public TypeComparer(TypeDefinition sourceType, TypeDefinition targetType, ICodeComparer parent) :
base(sourceType, targetType, parent)
{
}
