repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
repositoryminer
|
repositoryminer-master/repositoryminer-core/src/main/java/org/repositoryminer/scm/ISCM.java
|
package org.repositoryminer.scm;
import java.util.List;
import java.util.Set;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.domain.Reference;
import org.repositoryminer.domain.SCMType;
/**
* Interface that define what is needed to support a repository.
*/
public interface ISCM {
/**
* @return The supported version control system type.
*/
public SCMType getSCM();
/**
* Prepare the repository to analysis.
*
* @param path
* the repository path.
*/
public void open(String path);
/**
* @return all references (e.g. tags and branches).
*/
public List<Reference> getReferences();
/**
* Returns all the commits by a limited set of them per turn.
*
* @param skip
* how much commits should be skipped.
* @param max
* max number of fetched commits.
* @return a set of commits;
*/
public List<Commit> getCommits(int skip, int max);
/**
* Returns the commits with hash in the given list of hashes.
*
* @param selectedCommits
* a list of commits hashes.
* @return a set of selected commits
*/
public List<Commit> getCommits(Set<String> selectedCommits);
/**
* Gets the commit which the HEAD is pointed at.
* <p>
* <b>Note: For now, only these commit attributes need to be set: hash and
* committer date.</b>
*
* @return the commit of the current HEAD location.
*/
public Commit getHEAD();
/**
* Converts a reference to a commit to a commit object.
* <p>
* <b>Note: For now, only these commit attributes need to be set: hash and
* committer date.</b>
*
* @return the referenced commit.
*/
public Commit resolve(String reference);
/**
* @param reference
* the reference.
* @return the hashes of commits associated to a reference.
*/
public List<String> getCommitsNames(Reference reference);
/**
* @return the hashes of all commits.
*/
public List<String> getCommitsNames();
/**
* Does a checkout to a given point.
*
* @param point
* the checkout point.
*/
public void checkout(String point);
/**
* Terminates the analysis and free resources.
*/
public void close();
}
| 2,191
| 21.141414
| 75
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-core/src/main/java/org/repositoryminer/scm/GitSCM.java
|
package org.repositoryminer.scm;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.LogCommand;
import org.eclipse.jgit.api.ResetCommand.ResetType;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.diff.RawTextComparator;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.RevisionSyntaxException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
import org.eclipse.jgit.util.io.DisabledOutputStream;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.domain.Change;
import org.repositoryminer.domain.ChangeType;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.domain.Developer;
import org.repositoryminer.domain.Reference;
import org.repositoryminer.domain.ReferenceType;
import org.repositoryminer.domain.SCMType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Implements support for Git repositories.
*/
public class GitSCM implements ISCM {
private static final Logger LOG = LoggerFactory.getLogger(GitSCM.class);
private Git git;
private int branchCounter = 0;
@Override
public SCMType getSCM() {
return SCMType.GIT;
}
@Override
public void open(String path) {
LOG.info("Repository being opened.");
FileRepositoryBuilder repositoryBuilder = new FileRepositoryBuilder();
File repoFolder = new File(path, ".git");
if (!repoFolder.exists()) {
throw new RepositoryMinerException("Repository not found.");
}
try {
Repository repository = repositoryBuilder.setGitDir(repoFolder).readEnvironment().findGitDir().build();
git = new Git(repository);
} catch (IOException e) {
throw new RepositoryMinerException(e);
}
}
@Override
public List<Reference> getReferences() {
LOG.info("Extracting references.");
List<Reference> refs = new ArrayList<Reference>();
Iterable<Ref> branches = null;
try {
branches = git.branchList().call();
} catch (GitAPIException e) {
close();
throw new RepositoryMinerException(e);
}
for (Ref b : branches) {
if (b.getName().equals("HEAD")) {
continue;
}
int i = b.getName().lastIndexOf("/") + 1;
Commit commit = resolve(b.getName());
Reference r = new Reference(null, null, b.getName().substring(i), b.getName(), ReferenceType.BRANCH,
commit.getCommitterDate(), null);
refs.add(r);
LOG.info(String.format("Branch %s analyzed.", r.getName()));
}
Iterable<Ref> tags = null;
try {
tags = git.tagList().call();
} catch (GitAPIException e) {
close();
throw new RepositoryMinerException(e);
}
for (Ref t : tags) {
int i = t.getName().lastIndexOf("/") + 1;
Commit commit = resolve(t.getName());
Reference r = new Reference(null, null, t.getName().substring(i), t.getName(), ReferenceType.TAG,
commit.getCommitterDate(), null);
refs.add(r);
LOG.info(String.format("Tag %s analyzed.", r.getName()));
}
return refs;
}
@Override
public List<Commit> getCommits(int skip, int max) {
LOG.info("Extracting commits.");
List<Commit> commits = new ArrayList<Commit>();
try {
for (RevCommit revCommit : git.log().all().setSkip(skip).setMaxCount(max).call()) {
LOG.info(String.format("Analyzing commit %s.", revCommit.getName()));
commits.add(processCommit(revCommit));
}
} catch (GitAPIException | IOException e) {
close();
throw new RepositoryMinerException(e);
}
return commits;
}
@Override
public List<Commit> getCommits(Set<String> selectedCommits) {
LOG.info("Extracting commits.");
List<Commit> commits = new ArrayList<Commit>();
try {
for (RevCommit revCommit : git.log().all().call()) {
if (selectedCommits.contains(revCommit.getName())) {
LOG.info(String.format("Analyzing commit %s.", revCommit.getName()));
commits.add(processCommit(revCommit));
}
}
} catch (GitAPIException | IOException e) {
close();
throw new RepositoryMinerException(e);
}
return commits;
}
@Override
public Commit getHEAD() {
return resolve(Constants.HEAD);
}
@Override
public Commit resolve(String reference) {
RevWalk revWalk = null;
try {
ObjectId ref = git.getRepository().resolve(reference);
revWalk = new RevWalk(git.getRepository());
RevCommit revCommit = revWalk.parseCommit(ref);
return new Commit(revCommit.getName(), revCommit.getCommitterIdent().getWhen());
} catch (RevisionSyntaxException | IOException e) {
throw new RepositoryMinerException("Error getting the commit from " + reference + ".", e);
} finally {
if (revWalk != null) {
revWalk.close();
}
}
}
@Override
public List<String> getCommitsNames(Reference reference) {
LOG.info(String.format("Extracting the commits names from reference %s.", reference.getName()));
Iterable<RevCommit> revCommits;
if (reference.getType() == ReferenceType.BRANCH) {
revCommits = getCommitsFromBranch(reference.getName());
} else {
revCommits = getCommitsFromTag(reference.getName());
}
if (revCommits == null) {
return new ArrayList<String>();
}
List<String> names = new ArrayList<String>();
for (RevCommit revCommit : revCommits) {
names.add(revCommit.getName());
}
return names;
}
@Override
public List<String> getCommitsNames() {
LOG.info(String.format("Extracting the commits names"));
List<String> names = new ArrayList<String>();
try {
for (RevCommit revCommit : git.log().all().call()) {
names.add(revCommit.getName());
}
} catch (GitAPIException | IOException e) {
close();
throw new RepositoryMinerException(e);
}
return names;
}
@Override
public void checkout(String hash) {
LOG.info(String.format("Checking out %s.", hash));
File lockFile = new File(git.getRepository().getDirectory(), "git/index.lock");
if (lockFile.exists()) {
lockFile.delete();
}
try {
git.reset().setMode(ResetType.HARD).call();
git.checkout().setName("master").call();
git.checkout().setCreateBranch(true).setName("rm_branch" + branchCounter++).setStartPoint(hash)
.setForce(true).setOrphan(true).call();
} catch (GitAPIException e) {
close();
throw new RepositoryMinerException(e);
}
}
@Override
public void close() {
LOG.info("Repository being closed.");
git.getRepository().close();
git.close();
}
private Commit processCommit(RevCommit revCommit) {
PersonIdent author = revCommit.getAuthorIdent();
PersonIdent committer = revCommit.getCommitterIdent();
Developer myAuthor = new Developer(author.getName(), author.getEmailAddress());
Developer myCommitter = new Developer(committer.getName(), committer.getEmailAddress());
List<String> parents = new ArrayList<String>();
for (RevCommit parent : revCommit.getParents()) {
parents.add(parent.getName());
}
List<Change> changes = null;
try {
changes = getChangesForCommitedFiles(revCommit.getName());
} catch (IOException e) {
close();
throw new RepositoryMinerException(e);
}
return new Commit(null, revCommit.getName(), myAuthor, myCommitter, revCommit.getFullMessage().trim(), changes,
parents, author.getWhen(), committer.getWhen(), (parents.size() > 1), null);
}
private List<Change> getChangesForCommitedFiles(String hash) throws IOException {
RevWalk revWalk = new RevWalk(git.getRepository());
RevCommit commit = revWalk.parseCommit(ObjectId.fromString(hash));
if (commit.getParentCount() > 1) {
revWalk.close();
return new ArrayList<Change>();
}
RevCommit parentCommit = commit.getParentCount() > 0
? revWalk.parseCommit(ObjectId.fromString(commit.getParent(0).getName()))
: null;
DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);
df.setBinaryFileThreshold(2048);
df.setRepository(git.getRepository());
df.setDiffComparator(RawTextComparator.DEFAULT);
df.setDetectRenames(true);
List<DiffEntry> diffEntries = df.scan(parentCommit, commit);
df.close();
revWalk.close();
List<Change> changes = new ArrayList<Change>();
for (DiffEntry entry : diffEntries) {
Change change = new Change(entry.getNewPath(), entry.getOldPath(), 0, 0,
ChangeType.valueOf(entry.getChangeType().name()));
analyzeDiff(change, entry);
changes.add(change);
}
return changes;
}
private void analyzeDiff(Change change, DiffEntry diff) throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
DiffFormatter df = new DiffFormatter(output);
df.setRepository(git.getRepository());
df.format(diff);
Scanner scanner = new Scanner(output.toString("UTF-8"));
int added = 0;
int removed = 0;
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
if (line.startsWith("+") && !line.startsWith("+++")) {
added++;
} else if (line.startsWith("-") && !line.startsWith("---")) {
removed++;
}
}
output.close();
df.close();
scanner.close();
change.setLinesAdded(added);
change.setLinesRemoved(removed);
}
private Iterable<RevCommit> getCommitsFromTag(String refName) {
try {
List<Ref> call = git.tagList().call();
for (Ref ref : call) {
if (ref.getName().endsWith(refName)) {
LogCommand log = git.log();
Ref peeledRef = git.getRepository().peel(ref);
if (peeledRef.getPeeledObjectId() != null) {
return log.add(peeledRef.getPeeledObjectId()).call();
} else {
return log.add(ref.getObjectId()).call();
}
}
}
return null;
} catch (GitAPIException | IncorrectObjectTypeException | MissingObjectException e) {
close();
throw new RepositoryMinerException(e);
}
}
private Iterable<RevCommit> getCommitsFromBranch(String refName) {
try {
return git.log().add(git.getRepository().resolve(refName)).call();
} catch (RevisionSyntaxException | GitAPIException | IOException e) {
close();
throw new RepositoryMinerException(e);
}
}
}
| 10,455
| 27.336043
| 113
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-core/src/main/java/org/repositoryminer/scm/SCMFactory.java
|
package org.repositoryminer.scm;
import org.repositoryminer.domain.SCMType;
/**
* Factory class for ISCM.
*/
public class SCMFactory {
public static ISCM getSCM(SCMType type) {
switch (type) {
case GIT:
return new GitSCM();
default:
return null;
}
}
}
| 273
| 13.421053
| 42
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/RepositoryMinerTechnicalDebt.java
|
package org.repositoryminer.technicaldebt;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.plugin.MiningPlugin;
import org.repositoryminer.scm.ISCM;
import org.repositoryminer.scm.SCMFactory;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
import org.repositoryminer.technicaldebt.model.TDType;
import org.repositoryminer.technicaldebt.persistence.TechnicalDebtDAO;
import org.repositoryminer.technicaldebt.persistence.TechnicalDebtReportDAO;
import com.mongodb.client.model.Projections;
public class RepositoryMinerTechnicalDebt extends MiningPlugin<RMTDConfig>{
public RepositoryMinerTechnicalDebt(String repositoryKey) {
super(repositoryKey);
}
@Override
public void mine(RMTDConfig config) {
if (config == null || !config.isValid()) {
throw new RepositoryMinerException("Invalid configuration, select at least one indicator and a reference.");
}
ISCM scm = SCMFactory.getSCM(repository.getScm());
scm.open(repository.getPath());
Commit commit = scm.resolve(config.getReference());
scm.close();
checkDuplicatedAnalysis(commit.getHash());
ObjectId reportId = persistAnalysisReport(config.getReference(), commit, config.getIndicators());
Collection<TDItem> items = new TDFinder().find(commit.getHash(), config.getIndicators());
List<Document> documents = new ArrayList<>(items.size());
for (TDItem item : items) {
if (item.isDebt()) {
Document doc = new Document("analysis_report", reportId);
doc.append("reference", config.getReference()).
append("commit", commit.getHash()).
append("commit_date", commit.getCommitterDate()).
append("repository", repository.getId()).
append("checked", false).
append("intentional", 0);
doc.putAll(item.toDocument());
documents.add(doc);
}
}
new TechnicalDebtDAO().insertMany(documents);
}
private ObjectId persistAnalysisReport(String reference, Commit commit, Set<TDIndicator> indicators) {
TechnicalDebtReportDAO configDao = new TechnicalDebtReportDAO();
List<String> indicatorsList = new ArrayList<String>();
for (TDIndicator indicator : indicators) {
indicatorsList.add(indicator.name());
}
Set<String> typesList = new HashSet<String>();
for (TDIndicator indicator : indicators) {
for (TDType type : indicator.getTypes()) {
typesList.add(type.name());
}
}
Document doc = new Document();
doc.append("reference", reference)
.append("commit", commit.getHash())
.append("commit_date", commit.getCommitterDate())
.append("analysis_date", new Date(System.currentTimeMillis()))
.append("repository", repository.getId())
.append("indicators", indicatorsList)
.append("types", typesList);
configDao.insert(doc);
return doc.getObjectId("_id");
}
private void checkDuplicatedAnalysis(String hash) {
TechnicalDebtReportDAO configDao = new TechnicalDebtReportDAO();
Document doc = configDao.findByCommitHash(hash, Projections.include("_id"));
if (doc != null) {
configDao.deleteById(doc.getObjectId("_id"));
new TechnicalDebtDAO().deleteByReport(doc.getObjectId("_id"));
}
}
}
| 3,887
| 36.028571
| 111
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/RMTDConfig.java
|
package org.repositoryminer.technicaldebt;
import java.util.Set;
import org.repositoryminer.technicaldebt.model.TDIndicator;
public class RMTDConfig {
private String reference;
private Set<TDIndicator> indicators;
public RMTDConfig(String reference, Set<TDIndicator> indicators) {
this.reference = reference;
this.indicators = indicators;
}
public String getReference() {
return reference;
}
public void setReference(String reference) {
this.reference = reference;
}
public Set<TDIndicator> getIndicators() {
return indicators;
}
public void setIndicators(Set<TDIndicator> indicators) {
this.indicators = indicators;
}
public boolean isValid() {
return (reference != null && reference.length() > 0) && (indicators != null && indicators.size() > 0);
}
}
| 797
| 20
| 104
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/TDFinder.java
|
package org.repositoryminer.technicaldebt;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.repositoryminer.technicaldebt.checker.CPDChecker;
import org.repositoryminer.technicaldebt.checker.CheckStyleChecker;
import org.repositoryminer.technicaldebt.checker.Checker;
import org.repositoryminer.technicaldebt.checker.CodeSmellsChecker;
import org.repositoryminer.technicaldebt.checker.ExCommentChecker;
import org.repositoryminer.technicaldebt.checker.FindBugsCheker;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
public class TDFinder {
private Set<TDIndicator> tdFilter;
private Checker[] checkers = {
new CheckStyleChecker(),
new CodeSmellsChecker(),
new CPDChecker(),
new ExCommentChecker(),
new FindBugsCheker()
};
public Collection<TDItem> find(String commit, Set<TDIndicator> tdFilter) {
this.tdFilter = tdFilter;
Map<String, TDItem> tdItems = new HashMap<String, TDItem>();
for (Checker c : checkers) {
if (hasAtLeastOneIndicator(c.getIndicators())) {
c.setTDFilter(tdFilter);
c.setTDItems(tdItems);
c.check(commit);
}
}
return tdItems.values();
}
/*
* Checks if the TD indicators filter has at lest one of the indicators passed
* as parameter.
*/
private boolean hasAtLeastOneIndicator(List<TDIndicator> indicators) {
boolean result = false;
for (TDIndicator i : indicators) {
if (tdFilter.contains(i)) {
result = true;
break;
}
}
return result;
}
}
| 1,607
| 25.360656
| 79
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/checker/CodeSmellsChecker.java
|
package org.repositoryminer.technicaldebt.checker;
import static org.repositoryminer.technicaldebt.model.TDIndicator.BRAIN_METHOD;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMPLEX_METHOD;
import static org.repositoryminer.technicaldebt.model.TDIndicator.DATA_CLASS;
import static org.repositoryminer.technicaldebt.model.TDIndicator.FEATURE_ENVY;
import static org.repositoryminer.technicaldebt.model.TDIndicator.GOD_CLASS;
import java.util.Arrays;
import java.util.List;
import org.bson.Document;
import org.repositoryminer.metrics.persistence.CodeAnalysisDAO;
import org.repositoryminer.metrics.persistence.CodeAnalysisReportDAO;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
import com.mongodb.client.model.Projections;
public class CodeSmellsChecker extends Checker {
@SuppressWarnings("unchecked")
@Override
public void check(String commit) {
Document reportDoc = new CodeAnalysisReportDAO().findByCommitHash(commit, Projections.include("_id"));
if (reportDoc == null) {
return;
}
CodeAnalysisDAO dao = new CodeAnalysisDAO();
List<Document> analysisDoc = dao.findByReport(reportDoc.getObjectId("_id"),
Projections.include("filename", "classes.codesmells", "classes.methods.codesmells"));
for (Document fileDoc : analysisDoc) {
TDItem tdItem = searchFile(fileDoc.getString("filename"));
for (Document clsDoc : (List<Document>) fileDoc.get("classes", List.class)) {
for (String codesmell : (List<String>) clsDoc.get("codesmells", List.class)) {
addTDIndicator(tdItem, TDIndicator.getTDIndicator(codesmell), 1);
}
for (Document methodDoc : (List<Document>) clsDoc.get("methods", List.class)) {
for (String codesmell : (List<String>) methodDoc.get("codesmells", List.class)) {
addTDIndicator(tdItem, TDIndicator.getTDIndicator(codesmell), 1);
}
}
}
}
}
@Override
public List<TDIndicator> getIndicators() {
return Arrays.asList(GOD_CLASS, COMPLEX_METHOD, FEATURE_ENVY, BRAIN_METHOD, DATA_CLASS);
}
}
| 2,082
| 34.913793
| 104
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/checker/Checker.java
|
package org.repositoryminer.technicaldebt.checker;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
/**
* This class is the base TD checker. Extends this class to implement your
* checker. The list of TD items is shred between all the checkers. Use the
* methods offered by this checker to find the TD item associated with a file
* and to add occurrences of a certain TD indicator. Only the indicators
* filtered by the user will be accepted.
*/
public abstract class Checker {
private Map<String, TDItem> tdItems;
private Set<TDIndicator> tdFilter;
/**
* Finds the TD occurrences in a version.
*
* @param commit
*/
public abstract void check(String commit);
/**
* @return the TD indicators supported by the checker.
*/
public abstract List<TDIndicator> getIndicators();
public void setTDItems(Map<String, TDItem> tdItems) {
this.tdItems = tdItems;
}
public void setTDFilter(Set<TDIndicator> tdFilter) {
this.tdFilter = tdFilter;
}
/**
* Finds the TD item instance associated with a file.
*
* @param filename
* @return the TD item
*/
protected TDItem searchFile(String filename) {
TDItem tdItem = tdItems.get(filename);
if (tdItem == null) {
tdItem = new TDItem(filename);
tdItems.put(filename, tdItem);
}
return tdItem;
}
/*
* Checks if the TD indicator is accepted by the filter. If the indicator is
* accepted by the filter its occurrences are added to the item.
*/
protected void addTDIndicator(TDItem tdItem, TDIndicator indicator, int occurrences) {
if (indicator == null || !tdFilter.contains(indicator)) {
return;
}
tdItem.addToIndicator(indicator, occurrences);
}
}
| 1,800
| 25.101449
| 87
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/checker/ExCommentChecker.java
|
package org.repositoryminer.technicaldebt.checker;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_ARCHITECTURE_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_BUILD_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_CODE_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_DEFECT_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_DESIGN_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_DOCUMENTATION_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_PEOPLE_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_REQUIREMENT_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_TEST_DEBT;
import static org.repositoryminer.technicaldebt.model.TDIndicator.COMMENT_ANALYSIS_UNKNOWN_DEBT;
import java.util.Arrays;
import java.util.List;
import org.bson.Document;
import org.repositoryminer.excomment.persistence.ExCommentDAO;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
import com.mongodb.client.model.Projections;
public class ExCommentChecker extends Checker {
@SuppressWarnings("unchecked")
@Override
public void check(String commit) {
ExCommentDAO dao = new ExCommentDAO();
List<Document> analysisDoc = dao.findByCommit(commit, Projections.include("filename",
"comments.patterns.tdtype"));
for (Document fileDoc : analysisDoc) {
TDItem tdItem = searchFile(fileDoc.getString("filename"));
for (Document comment : (List<Document>) fileDoc.get("comments")) {
for (Document pattern : (List<Document>) comment.get("patterns")) {
String tdtype = pattern.getString("tdtype").replace(' ', '_').toUpperCase();
if (tdtype.length() == 0) {
addTDIndicator(tdItem, COMMENT_ANALYSIS_UNKNOWN_DEBT, 1);
} else {
addTDIndicator(tdItem, TDIndicator.getTDIndicator("COMMENT_ANALYSIS_"+tdtype), 1);
}
}
}
}
}
@Override
public List<TDIndicator> getIndicators() {
return Arrays.asList(COMMENT_ANALYSIS_ARCHITECTURE_DEBT, COMMENT_ANALYSIS_BUILD_DEBT,
COMMENT_ANALYSIS_CODE_DEBT, COMMENT_ANALYSIS_DEFECT_DEBT, COMMENT_ANALYSIS_DESIGN_DEBT,
COMMENT_ANALYSIS_DOCUMENTATION_DEBT, COMMENT_ANALYSIS_PEOPLE_DEBT,
COMMENT_ANALYSIS_REQUIREMENT_DEBT, COMMENT_ANALYSIS_TEST_DEBT, COMMENT_ANALYSIS_UNKNOWN_DEBT);
}
}
| 2,591
| 42.932203
| 102
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/checker/CheckStyleChecker.java
|
package org.repositoryminer.technicaldebt.checker;
import static org.repositoryminer.technicaldebt.model.TDIndicator.CODE_WITHOUT_STANDARDS;
import java.util.Arrays;
import java.util.List;
import org.bson.Document;
import org.repositoryminer.checkstyle.persistence.CheckstyleAuditDAO;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
import com.mongodb.client.model.Projections;
public class CheckStyleChecker extends Checker {
@SuppressWarnings("unchecked")
@Override
public void check(String commit) {
CheckstyleAuditDAO dao = new CheckstyleAuditDAO();
List<Document> analysisDoc = dao.findByCommit(commit, Projections.include("filename", "style_problems.line"));
for (Document fileDoc : analysisDoc) {
TDItem tdItem = searchFile(fileDoc.getString("filename"));
addTDIndicator(tdItem, CODE_WITHOUT_STANDARDS, ((List<Document>) fileDoc.get("style_problems")).size());
}
}
@Override
public List<TDIndicator> getIndicators() {
return Arrays.asList(CODE_WITHOUT_STANDARDS);
}
}
| 1,074
| 29.714286
| 112
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/checker/FindBugsCheker.java
|
package org.repositoryminer.technicaldebt.checker;
import static org.repositoryminer.technicaldebt.model.TDIndicator.AUTOMATIC_STATIC_ANALYSIS_ISSUES;
import static org.repositoryminer.technicaldebt.model.TDIndicator.MULTITHREAD_CORRECTNESS;
import static org.repositoryminer.technicaldebt.model.TDIndicator.SLOW_ALGORITHM;
import java.util.Arrays;
import java.util.List;
import org.bson.Document;
import org.repositoryminer.findbugs.persistence.FindBugsDAO;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
import com.mongodb.client.model.Projections;
public class FindBugsCheker extends Checker {
@SuppressWarnings("unchecked")
@Override
public void check(String commit) {
FindBugsDAO dao = new FindBugsDAO();
List<Document> analysisDoc = dao.findByCommit(commit, Projections.include("filename", "bugs.category"));
for (Document fileDoc : analysisDoc) {
TDItem tdItem = searchFile(fileDoc.getString("filename"));
List<Document> bugs = (List<Document>) fileDoc.get("bugs");
int specificBugs = 0;
for (Document bug : bugs) {
String category = bug.getString("category");
if (category.equals("MT_CORRECTNESS")) {
addTDIndicator(tdItem, MULTITHREAD_CORRECTNESS, 1);
specificBugs++;
} else if (category.equals("PERFORMANCE")) {
addTDIndicator(tdItem, SLOW_ALGORITHM, 1);
specificBugs++;
}
}
if ((bugs.size() - specificBugs) > 0) {
addTDIndicator(tdItem, AUTOMATIC_STATIC_ANALYSIS_ISSUES, bugs.size() - specificBugs);
}
}
}
@Override
public List<TDIndicator> getIndicators() {
return Arrays.asList(AUTOMATIC_STATIC_ANALYSIS_ISSUES, SLOW_ALGORITHM, MULTITHREAD_CORRECTNESS);
}
}
| 1,728
| 31.622642
| 106
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/checker/CPDChecker.java
|
package org.repositoryminer.technicaldebt.checker;
import static org.repositoryminer.technicaldebt.model.TDIndicator.DUPLICATED_CODE;
import java.util.Arrays;
import java.util.List;
import org.bson.Document;
import org.repositoryminer.pmd.cpd.persistence.CPDDAO;
import org.repositoryminer.technicaldebt.model.TDIndicator;
import org.repositoryminer.technicaldebt.model.TDItem;
import com.mongodb.client.model.Projections;
public class CPDChecker extends Checker {
@SuppressWarnings("unchecked")
@Override
public void check(String commit) {
CPDDAO dao = new CPDDAO();
List<Document> analysisDoc = dao.findByCommit(commit, Projections.include("filename", "occurrences.filename"));
for (Document doc : analysisDoc) {
for (Document occurrence : (List<Document>) doc.get("occurrences", List.class)) {
TDItem tdItem = searchFile(occurrence.getString("filename"));
addTDIndicator(tdItem, DUPLICATED_CODE, 1);
}
}
}
@Override
public List<TDIndicator> getIndicators() {
return Arrays.asList(DUPLICATED_CODE);
}
}
| 1,045
| 27.27027
| 113
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/persistence/TechnicalDebtDAO.java
|
package org.repositoryminer.technicaldebt.persistence;
import java.util.List;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.client.model.Filters;
public class TechnicalDebtDAO extends GenericDAO {
private static final String COLLECTION_NAME = "rm_technical_debt";
public TechnicalDebtDAO() {
super(COLLECTION_NAME);
}
public void deleteByCommit(String hash) {
deleteMany(Filters.eq("commit", hash));
}
/**
* Retrieves an analyzed file.
*
* @param fileHash
* the file hash.
* @param commit
* the commit id.
* @param projection
* the query projection.
* @return the technical debt analysis.
*/
public Document findByFileAndCommit(long fileHash, String commit, Bson projection) {
return findOne(Filters.and(Filters.eq("filehash", fileHash), Filters.eq("commit", commit)), projection);
}
public void deleteByReport(ObjectId report) {
deleteMany(Filters.eq("analysis_report", report));
}
public List<Document> findByCommit(String commit, Bson projection) {
return findMany(Filters.eq("commit", commit), projection);
}
public List<Document> findByReport(ObjectId report, Bson projection) {
return findMany(Filters.eq("analysis_report", report), projection);
}
}
| 1,368
| 25.326923
| 106
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/persistence/TechnicalDebtReportDAO.java
|
package org.repositoryminer.technicaldebt.persistence;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.client.model.Filters;
public class TechnicalDebtReportDAO extends GenericDAO {
private static final String COLLECTION_NAME = "rm_technical_debt_report";
public TechnicalDebtReportDAO() {
super(COLLECTION_NAME);
}
public Document findByCommitHash(String hash, Bson projection) {
return findOne(Filters.eq("commit", hash), projection);
}
public void deleteById(ObjectId id) {
deleteOne(Filters.eq("_id", id));
}
}
| 652
| 23.185185
| 74
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/model/TDIndicator.java
|
package org.repositoryminer.technicaldebt.model;
import static org.repositoryminer.technicaldebt.model.TDType.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public enum TDIndicator {
// Code Smells
GOD_CLASS(CODE_DEBT, DESIGN_DEBT),
COMPLEX_METHOD(CODE_DEBT, DESIGN_DEBT),
FEATURE_ENVY(CODE_DEBT, DESIGN_DEBT),
BRAIN_METHOD(CODE_DEBT, DESIGN_DEBT),
DATA_CLASS(CODE_DEBT, DESIGN_DEBT),
// PMD/CPD
DUPLICATED_CODE(CODE_DEBT, DESIGN_DEBT),
// CheckStyle
CODE_WITHOUT_STANDARDS(CODE_DEBT),
// FindBugs
AUTOMATIC_STATIC_ANALYSIS_ISSUES(CODE_DEBT, DESIGN_DEBT),
MULTITHREAD_CORRECTNESS(CODE_DEBT),
SLOW_ALGORITHM(CODE_DEBT),
// eXcomment
COMMENT_ANALYSIS_UNKNOWN_DEBT(UNKNOWN_DEBT),
COMMENT_ANALYSIS_CODE_DEBT(CODE_DEBT),
COMMENT_ANALYSIS_DESIGN_DEBT(DESIGN_DEBT),
COMMENT_ANALYSIS_ARCHITECTURE_DEBT(ARCHITECTURE_DEBT),
COMMENT_ANALYSIS_BUILD_DEBT(BUILD_DEBT),
COMMENT_ANALYSIS_DEFECT_DEBT(DEFECT_DEBT),
COMMENT_ANALYSIS_DOCUMENTATION_DEBT(DOCUMENTATION_DEBT),
COMMENT_ANALYSIS_PEOPLE_DEBT(PEOPLE_DEBT),
COMMENT_ANALYSIS_REQUIREMENT_DEBT(REQUIREMENT_DEBT),
COMMENT_ANALYSIS_TEST_DEBT(TEST_DEBT);
private List<TDType> types;
TDIndicator(TDType... types) {
this.types = Arrays.asList(types);
}
public static TDIndicator getTDIndicator(String indicatorName) {
for (TDIndicator indicator : TDIndicator.values()) {
if (indicator.toString().equals(indicatorName)) {
return indicator;
}
}
return null;
}
public List<TDType> getTypes() {
return types;
}
public static List<TDIndicator> getByType(TDType type) {
List<TDIndicator> result = new ArrayList<TDIndicator>();
if (type == null) {
return result;
}
for (TDIndicator indicator : TDIndicator.values()) {
if (indicator.types.contains(type)) {
result.add(indicator);
}
}
return result;
}
}
| 1,872
| 23.324675
| 65
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/model/TDType.java
|
package org.repositoryminer.technicaldebt.model;
public enum TDType {
UNKNOWN_DEBT,
CODE_DEBT,
DESIGN_DEBT,
ARCHITECTURE_DEBT,
BUILD_DEBT,
DEFECT_DEBT,
DOCUMENTATION_DEBT,
PEOPLE_DEBT,
REQUIREMENT_DEBT,
TEST_DEBT;
}
| 229
| 12.529412
| 48
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-technicaldebt/src/main/java/org/repositoryminer/technicaldebt/model/TDItem.java
|
package org.repositoryminer.technicaldebt.model;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.bson.Document;
import org.repositoryminer.util.StringUtils;
public class TDItem {
String filename;
Map<TDIndicator, Integer> indicators = new HashMap<>();
Set<TDType> debts = new HashSet<>();
public TDItem(String filename) {
this.filename = filename;
}
public Document toDocument() {
setTDDebts();
List<Document> indicatorsDoc = new ArrayList<Document>();
for (Entry<TDIndicator, Integer> indicator : indicators.entrySet()) {
indicatorsDoc.add(new Document("name", indicator.getKey().name())
.append("occurrences", indicator.getValue()));
}
// Adding a confirmation flat to TD types and convert them to a document.
List<Document> typesDoc = new ArrayList<>();
for (TDType type : debts) {
typesDoc.add(new Document().append("name", type.name()).append("value", 0));
}
Document doc = new Document();
doc.append("filename", filename).
append("filehash", StringUtils.encodeToCRC32(filename)).
append("indicators", indicatorsDoc).
append("debts", typesDoc);
return doc;
}
public boolean isDebt() {
return indicators.size() > 0;
}
public void addToIndicator(TDIndicator indicator, int quantity) {
if (indicator == null) {
return;
}
Integer number = indicators.get(indicator);
if (number != null) {
indicators.put(indicator, number + quantity);
} else {
indicators.put(indicator, quantity);
}
}
private void setTDDebts() {
for (TDIndicator indicator : indicators.keySet()) {
debts.addAll(indicator.getTypes());
}
}
public String getFilename() {
return filename;
}
public void setFilename(String filename) {
this.filename = filename;
}
public Map<TDIndicator, Integer> getIndicators() {
return indicators;
}
public void setIndicators(Map<TDIndicator, Integer> indicators) {
this.indicators = indicators;
}
public Set<TDType> getDebts() {
return debts;
}
public void setDebts(Set<TDType> debts) {
this.debts = debts;
}
}
| 2,189
| 22.052632
| 79
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/RepositoryMinerWebSCM.java
|
package org.repositoryminer.web.scm;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
import org.repositoryminer.plugin.MiningPlugin;
import org.repositoryminer.web.scm.hostingservice.HostingServiceFactory;
import org.repositoryminer.web.scm.hostingservice.IHostingService;
import org.repositoryminer.web.scm.model.Issue;
import org.repositoryminer.web.scm.model.Milestone;
import org.repositoryminer.web.scm.persistence.IssueDAO;
import org.repositoryminer.web.scm.persistence.MilestoneDAO;
public class RepositoryMinerWebSCM extends MiningPlugin<WebSCMConfig>{
private IHostingService service;
public RepositoryMinerWebSCM(String repositoryKey) {
super(repositoryKey);
}
@Override
public void mine(WebSCMConfig config) {
service = HostingServiceFactory.getHostingService(config.getServiceType());
service.connect(config);
List<Issue> issues = service.getAllIssues();
List<Milestone> milestones = service.getAllMilestones();
processMilestones(milestones, issues);
processIssues(issues);
}
private void processMilestones(List<Milestone> milestones, List<Issue> issues) {
MilestoneDAO mileDocHandler = new MilestoneDAO();
List<Document> milesDocs = new ArrayList<Document>(milestones.size());
if (milestones.size() > 0) {
for (Milestone mile : milestones) {
mile.setIssues(new ArrayList<Integer>());
for (Issue i : issues) {
if (i.getMilestone() == mile.getNumber()) {
mile.getIssues().add(i.getNumber());
}
}
mile.setRepository(repository.getId());
milesDocs.add(mile.toDocument());
}
mileDocHandler.insertMany(milesDocs);
}
}
private void processIssues(List<Issue> issues) {
IssueDAO issueDocHandler = new IssueDAO();
List<Document> issuesDocs = new ArrayList<Document>(issues.size());
if (issues.size() > 0) {
for (Issue issue : issues) {
issue.setRepository(repository.getId());
issuesDocs.add(issue.toDocument());
}
issueDocHandler.insertMany(issuesDocs);
}
}
}
| 2,015
| 27.8
| 81
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/WebSCMConfig.java
|
package org.repositoryminer.web.scm;
import org.repositoryminer.web.scm.hostingservice.HostingServiceType;
/**
* Here you can configure the parameters that enable the synchronization of
* analyzed project with some web hosting service, <i>e.g.</i> github.
* <p>
* Check more informations in the service that will be used about how to know
* the owner and a name of a repository, <i>e.g.</i> in GitHUB we access a
* repository like this, github.com/<owner>/<repository_name>.
* <p>
* Check if the user has the enough rights in the repository, otherwise the
* synchronization will not retrieve some data.
* <p>
* <b>We not store your credentials.</b><br>
* <b>We encourage the use of access tokens instead of passwords, because is
* more secure.</b>
*/
public class WebSCMConfig {
private String owner;
private String name;
private HostingServiceType serviceType;
private String username;
private String token;
/**
* @param owner
* repository owner user.
* @param name
* repository name.
* @param serviceType
* the web hosting service ({@link HostingServiceType}) we want do
* the synchronization.
* @param username
* the user at the hosting service.
* @param token
* the token can be your password or an access token at the hosting
* service.
*
*/
public WebSCMConfig(String owner, String name, HostingServiceType serviceType, String username,
String token) {
this.owner = owner;
this.name = name;
this.serviceType = serviceType;
this.username = username;
this.token = token;
}
public String getOwner() {
return owner;
}
public WebSCMConfig setOwner(String owner) {
this.owner = owner;
return this;
}
public String getName() {
return name;
}
public WebSCMConfig setName(String name) {
this.name = name;
return this;
}
public HostingServiceType getServiceType() {
return serviceType;
}
public WebSCMConfig setServiceType(HostingServiceType serviceType) {
this.serviceType = serviceType;
return this;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
}
| 2,325
| 23.484211
| 96
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/hostingservice/IHostingService.java
|
package org.repositoryminer.web.scm.hostingservice;
import java.util.List;
import org.repositoryminer.web.scm.WebSCMConfig;
import org.repositoryminer.web.scm.model.Issue;
import org.repositoryminer.web.scm.model.Milestone;
public interface IHostingService {
/**
* Initialize connection with web service using login and a security token or a
* password.
*
* @param config
*/
public void connect(WebSCMConfig config);
/**
* @return All issues from web repository service.
*/
public List<Issue> getAllIssues();
/**
* @return All milestones from web repository service.
*/
public List<Milestone> getAllMilestones();
}
| 646
| 21.310345
| 80
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/hostingservice/HostingServiceType.java
|
package org.repositoryminer.web.scm.hostingservice;
public enum HostingServiceType {
GITHUB;
}
| 99
| 13.285714
| 51
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/hostingservice/HostingServiceFactory.java
|
package org.repositoryminer.web.scm.hostingservice;
public class HostingServiceFactory {
public static IHostingService getHostingService(HostingServiceType type) {
switch (type) {
case GITHUB:
return new GitHubService();
default:
return null;
}
}
}
| 267
| 18.142857
| 75
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/hostingservice/GitHubService.java
|
package org.repositoryminer.web.scm.hostingservice;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.egit.github.core.IssueEvent;
import org.eclipse.egit.github.core.RepositoryId;
import org.eclipse.egit.github.core.User;
import org.eclipse.egit.github.core.client.GitHubClient;
import org.eclipse.egit.github.core.client.PageIterator;
import org.eclipse.egit.github.core.service.IssueService;
import org.eclipse.egit.github.core.service.MilestoneService;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.web.scm.WebSCMConfig;
import org.repositoryminer.web.scm.model.Comment;
import org.repositoryminer.web.scm.model.Event;
import org.repositoryminer.web.scm.model.Issue;
import org.repositoryminer.web.scm.model.Label;
import org.repositoryminer.web.scm.model.Milestone;
public class GitHubService implements IHostingService {
private IssueService issueServ;
private MilestoneService milestoneServ;
private RepositoryId repositoryId;
@Override
public void connect(WebSCMConfig config) {
GitHubClient client = new GitHubClient();
client.setCredentials(config.getUsername(), config.getToken());
this.repositoryId = new RepositoryId(config.getOwner(), config.getName());
this.issueServ = new IssueService(client);
this.milestoneServ = new MilestoneService(client);
}
@Override
public List<Issue> getAllIssues() {
List<Issue> issues = new ArrayList<Issue>();
Map<String, String> parameters = new HashMap<>();
parameters.put("state", "all");
try {
for (org.eclipse.egit.github.core.Issue izzue : issueServ.getIssues(repositoryId, parameters)) {
Issue issue = new Issue(izzue.getUser().getLogin(), izzue.getClosedAt(), izzue.getCreatedAt(),
izzue.getNumber(), izzue.getState(), izzue.getTitle(), izzue.getUpdatedAt(),
izzue.getBody());
if (izzue.getAssignee() != null) {
issue.setAssignee(izzue.getAssignee().getLogin());
}
if (izzue.getMilestone() != null) {
issue.setMilestone(izzue.getMilestone().getNumber());
}
if (izzue.getLabels() != null) {
List<Label> labels = new ArrayList<Label>();
for (org.eclipse.egit.github.core.Label l : izzue.getLabels()) {
labels.add(new Label(l.getName(), l.getColor()));
}
issue.setLabels(labels);
}
issue.setComments(getAllComments(issue.getNumber()));
issue.setEvents(getlAllEvents(issue.getNumber()));
issues.add(issue);
}
} catch (IOException e) {
throw new RepositoryMinerException("Was not possible to get the issues.", e);
}
return issues;
}
@Override
public List<Milestone> getAllMilestones() {
List<Milestone> milesDB = new ArrayList<Milestone>();
try {
for (org.eclipse.egit.github.core.Milestone mile : milestoneServ.getMilestones(repositoryId, "all")) {
Milestone mileDB = new Milestone(mile.getNumber(), mile.getState(), mile.getTitle(),
mile.getDescription(), mile.getOpenIssues(), mile.getClosedIssues(), mile.getCreatedAt(),
mile.getDueOn());
if (mile.getCreator() != null) {
mileDB.setCreator(mile.getCreator().getLogin());
}
milesDB.add(mileDB);
}
} catch (IOException e) {
throw new RepositoryMinerException("Was not possible to get the milestones.", e);
}
return milesDB;
}
private List<Comment> getAllComments(int issueId) throws IOException {
List<Comment> comments = new ArrayList<Comment>();
List<org.eclipse.egit.github.core.Comment> commentz = issueServ.getComments(repositoryId, issueId);
if (commentz != null) {
for (org.eclipse.egit.github.core.Comment c : commentz) {
Comment comment = new Comment(c.getUser().getLogin(), c.getBody(), c.getCreatedAt(), c.getUpdatedAt());
comments.add(comment);
}
}
return comments;
}
private List<Event> getlAllEvents(int issueId) {
List<Event> events = new ArrayList<Event>();
PageIterator<IssueEvent> eventsPages = issueServ.pageIssueEvents(repositoryId.getOwner(),
repositoryId.getName(), issueId);
if (eventsPages != null) {
while (eventsPages.hasNext()) {
Collection<IssueEvent> issueEvents = eventsPages.next();
for (IssueEvent issueEvent : issueEvents) {
Event event = new Event();
event.setDescription(issueEvent.getEvent());
User user = issueEvent.getActor();
if (user != null) {
event.setCreator(user.getName());
}
event.setCreatedAt(issueEvent.getCreatedAt());
event.setCommitId(issueEvent.getCommitId());
events.add(event);
}
}
}
return events;
}
}
| 4,650
| 30.639456
| 107
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/persistence/IssueDAO.java
|
package org.repositoryminer.web.scm.persistence;
import org.bson.types.ObjectId;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.BasicDBObject;
public class IssueDAO extends GenericDAO {
private static final String COLLECTION_NAME = "rm_issues";
public IssueDAO() {
super(COLLECTION_NAME);
}
public void deleteByRepository(String id) {
BasicDBObject where = new BasicDBObject("repository", new ObjectId(id));
deleteMany(where);
}
}
| 473
| 21.571429
| 74
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/persistence/MilestoneDAO.java
|
package org.repositoryminer.web.scm.persistence;
import org.bson.types.ObjectId;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.BasicDBObject;
public class MilestoneDAO extends GenericDAO {
private static final String COLLECTION_NAME = "rm_milestones";
public MilestoneDAO() {
super(COLLECTION_NAME);
}
public void deleteByRepository(String id) {
BasicDBObject where = new BasicDBObject("repository", new ObjectId(id));
deleteMany(where);
}
}
| 485
| 22.142857
| 74
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/model/Comment.java
|
package org.repositoryminer.web.scm.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.bson.Document;
public class Comment {
private String user;
private String body;
private Date createdAt;
private Date updatedAt;
public static List<Document> toDocumentList(List<Comment> comments) {
List<Document> docs = new ArrayList<Document>();
if (comments != null) {
for (Comment c : comments) {
docs.add(new Document("user", c.getUser()).append("body", c.getBody())
.append("created_at", c.getCreatedAt()).append("updated_at", c.getUpdatedAt()));
}
}
return docs;
}
public Comment() {
}
public Comment(String user, String body, Date createdAt, Date updatedAt) {
super();
this.user = user;
this.body = body;
this.createdAt = createdAt;
this.updatedAt = updatedAt;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public Date getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
public Date getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Date updatedAt) {
this.updatedAt = updatedAt;
}
}
| 1,327
| 17.971429
| 86
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/model/Label.java
|
package org.repositoryminer.web.scm.model;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
public class Label {
private String name;
private String color;
public Label() {}
public Label(String name, String color) {
super();
this.name = name;
this.color = color;
}
public static List<Document> toDocumentList(List<Label> labels) {
if (labels == null) {
return null;
}
List<Document> docs = new ArrayList<Document>();
for (Label l : labels) {
docs.add(new Document("name", l.name).append("color", l.color));
}
return docs;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
| 815
| 15.653061
| 67
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/model/Issue.java
|
package org.repositoryminer.web.scm.model;
import java.util.Date;
import java.util.List;
import org.bson.Document;
import org.bson.types.ObjectId;
public class Issue {
private String creator;
private String assignee;
private Date closedAt;
private Date createdAt;
private int number;
private String status;
private String title;
private Date updatedAt;
private String body;
private int milestone;
private ObjectId repository;
private List<Label> labels;
private List<Comment> comments;
private List<Event> events;
public Document toDocument() {
Document doc = new Document();
doc.append("creator", creator).append("assignee", assignee).append("closed_at", closedAt)
.append("created_at", createdAt).append("number", number).append("status", status)
.append("title", title).append("updated_at", updatedAt).append("body", body)
.append("milestone", milestone).append("repository", repository)
.append("labels", Label.toDocumentList(labels)).append("comments", Comment.toDocumentList(comments))
.append("events", Event.toDocumentList(events));
return doc;
}
public Issue() {
}
public Issue(String creator, Date closedAt, Date createdAt, int number, String status, String title,
Date updatedAt, String body) {
super();
this.creator = creator;
this.closedAt = closedAt;
this.createdAt = createdAt;
this.number = number;
this.status = status;
this.title = title;
this.updatedAt = updatedAt;
this.body = body;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public String getAssignee() {
return assignee;
}
public void setAssignee(String assignee) {
this.assignee = assignee;
}
public Date getClosedAt() {
return closedAt;
}
public void setClosedAt(Date closedAt) {
this.closedAt = closedAt;
}
public Date getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Date getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Date updatedAt) {
this.updatedAt = updatedAt;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public int getMilestone() {
return milestone;
}
public void setMilestone(int milestone) {
this.milestone = milestone;
}
public ObjectId getRepository() {
return repository;
}
public void setRepository(ObjectId repository) {
this.repository = repository;
}
public List<Label> getLabels() {
return labels;
}
public void setLabels(List<Label> labels) {
this.labels = labels;
}
public List<Comment> getComments() {
return comments;
}
public void setComments(List<Comment> comments) {
this.comments = comments;
}
public List<Event> getEvents() {
return events;
}
public void setEvents(List<Event> events) {
this.events = events;
}
}
| 3,250
| 18.584337
| 104
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/model/Event.java
|
package org.repositoryminer.web.scm.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.bson.Document;
public class Event {
private String description;
private String creator;
private Date createdAt;
private String commitId;
public static List<Document> toDocumentList(List<Event> events) {
List<Document> docs = new ArrayList<Document>();
if (events != null) {
for (Event e : events) {
docs.add(new Document("description", e.getDescription()).append("creator", e.getCreator())
.append("created_at", e.getCreatedAt()).append("commit", e.getCommitId()));
}
}
return docs;
}
public Event() {
}
public Event(String description, String creator, Date createdAt, String commitId) {
super();
this.description = description;
this.creator = creator;
this.createdAt = createdAt;
this.commitId = commitId;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public Date getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
public String getCommitId() {
return commitId;
}
public void setCommitId(String commitId) {
this.commitId = commitId;
}
}
| 1,425
| 19.084507
| 94
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-web-scm/src/main/java/org/repositoryminer/web/scm/model/Milestone.java
|
package org.repositoryminer.web.scm.model;
import java.util.Date;
import java.util.List;
import org.bson.Document;
import org.bson.types.ObjectId;
public class Milestone {
private int number;
private String status;
private String title;
private String description;
private String creator;
private int openedIssues;
private int closedIssues;
private Date createdAt;
private Date dueOn;
private List<Integer> issues;
private ObjectId repository;
public Document toDocument() {
Document doc = new Document();
doc.append("number", number).append("status", status).append("title", title)
.append("description", description).append("creator", creator).append("opened_issues", openedIssues)
.append("closed_issues", closedIssues).append("created_at", createdAt).append("due_on", dueOn)
.append("repository", repository).append("issues", issues);
return doc;
}
public Milestone() {}
public Milestone(int number, String status, String title, String description, int openedIssues,
int closedIssues, Date createdAt, Date dueOn) {
super();
this.number = number;
this.status = status;
this.title = title;
this.description = description;
this.openedIssues = openedIssues;
this.closedIssues = closedIssues;
this.createdAt = createdAt;
this.dueOn = dueOn;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public int getOpenedIssues() {
return openedIssues;
}
public void setOpenedIssues(int openedIssues) {
this.openedIssues = openedIssues;
}
public int getClosedIssues() {
return closedIssues;
}
public void setClosedIssues(int closedIssues) {
this.closedIssues = closedIssues;
}
public Date getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
public Date getDueOn() {
return dueOn;
}
public void setDueOn(Date dueOn) {
this.dueOn = dueOn;
}
public List<Integer> getIssues() {
return issues;
}
public void setIssues(List<Integer> issues) {
this.issues = issues;
}
public ObjectId getRepository() {
return repository;
}
public void setRepository(ObjectId repository) {
this.repository = repository;
}
}
| 2,736
| 19.274074
| 104
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-checkstyle/src/main/java/org/repositoryminer/checkstyle/RepositoryMinerCheckStyle.java
|
package org.repositoryminer.checkstyle;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.bson.Document;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.checkstyle.model.StyleProblem;
import org.repositoryminer.checkstyle.persistence.CheckstyleAuditDAO;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.plugin.SnapshotAnalysisPlugin;
import org.repositoryminer.util.RMFileUtils;
import org.repositoryminer.util.StringUtils;
import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
public class RepositoryMinerCheckStyle extends SnapshotAnalysisPlugin<CheckStyleConfig> {
@Override
public void run(String snapshot, CheckStyleConfig config) {
scm.checkout(snapshot);
Commit commit = scm.resolve(snapshot);
CheckstyleAuditDAO dao = new CheckstyleAuditDAO();
dao.deleteByCommit(commit.getHash());
CheckStyleExecutor executor = new CheckStyleExecutor(tmpRepository);
if (config != null) {
if (config.isInsideRepository()) {
executor.setConfigFile(config.getConfigFile() != null ?
RMFileUtils.concatFilePath(tmpRepository, config.getConfigFile()) : null);
executor.setPropertiesFile(config.getPropertiesFile() != null ?
RMFileUtils.concatFilePath(tmpRepository, config.getPropertiesFile()) : null);
} else {
executor.setConfigFile(config.getConfigFile());
executor.setPropertiesFile(config.getPropertiesFile());
}
}
Map<String, List<StyleProblem>> result = null;
try {
result = executor.execute();
} catch (CheckstyleException e) {
throw new RepositoryMinerException("Can not execute checkstyle.", e);
}
List<Document> documents = new ArrayList<Document>(result.size());
for (Entry<String, List<StyleProblem>> file : result.entrySet()) {
Document doc = new Document();
doc.append("reference", snapshot).
append("commit", commit.getHash()).
append("filehash", StringUtils.encodeToCRC32(file.getKey())).
append("commit_date", commit.getCommitterDate()).
append("repository", repositoryId).
append("filename", file.getKey()).
append("style_problems", StyleProblem.toDocumentList(file.getValue()));
documents.add(doc);
}
dao.insertMany(documents);
}
}
| 2,285
| 32.617647
| 89
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-checkstyle/src/main/java/org/repositoryminer/checkstyle/CheckStyleExecutor.java
|
package org.repositoryminer.checkstyle;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.apache.commons.io.FileUtils;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.checkstyle.audit.RepositoryMinerAudit;
import org.repositoryminer.checkstyle.model.StyleProblem;
import com.google.common.io.Closeables;
import com.puppycrawl.tools.checkstyle.Checker;
import com.puppycrawl.tools.checkstyle.ConfigurationLoader;
import com.puppycrawl.tools.checkstyle.ModuleFactory;
import com.puppycrawl.tools.checkstyle.PackageObjectFactory;
import com.puppycrawl.tools.checkstyle.PropertiesExpander;
import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
import com.puppycrawl.tools.checkstyle.api.Configuration;
import com.puppycrawl.tools.checkstyle.api.RootModule;
public class CheckStyleExecutor {
private static String[] EXTENSION_FILE_FILTER = { "java" };
private String propertiesFile;
private String configFile;
private String repository;
public CheckStyleExecutor(String repository) {
this.repository = repository;
}
public void setPropertiesFile(String propertiesFile) {
this.propertiesFile = propertiesFile;
}
public void setConfigFile(String configFile) {
this.configFile = configFile;
}
public Map<String, List<StyleProblem>> execute() throws CheckstyleException {
Properties properties;
if (propertiesFile == null) {
properties = System.getProperties();
} else {
properties = loadProperties(new File(propertiesFile));
}
if (configFile == null) {
configFile = "/google_checks.xml";
}
// create configurations
Configuration config = ConfigurationLoader.loadConfiguration(configFile, new PropertiesExpander(properties));
// create our custom audit listener
RepositoryMinerAudit listener = new RepositoryMinerAudit();
listener.setRepositoryPathLength(repository.length());
ClassLoader moduleClassLoader = Checker.class.getClassLoader();
RootModule rootModule = getRootModule(config.getName(), moduleClassLoader);
rootModule.setModuleClassLoader(moduleClassLoader);
rootModule.configure(config);
rootModule.addListener(listener);
// executes checkstyle
rootModule.process((List<File>) FileUtils.listFiles(new File(repository), EXTENSION_FILE_FILTER, true));
rootModule.destroy();
return listener.getFileErrors();
}
private Properties loadProperties(File file) {
Properties properties = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
properties.load(fis);
} catch (IOException e) {
throw new RepositoryMinerException("Can not load properties from " + file.getAbsolutePath(), e);
} finally {
Closeables.closeQuietly(fis);
}
return properties;
}
private RootModule getRootModule(String name, ClassLoader moduleClassLoader) throws CheckstyleException {
ModuleFactory factory = new PackageObjectFactory(Checker.class.getPackage().getName() + ".", moduleClassLoader);
return (RootModule) factory.createModule(name);
}
}
| 3,128
| 30.606061
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-checkstyle/src/main/java/org/repositoryminer/checkstyle/CheckStyleConfig.java
|
package org.repositoryminer.checkstyle;
public class CheckStyleConfig {
private String configFile;
private String propertiesFile;
private boolean insideRepository = true;
public String getConfigFile() {
return configFile;
}
public void setConfigFile(String configFile) {
this.configFile = configFile;
}
public String getPropertiesFile() {
return propertiesFile;
}
public void setPropertiesFile(String propertiesFile) {
this.propertiesFile = propertiesFile;
}
public boolean isInsideRepository() {
return insideRepository;
}
public void setInsideRepository(boolean insideRepository) {
this.insideRepository = insideRepository;
}
}
| 665
| 19.181818
| 60
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-checkstyle/src/main/java/org/repositoryminer/checkstyle/audit/RepositoryMinerAudit.java
|
package org.repositoryminer.checkstyle.audit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.io.FilenameUtils;
import org.repositoryminer.checkstyle.model.StyleProblem;
import com.puppycrawl.tools.checkstyle.api.AuditEvent;
import com.puppycrawl.tools.checkstyle.api.AuditListener;
public class RepositoryMinerAudit implements AuditListener {
private Map<String, List<StyleProblem>> fileErrors = new HashMap<String, List<StyleProblem>>();
private String currFile;
private int repositoryPathEnd;
public Map<String, List<StyleProblem>> getFileErrors() {
return fileErrors;
}
public void setRepositoryPathLength(int repositoryPathLength) {
this.repositoryPathEnd = repositoryPathLength + 1;
}
@Override
public void auditStarted(AuditEvent event) {
// Nothing is needed here
}
@Override
public void auditFinished(AuditEvent event) {
// Nothing is needed here
}
@Override
public void fileStarted(AuditEvent event) {
String filename = FilenameUtils.normalize(event.getFileName());
filename = filename.substring(repositoryPathEnd);
currFile = filename;
fileErrors.put(currFile, new ArrayList<StyleProblem>());
}
@Override
public void fileFinished(AuditEvent event) {
if (fileErrors.get(currFile).isEmpty()) {
fileErrors.remove(currFile);
}
}
@Override
public void addError(AuditEvent event) {
int checkerIndex = event.getSourceName().lastIndexOf('.') + 1;
StyleProblem sp = new StyleProblem(event.getLine(), event.getColumn(), event.getMessage(),
event.getSeverityLevel().getName(), event.getSourceName().substring(checkerIndex));
fileErrors.get(currFile).add(sp);
}
@Override
public void addException(AuditEvent event, Throwable throwable) {
// Nothing is needed here
}
}
| 1,823
| 25.823529
| 96
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-checkstyle/src/main/java/org/repositoryminer/checkstyle/persistence/CheckstyleAuditDAO.java
|
package org.repositoryminer.checkstyle.persistence;
import java.util.List;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.BasicDBObject;
import com.mongodb.client.model.Filters;
public class CheckstyleAuditDAO extends GenericDAO {
private static final String COLLECTION_NAME = "checkstyle_audit";
public CheckstyleAuditDAO() {
super(COLLECTION_NAME);
}
public Document findByFile(long filehash, String commit, Bson projection) {
Bson clause1 = new BasicDBObject("filehash", filehash);
Bson clause2 = new BasicDBObject("commit", commit);
return findOne(Filters.and(clause1, clause2), projection);
}
public void deleteByCommit(String hash) {
deleteMany(Filters.eq("commit", hash));
}
public List<Document> findByCommit(String hash, Bson projection) {
return findMany(Filters.eq("commit", hash), projection);
}
}
| 926
| 26.264706
| 76
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-checkstyle/src/main/java/org/repositoryminer/checkstyle/model/StyleProblem.java
|
package org.repositoryminer.checkstyle.model;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
public class StyleProblem {
private int line;
private int column;
private String message;
private String severity;
private String checker;
public static List<Document> toDocumentList(List<StyleProblem> styleProblems) {
List<Document> docs = new ArrayList<Document>();
if (styleProblems == null) {
return docs;
}
for (StyleProblem e : styleProblems) {
docs.add(e.toDocument());
}
return docs;
}
public Document toDocument() {
Document doc = new Document();
return doc.append("line", line).append("column", column).append("message", message).append("severity", severity)
.append("checker", checker);
}
public StyleProblem(int line, int column, String message, String severity, String checker) {
this.line = line;
this.column = column;
this.message = message;
this.severity = severity;
this.checker = checker;
}
public int getLine() {
return line;
}
public void setLine(int line) {
this.line = line;
}
public int getColumn() {
return column;
}
public void setColumn(int column) {
this.column = column;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getSeverity() {
return severity;
}
public void setSeverity(String severity) {
this.severity = severity;
}
public String getChecker() {
return checker;
}
public void setChecker(String checker) {
this.checker = checker;
}
}
| 1,588
| 17.916667
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/FindBugsConfig.java
|
package org.repositoryminer.findbugs;
import java.util.HashSet;
import java.util.Set;
import org.repositoryminer.findbugs.configuration.Effort;
import org.repositoryminer.findbugs.configuration.Priority;
public class FindBugsConfig {
private Priority priority = Priority.NORMAL;
private Effort effort = Effort.DEFAULT;
private Set<String> analysisClasspath = new HashSet<String>();
private boolean insideRepository = false;
public FindBugsConfig() {}
public FindBugsConfig(Priority priority, Effort effort, Set<String> analysisClasspath, boolean insideRepository) {
this.priority = priority;
this.effort = effort;
this.analysisClasspath = analysisClasspath;
this.insideRepository = insideRepository;
}
public Priority getPriority() {
return priority;
}
public void setPriority(Priority priority) {
this.priority = priority;
}
public Effort getEffort() {
return effort;
}
public void setEffort(Effort effort) {
this.effort = effort;
}
public Set<String> getAnalysisClasspath() {
return analysisClasspath;
}
public void setAnalysisClasspath(Set<String> analysisClasspath) {
this.analysisClasspath = analysisClasspath;
}
public boolean isInsideRepository() {
return insideRepository;
}
public void setInsideRepository(boolean insideRepository) {
this.insideRepository = insideRepository;
}
}
| 1,350
| 22.701754
| 115
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/RepositoryMinerFindBugs.java
|
package org.repositoryminer.findbugs;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.bson.Document;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.findbugs.configuration.Effort;
import org.repositoryminer.findbugs.configuration.Priority;
import org.repositoryminer.findbugs.model.ReportedBug;
import org.repositoryminer.findbugs.persistence.FindBugsDAO;
import org.repositoryminer.plugin.SnapshotAnalysisPlugin;
import org.repositoryminer.util.RMFileUtils;
import org.repositoryminer.util.StringUtils;
import edu.umd.cs.findbugs.FindBugs;
import edu.umd.cs.findbugs.Priorities;
import edu.umd.cs.findbugs.config.AnalysisFeatureSetting;
import edu.umd.cs.findbugs.config.UserPreferences;
public class RepositoryMinerFindBugs extends SnapshotAnalysisPlugin<FindBugsConfig> {
private static final String[] EXTENSION_FILE_FILTER = { "java" };
private static final Map<Priority, Integer> prioritiesMap = new HashMap<Priority, Integer>();
private static final Map<Effort, AnalysisFeatureSetting[]> effortsMap = new HashMap<Effort, AnalysisFeatureSetting[]>();
private static final Map<Effort, String> userPrefsEffortMap = new HashMap<Effort, String>();
static {
prioritiesMap.put(Priority.LOW, Priorities.IGNORE_PRIORITY);
prioritiesMap.put(Priority.NORMAL, Priorities.NORMAL_PRIORITY);
prioritiesMap.put(Priority.HIGH, Priorities.HIGH_PRIORITY);
effortsMap.put(Effort.MIN, FindBugs.MIN_EFFORT);
effortsMap.put(Effort.DEFAULT, FindBugs.DEFAULT_EFFORT);
effortsMap.put(Effort.MAX, FindBugs.MAX_EFFORT);
userPrefsEffortMap.put(Effort.MIN, UserPreferences.EFFORT_MIN);
userPrefsEffortMap.put(Effort.DEFAULT, UserPreferences.EFFORT_DEFAULT);
userPrefsEffortMap.put(Effort.MAX, UserPreferences.EFFORT_MAX);
}
@Override
public void run(String snapshot, FindBugsConfig config) {
scm.checkout(snapshot);
Commit commit = scm.getHEAD();
FindBugsDAO dao = new FindBugsDAO();
dao.deleteByCommit(commit.getHash());
FindBugsExecutor findBugsExecutor = new FindBugsExecutor();
findBugsExecutor.setBugPriority(prioritiesMap.get(config.getPriority()));
findBugsExecutor.setEffort(effortsMap.get(config.getEffort()));
findBugsExecutor.setUserPrefsEffort(userPrefsEffortMap.get(config.getEffort()));
if (config.isInsideRepository()) {
findBugsExecutor.setAnalysisClasspath(
new HashSet<String>(RMFileUtils.concatFilePath(tmpRepository, config.getAnalysisClasspath())));
} else {
findBugsExecutor.setAnalysisClasspath(config.getAnalysisClasspath());
}
Map<String, List<ReportedBug>> reportedBugs = null;
try {
reportedBugs = findBugsExecutor.execute();
} catch (IllegalStateException | IOException | InterruptedException e) {
throw new RepositoryMinerException("Can not execute findbugs.", e);
}
List<String> files = getFiles(tmpRepository);
List<Document> documents = new ArrayList<>();
for (Entry<String, List<ReportedBug>> bug : reportedBugs.entrySet()) {
String filename = null;
for (String file : files) {
if (file.endsWith(bug.getKey())) {
filename = file;
break;
}
}
if (filename != null) {
Document doc = new Document();
doc.append("reference", snapshot).
append("commit", commit.getHash()).
append("commit_date", commit.getCommitterDate()).
append("repository", repositoryId).
append("filename", filename).
append("filehash", StringUtils.encodeToCRC32(filename)).
append("bugs", ReportedBug.toDocumentList(bug.getValue()));
documents.add(doc);
}
}
dao.insertMany(documents);
}
private List<String> getFiles(String dir) {
Collection<File> files = FileUtils.listFiles(new File(dir), EXTENSION_FILE_FILTER, true);
List<String> filepaths = new ArrayList<String>(files.size());
for (File f : files) {
filepaths.add(FilenameUtils.normalize(f.getAbsolutePath().substring(dir.length() + 1), true));
}
return filepaths;
}
}
| 4,250
| 35.333333
| 121
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/FindBugsExecutor.java
|
package org.repositoryminer.findbugs;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.repositoryminer.findbugs.model.ReportedBug;
import edu.umd.cs.findbugs.BugInstance;
import edu.umd.cs.findbugs.DetectorFactoryCollection;
import edu.umd.cs.findbugs.FindBugs2;
import edu.umd.cs.findbugs.Project;
import edu.umd.cs.findbugs.XMLBugReporter;
import edu.umd.cs.findbugs.config.AnalysisFeatureSetting;
import edu.umd.cs.findbugs.config.UserPreferences;
public class FindBugsExecutor {
private int bugPriority;
private AnalysisFeatureSetting[] effort;
private String userPrefsEffort;
private Set<String> analysisClasspath;
public Map<String, List<ReportedBug>> execute() throws IOException, InterruptedException, IllegalStateException {
FindBugs2 findBugs = new FindBugs2();
Project project = getProject();
findBugs.setProject(project);
XMLBugReporter reporter = new XMLBugReporter(project);
reporter.setPriorityThreshold(bugPriority);
reporter.setAddMessages(true);
reporter.setUseLongBugCodes(true);
findBugs.setBugReporter(reporter);
UserPreferences userPrefs = UserPreferences.createDefaultUserPreferences();
userPrefs.setEffort(userPrefsEffort);
findBugs.setUserPreferences(userPrefs);
findBugs.setDetectorFactoryCollection(DetectorFactoryCollection.instance());
findBugs.setAnalysisFeatureSettings(effort);
findBugs.finishSettings();
findBugs.execute();
Map<String, List<ReportedBug>> reportedBugs = new HashMap<String, List<ReportedBug>>();
for (BugInstance b : reporter.getBugCollection()) {
String filename = b.getPrimarySourceLineAnnotation().getSourcePath();
if (!reportedBugs.containsKey(filename)) {
reportedBugs.put(filename, new ArrayList<ReportedBug>());
}
ReportedBug rb = new ReportedBug(b.getBugRank(), b.getBugRankCategory().toString(), b.getPriority(),
b.getPriorityString(), b.getType(), b.getAbbrev(), b.getBugPattern().getDetailPlainText(),
b.getBugPattern().getCategory(), b.getPrimaryClass().getClassName(), b.getAbridgedMessage(),
b.getMessage());
if (b.getPrimaryMethod() != null) {
String methodName = b.getPrimaryMethod().getFullMethod(b.getPrimaryClass());
rb.setMethod(methodName.substring(methodName.lastIndexOf(".") + 1));
}
if (b.getPrimaryField() != null) {
rb.setField(b.getPrimaryField().getFieldName());
}
if (b.getPrimaryLocalVariableAnnotation() != null) {
rb.setLocalVariable(b.getPrimaryLocalVariableAnnotation().getName());
}
reportedBugs.get(filename).add(rb);
}
findBugs.dispose();
return reportedBugs;
}
private Project getProject() throws IOException, IllegalStateException {
Project findBugsProject = new Project();
for (String clsPath : analysisClasspath) {
findBugsProject.addFile(clsPath);
}
return findBugsProject;
}
public void setBugPriority(int bugPriority) {
this.bugPriority = bugPriority;
}
public void setEffort(AnalysisFeatureSetting[] effort) {
this.effort = effort;
}
public void setUserPrefsEffort(String userPrefsEffort) {
this.userPrefsEffort = userPrefsEffort;
}
public void setAnalysisClasspath(Set<String> analysisClasspath) {
this.analysisClasspath = analysisClasspath;
}
}
| 3,321
| 29.759259
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/configuration/Priority.java
|
package org.repositoryminer.findbugs.configuration;
public enum Priority {
LOW,
NORMAL,
HIGH;
}
| 103
| 10.555556
| 51
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/configuration/Effort.java
|
package org.repositoryminer.findbugs.configuration;
public enum Effort {
MIN,
DEFAULT,
MAX;
}
| 100
| 10.222222
| 51
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/persistence/FindBugsDAO.java
|
package org.repositoryminer.findbugs.persistence;
import java.util.List;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.BasicDBObject;
import com.mongodb.client.model.Filters;
public class FindBugsDAO extends GenericDAO {
private static final String COLLECTION_NAME = "findbugs_bugs_analysis";
public FindBugsDAO() {
super(COLLECTION_NAME);
}
public Document findByClasses(String[] classes, String commit, Bson projection) {
Bson clause1 = Filters.in("bugs.class", classes);
Bson clause2 = new BasicDBObject("commit", commit);
return findOne(Filters.and(clause1, clause2), projection);
}
public Document findByFile(long filehash, String commit, Bson projection) {
Bson clause1 = new BasicDBObject("filehash", filehash);
Bson clause2 = new BasicDBObject("commit", commit);
return findOne(Filters.and(clause1, clause2), projection);
}
public void deleteByCommit(String hash) {
deleteMany(Filters.eq("commit", hash));
}
public List<Document> findByCommit(String hash, Bson projection) {
return findMany(Filters.eq("commit", hash), projection);
}
}
| 1,168
| 28.225
| 82
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-findbugs/src/main/java/org/repositoryminer/findbugs/model/ReportedBug.java
|
package org.repositoryminer.findbugs.model;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
public class ReportedBug {
private int rank;
private String rankCategory;
private int priority;
private String priorityCategory;
private String type;
private String abbreviation;
private String description;
private String category;
private String clazz;
private String field;
private String method;
private String localVariable;
private String shortMessage;
private String longMessage;
public ReportedBug() {
}
public ReportedBug(int rank, String rankCategory, int priority, String priorityCategory, String type,
String abbreviation, String description, String category, String clazz, String shortMessage,
String longMessage) {
super();
this.rank = rank;
this.rankCategory = rankCategory;
this.priority = priority;
this.priorityCategory = priorityCategory;
this.type = type;
this.abbreviation = abbreviation;
this.description = description;
this.category = category;
this.clazz = clazz;
this.shortMessage = shortMessage;
this.longMessage = longMessage;
}
public static List<Document> toDocumentList(List<ReportedBug> reportedBugs) {
List<Document> list = new ArrayList<Document>();
for (ReportedBug rb : reportedBugs) {
Document doc = new Document();
doc.append("rank", rb.getRank()).append("rank_category", rb.getRankCategory())
.append("priority", rb.getPriority()).append("priority_category", rb.getPriorityCategory())
.append("type", rb.getType()).append("abbreviation", rb.getAbbreviation())
.append("description", rb.getDescription()).append("category", rb.getCategory())
.append("class", rb.getClazz()).append("field", rb.getField()).append("method", rb.getMethod())
.append("local_variable", rb.getLocalVariable()).append("short_message", rb.getShortMessage())
.append("long_message", rb.getLongMessage());
list.add(doc);
}
return list;
}
public int getRank() {
return rank;
}
public void setRank(int rank) {
this.rank = rank;
}
public String getRankCategory() {
return rankCategory;
}
public void setRankCategory(String rankCategory) {
this.rankCategory = rankCategory;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public String getPriorityCategory() {
return priorityCategory;
}
public void setPriorityCategory(String priorityCategory) {
this.priorityCategory = priorityCategory;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getAbbreviation() {
return abbreviation;
}
public void setAbbreviation(String abbreviation) {
this.abbreviation = abbreviation;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public String getLocalVariable() {
return localVariable;
}
public void setLocalVariable(String localVariable) {
this.localVariable = localVariable;
}
public String getShortMessage() {
return shortMessage;
}
public void setShortMessage(String shortMessage) {
this.shortMessage = shortMessage;
}
public String getLongMessage() {
return longMessage;
}
public void setLongMessage(String longMessage) {
this.longMessage = longMessage;
}
}
| 3,872
| 21.387283
| 102
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/AnalysisRunner.java
|
package org.repositoryminer.metrics;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.codemetric.CodeMetric;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.codemetric.MetricFactory;
import org.repositoryminer.metrics.codesmell.CodeSmell;
import org.repositoryminer.metrics.codesmell.CodeSmellFactory;
import org.repositoryminer.metrics.codesmell.CodeSmellId;
import org.repositoryminer.metrics.parser.Language;
import org.repositoryminer.metrics.parser.Parser;
import org.repositoryminer.metrics.persistence.CodeAnalysisDAO;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
import org.repositoryminer.util.RMFileUtils;
public class AnalysisRunner {
private ProjectReport projectReport = new ProjectReport();
private Map<CodeMetricId, CodeMetric> metricsToCalculate = new LinkedHashMap<>();
private Map<CodeSmellId, CodeSmell> codeSmellsToDetect = new LinkedHashMap<>();
private Map<String, Parser> parsersToUse = new LinkedHashMap<>();
private Map<Language, String[]> sourceFolders = new LinkedHashMap<>();
private String repository;
public AnalysisRunner(String repository) {
this.repository = repository;
}
public Collection<CodeMetric> getCalculatedMetrics() {
return metricsToCalculate.values();
}
public Collection<CodeSmell> getDetectedCodeSmells() {
return codeSmellsToDetect.values();
}
public void setCodeMetrics(List<CodeMetric> codeMetrics) {
if (codeMetrics == null) {
return;
}
for (CodeMetric metric : codeMetrics) {
visitMetric(metric);
}
}
public void setCodeSmells(List<CodeSmell> codeSmells) {
if (codeSmells == null) {
return;
}
for (CodeSmell codeSmell : codeSmells) {
visitCodeSmell(codeSmell);
}
}
public void setParsers(List<Parser> parsers) {
for (Parser p : parsers) {
if (p.getSourceFolders() == null || p.getSourceFolders().length == 0) {
p.setSourceFolders(RMFileUtils.getAllDirsAsString(repository).toArray(new String[0]));
} else {
p.setSourceFolders(RMFileUtils.concatFilePath(repository, p.getSourceFolders()));
}
for (String ext : p.getExtensions()) {
parsersToUse.put(ext, p);
}
}
}
public void run(ObjectId analysisReportId, Commit commit, ObjectId repoId, String reference) throws IOException {
for (File file : FileUtils.listFiles(new File(repository), parsersToUse.keySet().toArray(new String[0]),
true)) {
analyzeFile(file, repository);
}
for (CodeMetric metric : metricsToCalculate.values()) {
metric.clean(projectReport);
}
for (CodeSmell codeSmell : codeSmellsToDetect.values()) {
for (FileReport fr : projectReport.getAllFiles()) {
codeSmell.detect(fr, projectReport);
}
}
persistData(analysisReportId, commit, repoId, reference);
}
private void analyzeFile(File file, String repository) throws IOException {
Parser parser = parsersToUse.get(FilenameUtils.getExtension(file.getAbsolutePath()));
if (parser == null) {
return;
}
String filename = FilenameUtils.normalize(file.getAbsolutePath(), true).substring(repository.length() + 1);
AST ast = parser.generate(filename, FileUtils.readFileToString(file, "UTF-8"),
sourceFolders.get(parser.getId()));
FileReport fr = new FileReport(ast.getFileName());
for (AbstractType type : ast.getTypes()) {
ClassReport cr = new ClassReport(type.getName(), type.getNodeType().toString());
fr.getClassesReports().put(type.getName(), cr);
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = new MethodReport(method.getName());
cr.getMethodsReports().put(method.getName(), mr);
}
}
projectReport.addFileReport(fr);
for (CodeMetric metric : metricsToCalculate.values()) {
metric.calculate(ast, fr, projectReport);
}
}
private void persistData(ObjectId analysisReportId, Commit commit, ObjectId repoId, String reference) {
CodeAnalysisDAO dao = new CodeAnalysisDAO();
List<Document> documents = new ArrayList<>();
int i = 0;
for (FileReport fr : projectReport.getAllFiles()) {
Document doc = fr.toDocument();
doc.append("analysis_report", analysisReportId).
append("reference", reference).
append("commit", commit.getHash()).
append("commit_date", commit.getCommitterDate()).
append("repository", repoId);
documents.add(doc);
if (i == 1000) {
i = 0;
dao.insertMany(documents);
documents.clear();
}
i++;
}
if (documents.size() > 0) {
dao.insertMany(documents);
}
}
// Check if the metric requisites are being calculated in the correct order.
private void visitMetric(CodeMetric codeMetric) {
if (codeMetric.getRequiredMetrics() != null) {
for (CodeMetricId id : codeMetric.getRequiredMetrics()) {
if (!metricsToCalculate.containsKey(id)) {
visitMetric(MetricFactory.getMetric(id));
}
}
}
if (!metricsToCalculate.containsKey(codeMetric.getId())) {
metricsToCalculate.put(codeMetric.getId(), codeMetric);
}
}
// checks if the code smells are being detected in the correct order based on
// theirs requisites, and also make sure that the needed metrics were calculated too.
private void visitCodeSmell(CodeSmell codeSmellParam) {
if (codeSmellParam.getRequiredMetrics() != null) {
for (CodeMetricId id : codeSmellParam.getRequiredMetrics()) {
visitMetric(MetricFactory.getMetric(id));
}
}
if (codeSmellParam.getRequiredCodeSmells() != null) {
for (CodeSmellId id : codeSmellParam.getRequiredCodeSmells()) {
if (!codeSmellsToDetect.containsKey(id)) {
visitCodeSmell(CodeSmellFactory.getCodeSmell(id));
}
}
}
if (!codeSmellsToDetect.containsKey(codeSmellParam.getId())) {
codeSmellsToDetect.put(codeSmellParam.getId(), codeSmellParam);
}
}
}
| 6,408
| 30.727723
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/MetricsConfig.java
|
package org.repositoryminer.metrics;
import java.util.List;
import org.repositoryminer.metrics.codemetric.CodeMetric;
import org.repositoryminer.metrics.codesmell.CodeSmell;
import org.repositoryminer.metrics.parser.Parser;
public class MetricsConfig {
private List<Parser> parsers;
private List<CodeMetric> codeMetrics;
private List<CodeSmell> codeSmells;
public MetricsConfig() {}
public MetricsConfig(List<Parser> parsers, List<CodeMetric> codeMetrics, List<CodeSmell> codeSmells) {
this.parsers = parsers;
this.codeMetrics = codeMetrics;
this.codeSmells = codeSmells;
}
public boolean isValid() {
return isValidParam(parsers) && (isValidParam(codeMetrics) || isValidParam(codeSmells));
}
private boolean isValidParam(List<?> list) {
if (list != null && list.size() > 0) {
return true;
}
return false;
}
public List<Parser> getParsers() {
return parsers;
}
public void setParsers(List<Parser> parsers) {
this.parsers = parsers;
}
public List<CodeMetric> getCodeMetrics() {
return codeMetrics;
}
public void setCodeMetrics(List<CodeMetric> codeMetrics) {
this.codeMetrics = codeMetrics;
}
public List<CodeSmell> getCodeSmells() {
return codeSmells;
}
public void setCodeSmells(List<CodeSmell> codeSmells) {
this.codeSmells = codeSmells;
}
}
| 1,308
| 21.568966
| 103
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/RepositoryMinerMetrics.java
|
package org.repositoryminer.metrics;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.repositoryminer.RepositoryMinerException;
import org.repositoryminer.domain.Commit;
import org.repositoryminer.metrics.codemetric.CodeMetric;
import org.repositoryminer.metrics.codesmell.CodeSmell;
import org.repositoryminer.metrics.parser.Parser;
import org.repositoryminer.metrics.persistence.CodeAnalysisReportDAO;
import org.repositoryminer.metrics.persistence.CodeAnalysisDAO;
import org.repositoryminer.plugin.SnapshotAnalysisPlugin;
import com.mongodb.client.model.Projections;
public class RepositoryMinerMetrics extends SnapshotAnalysisPlugin<MetricsConfig> {
@Override
public void run(String snapshot, MetricsConfig config) {
if (!config.isValid()) {
throw new RepositoryMinerException(
"Invalid configuration, check if has parser and code metrics or codes mells.");
}
scm.checkout(snapshot);
Commit commit = scm.resolve(snapshot);
checkDuplicatedAnalysis(commit.getHash());
AnalysisRunner runner = new AnalysisRunner(tmpRepository);
runner.setCodeMetrics(config.getCodeMetrics());
runner.setCodeSmells(config.getCodeSmells());
runner.setParsers(config.getParsers());
ObjectId reportId = persistAnalysisReport(snapshot, config.getParsers(), runner.getCalculatedMetrics(),
runner.getDetectedCodeSmells(), commit);
try {
runner.run(reportId, commit, repositoryId, snapshot);
} catch (IOException e) {
throw new RepositoryMinerException(e);
}
}
private void checkDuplicatedAnalysis(String hash) {
CodeAnalysisReportDAO configDao = new CodeAnalysisReportDAO();
Document doc = configDao.findByCommitHash(hash, Projections.include("_id"));
if (doc != null) {
configDao.deleteById(doc.getObjectId("_id"));
new CodeAnalysisDAO().deleteByReport(doc.getObjectId("_id"));
}
}
private ObjectId persistAnalysisReport(String reference, List<Parser> usedParsers,
Collection<CodeMetric> calculatedMetrics, Collection<CodeSmell> detectedCodeSmells, Commit commit) {
CodeAnalysisReportDAO configDao = new CodeAnalysisReportDAO();
List<String> metricsNames = new ArrayList<>();
for (CodeMetric cm : calculatedMetrics) {
metricsNames.add(cm.getId().name());
}
List<String> parsersNames = new ArrayList<>();
for (Parser p : usedParsers) {
parsersNames.add(p.getId().name());
}
List<Document> codeSmellsDoc = new ArrayList<>();
for (CodeSmell codeSmell : detectedCodeSmells) {
codeSmellsDoc.add(new Document("codesmell", codeSmell.getId().name()).append("thresholds",
codeSmell.getThresholds()));
}
Document doc = new Document();
doc.append("reference", reference).
append("commit", commit.getHash()).
append("commit_date", commit.getCommitterDate()).
append("analysis_date", new Date(System.currentTimeMillis())).
append("repository", repositoryId).
append("parsers", parsersNames).
append("metrics", metricsNames).
append("codesmells", codeSmellsDoc);
configDao.insert(doc);
return doc.getObjectId("_id");
}
}
| 3,189
| 32.93617
| 105
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/report/ProjectReport.java
|
package org.repositoryminer.metrics.report;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class ProjectReport {
private Map<String, FileReport> files = new HashMap<>();
private Map<String, ClassReport> orphanClasses = new HashMap<>();
public Collection<FileReport> getAllFiles() {
return files.values();
}
public ClassReport getClassByName(String name) {
for (FileReport fr : files.values()) {
ClassReport cr = fr.getClassesReports().get(name);
if (cr != null) {
return cr;
}
}
ClassReport cr = orphanClasses.get(name);
if (cr == null) {
cr = new ClassReport(name);
orphanClasses.put(name, cr);
}
return cr;
}
public FileReport getFileByName(String name) {
return files.get(name);
}
public void addFileReport(FileReport fileReport) {
files.put(fileReport.getName(), fileReport);
if (orphanClasses.isEmpty()) {
return;
}
for (ClassReport cr : fileReport.getClassesReports().values()) {
ClassReport orphanClass = orphanClasses.get(cr.getName());
if (orphanClass != null) {
orphanClasses.remove(cr.getName());
cr.setMetricsReport(orphanClass.getMetricsReport());
for (MethodReport mr : cr.getMethodsReports().values()) {
MethodReport orphanMethod = orphanClass.getMethodsReports().get(mr.getName());
if (orphanMethod != null) {
orphanClass.getMethodsReports().remove(mr.getName());
mr.setMetricsReport(orphanMethod.getMetricsReport());
}
}
}
}
}
}
| 1,517
| 24.3
| 83
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/report/MethodReport.java
|
package org.repositoryminer.metrics.report;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.bson.Document;
public class MethodReport {
private String name;
private MetricsReport metricsReport = new MetricsReport();
public MethodReport(String signature) {
this.name = signature;
}
public Document toDocument() {
Document doc = new Document("name", name).
append("metrics", metricsReport.toMetricsDocument()).
append("codesmells", metricsReport.getCodeSmellsAsString());
return doc;
}
public static Object toDocumentList(Collection<MethodReport> values) {
List<Document> docs = new ArrayList<>();
for (MethodReport mr : values) {
docs.add(mr.toDocument());
}
return docs;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public MetricsReport getMetricsReport() {
return metricsReport;
}
public void setMetricsReport(MetricsReport metricsReport) {
this.metricsReport = metricsReport;
}
}
| 1,041
| 20.265306
| 71
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/report/ClassReport.java
|
package org.repositoryminer.metrics.report;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.bson.Document;
public class ClassReport {
private String name;
private String type;
private Map<String, MethodReport> methodsReports = new HashMap<>();
private MetricsReport metricsReport = new MetricsReport();
public ClassReport(String name) {
this.name = name;
}
public ClassReport(String name, String type) {
this.name = name;
this.type = type;
}
public Collection<MethodReport> getMethods() {
return methodsReports.values();
}
public MethodReport getMethodBySignature(String signature) {
MethodReport mr = methodsReports.get(signature);
if (mr == null) {
mr = new MethodReport(signature);
methodsReports.put(signature, mr);
}
return mr;
}
public Document toDocument() {
Document doc = new Document("name", name).
append("type", type).
append("metrics", metricsReport.toMetricsDocument()).
append("codesmells", metricsReport.getCodeSmellsAsString()).
append("methods", MethodReport.toDocumentList(methodsReports.values()));
return doc;
}
public static Object toDocumentList(Collection<ClassReport> values) {
List<Document> docs = new ArrayList<>();
for (ClassReport cr : values) {
docs.add(cr.toDocument());
}
return docs;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Map<String, MethodReport> getMethodsReports() {
return methodsReports;
}
public void setMethodsReports(Map<String, MethodReport> methodsReports) {
this.methodsReports = methodsReports;
}
public MetricsReport getMetricsReport() {
return metricsReport;
}
public void setMetricsReport(MetricsReport metricsReport) {
this.metricsReport = metricsReport;
}
}
| 1,985
| 21.314607
| 76
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/report/FileReport.java
|
package org.repositoryminer.metrics.report;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.bson.Document;
import org.repositoryminer.util.StringUtils;
public class FileReport {
private String name;
private Map<String, ClassReport> classesReports = new HashMap<>();
private MetricsReport metricsReport = new MetricsReport();
public ClassReport getClass(String name) {
ClassReport cr = classesReports.get(name);
if (cr == null) {
cr = new ClassReport(name);
classesReports.put(name, cr);
}
return cr;
}
public Collection<ClassReport> getClasses() {
return classesReports.values();
}
public Document toDocument() {
Document doc = new Document();
doc.append("filename", name).
append("filehash", StringUtils.encodeToCRC32(name)).
append("metrics", metricsReport.toMetricsDocument()).
append("classes", ClassReport.toDocumentList(classesReports.values()));
return doc;
}
public FileReport(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<String, ClassReport> getClassesReports() {
return classesReports;
}
public void setClassesReports(Map<String, ClassReport> classesReports) {
this.classesReports = classesReports;
}
public MetricsReport getMetricsReport() {
return metricsReport;
}
public void setMetricsReport(MetricsReport metricsReport) {
this.metricsReport = metricsReport;
}
}
| 1,497
| 21.69697
| 74
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/report/MetricsReport.java
|
package org.repositoryminer.metrics.report;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.bson.Document;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.codesmell.CodeSmellId;
public class MetricsReport {
private Map<CodeMetricId, Number> codeMetrics = new HashMap<>();
private Set<CodeSmellId> codeSmells = new HashSet<>();
public List<Document> toMetricsDocument() {
List<Document> documents = new ArrayList<Document>();
for (Entry<CodeMetricId, Number> entry : codeMetrics.entrySet()) {
documents.add(new Document("name", entry.getKey().name()).append("value", entry.getValue()));
}
return documents;
}
public List<String> getCodeSmellsAsString() {
List<String> list = new ArrayList<String>();
for (CodeSmellId id : codeSmells) {
list.add(id.name());
}
return list;
}
public boolean hasCodeSmell(CodeSmellId id) {
return codeSmells.contains(id);
}
public boolean hasCodeMetric(CodeMetricId id) {
return codeMetrics.containsKey(id);
}
public Number getCodeMetric(CodeMetricId id) {
return codeMetrics.get(id);
}
public <T extends Number> T getCodeMetric(CodeMetricId id, Class<T> type) {
return type.cast(codeMetrics.get(id));
}
public void setCodeMetric(CodeMetricId id, Number value) {
codeMetrics.put(id, value);
}
public void setCodeSmell(CodeSmellId id) {
codeSmells.add(id);
}
public void addOneToCodeMetric(CodeMetricId id) {
updateMetric(id, 1);
}
public void updateMetric(CodeMetricId id, int value) {
int newValue = value;
if (codeMetrics.containsKey(id)) {
newValue += codeMetrics.get(id).intValue();
}
codeMetrics.put(id, newValue);
}
public void updateMetric(CodeMetricId id, long value) {
long newValue = value;
if (codeMetrics.containsKey(id)) {
newValue += codeMetrics.get(id).longValue();
}
codeMetrics.put(id, newValue);
}
public void updateMetric(CodeMetricId id, float value) {
float newValue = value;
if (codeMetrics.containsKey(id)) {
newValue += codeMetrics.get(id).floatValue();
}
codeMetrics.put(id, newValue);
}
public void updateMetric(CodeMetricId id, double value) {
double newValue = value;
if (codeMetrics.containsKey(id)) {
newValue += codeMetrics.get(id).doubleValue();
}
codeMetrics.put(id, newValue);
}
public Map<CodeMetricId, Number> getCodeMetrics() {
return codeMetrics;
}
public void setCodeMetrics(Map<CodeMetricId, Number> codeMetrics) {
this.codeMetrics = codeMetrics;
}
public Set<CodeSmellId> getCodeSmells() {
return codeSmells;
}
public void setCodeSmells(Set<CodeSmellId> codeSmells) {
this.codeSmells = codeSmells;
}
}
| 2,802
| 24.026786
| 96
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractEnumConstant.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
/**
* This class represents an enum constant.
*/
public class AbstractEnumConstant {
private String name;
private List<String> arguments;
public AbstractEnumConstant() {
}
public AbstractEnumConstant(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getArguments() {
return arguments;
}
public void setArguments(List<String> arguments) {
this.arguments = arguments;
}
}
| 572
| 14.916667
| 51
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AST.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
import org.repositoryminer.metrics.parser.Language;
/**
* This class represents the file and is also the Abstract Syntax Tree root
* node.
*/
public class AST {
private String filename;
private String source;
private Language language;
private List<AbstractType> types;
private List<AbstractImport> imports;
private String packageDeclaration;
public String getFileName() {
return filename;
}
public void setFileName(String filename) {
this.filename = filename;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public Language getLanguage() {
return language;
}
public void setLanguage(Language language) {
this.language = language;
}
public List<AbstractType> getTypes() {
return types;
}
public void setTypes(List<AbstractType> types) {
this.types = types;
}
public List<AbstractImport> getImports() {
return imports;
}
public void setImports(List<AbstractImport> imports) {
this.imports = imports;
}
public String getPackageDeclaration() {
return packageDeclaration;
}
public void setPackageDeclaration(String packageDeclaration) {
this.packageDeclaration = packageDeclaration;
}
}
| 1,282
| 17.867647
| 75
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractEnum.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
/**
* This class represents an enum.
*/
public class AbstractEnum extends AbstractType {
private List<AbstractEnumConstant> constants;
public AbstractEnum() {
setNodeType(NodeType.ENUM_DECLARATION);
}
public List<AbstractEnumConstant> getConstants() {
return constants;
}
public void setConstants(List<AbstractEnumConstant> constants) {
this.constants = constants;
}
}
| 454
| 17.958333
| 65
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractParameter.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents a parameter declaration.
*/
public class AbstractParameter {
private String type;
private String name;
public AbstractParameter() {
}
public AbstractParameter(String type, String name) {
this.type = type;
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
| 524
| 14
| 53
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractFieldAccess.java
|
package org.repositoryminer.metrics.ast;
public class AbstractFieldAccess extends AbstractStatement {
private String type;
private String declaringClass;
private boolean primitive;
private boolean builtIn;
public AbstractFieldAccess() {
super(NodeType.FIELD_ACCESS);
}
public AbstractFieldAccess(String expression, String type, String declaringClass, boolean primitive,
boolean builtIn) {
this();
setExpression(expression);
this.type = type;
this.declaringClass = declaringClass;
this.primitive = primitive;
this.builtIn = builtIn;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getDeclaringClass() {
return declaringClass;
}
public void setDeclaringClass(String declaringClass) {
this.declaringClass = declaringClass;
}
public boolean isPrimitive() {
return primitive;
}
public void setPrimitive(boolean primitive) {
this.primitive = primitive;
}
public boolean isBuiltIn() {
return builtIn;
}
public void setBuiltIn(boolean builtIn) {
this.builtIn = builtIn;
}
}
| 1,099
| 18.642857
| 101
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/NodeType.java
|
package org.repositoryminer.metrics.ast;
/**
* This enum contains the node types.
*/
public enum NodeType {
RETURN,
IF,
ELSE,
SWITCH,
SWITCH_CASE,
SWITCH_DEFAULT,
FOR,
DO_WHILE,
WHILE,
BREAK,
CONTINUE,
TRY,
CATCH,
FINALLY,
THROW,
CONDITIONAL_EXPRESSION,
EXPRESSION,
METHOD_INVOCATION,
FIELD_ACCESS,
VARIABLE_DECLARATION,
CLASS_DECLARATION,
ENUM_DECLARATION,
ANNOTATION_DECLARATION;
}
| 410
| 12.258065
| 40
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractType.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
/**
* This class represents an abstract type declaration.
*
* @see AbstractClass
*/
public class AbstractType {
private String name;
private int startPosition;
private int endPosition;
private NodeType nodeType;
private List<AbstractMethod> methods;
private List<AbstractField> fields;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStartPosition() {
return startPosition;
}
public void setStartPosition(int startPosition) {
this.startPosition = startPosition;
}
public int getEndPosition() {
return endPosition;
}
public void setEndPosition(int endPosition) {
this.endPosition = endPosition;
}
public NodeType getNodeType() {
return nodeType;
}
public void setNodeType(NodeType nodeType) {
this.nodeType = nodeType;
}
public List<AbstractMethod> getMethods() {
return methods;
}
public void setMethods(List<AbstractMethod> methods) {
this.methods = methods;
}
public List<AbstractField> getFields() {
return fields;
}
public void setFields(List<AbstractField> fields) {
this.fields = fields;
}
}
| 1,198
| 16.895522
| 55
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractVariableDeclaration.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents a local variable declaration.
*/
public class AbstractVariableDeclaration extends AbstractStatement {
private String type;
private String initializer;
public AbstractVariableDeclaration() {
super(NodeType.VARIABLE_DECLARATION);
}
public AbstractVariableDeclaration(String expression, String type, String initializer) {
this();
setExpression(expression);
this.type = type;
this.initializer = initializer;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getInitializer() {
return initializer;
}
public void setInitializer(String initializer) {
this.initializer = initializer;
}
}
| 753
| 18.842105
| 89
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractAnnotation.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
/**
* This class represents an annotation.
*/
public class AbstractAnnotation extends AbstractType {
private List<AbstractAnnotationMember> members;
public AbstractAnnotation() {
setNodeType(NodeType.ANNOTATION_DECLARATION);
}
public List<AbstractAnnotationMember> getMembers() {
return members;
}
public void setMembers(List<AbstractAnnotationMember> members) {
this.members = members;
}
}
| 476
| 18.875
| 65
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractClass.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents a concrete class or an interface.
*/
public class AbstractClass extends AbstractType {
private boolean isInterface;
private String superClass;
public AbstractClass() {
setNodeType(NodeType.CLASS_DECLARATION);
}
public boolean isInterface() {
return isInterface;
}
public void setInterface(boolean isInterface) {
this.isInterface = isInterface;
}
public String getSuperClass() {
return superClass;
}
public void setSuperClass(String superClass) {
this.superClass = superClass;
}
}
| 580
| 17.741935
| 58
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractAnnotationMember.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents an annotation member.
*/
public class AbstractAnnotationMember {
private String type;
private String name;
private String defaultExpression;
public AbstractAnnotationMember() {
}
public AbstractAnnotationMember(String type, String name) {
this.type = type;
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDefaultExpression() {
return defaultExpression;
}
public void setDefaultExpression(String defaultExpression) {
this.defaultExpression = defaultExpression;
}
}
| 761
| 16.318182
| 61
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractMethod.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
/**
* This class represents a method declaration.
*/
public class AbstractMethod {
private String name;
private int startPosition;
private int endPosition;
private String returnType;
private boolean isConstructor;
private boolean isVarargs;
private List<String> modifiers;
private List<AbstractStatement> statements;
private List<AbstractParameter> parameters;
private List<String> thrownsExceptions;
private int maxDepth;
private boolean accessor;
private String accessoredField;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStartPosition() {
return startPosition;
}
public void setStartPosition(int startPosition) {
this.startPosition = startPosition;
}
public int getEndPosition() {
return endPosition;
}
public void setEndPosition(int endPosition) {
this.endPosition = endPosition;
}
public String getReturnType() {
return returnType;
}
public void setReturnType(String returnType) {
this.returnType = returnType;
}
public boolean isConstructor() {
return isConstructor;
}
public void setConstructor(boolean isConstructor) {
this.isConstructor = isConstructor;
}
public boolean isVarargs() {
return isVarargs;
}
public void setVarargs(boolean isVarargs) {
this.isVarargs = isVarargs;
}
public List<String> getModifiers() {
return modifiers;
}
public void setModifiers(List<String> modifiers) {
this.modifiers = modifiers;
}
public List<AbstractStatement> getStatements() {
return statements;
}
public void setStatements(List<AbstractStatement> statements) {
this.statements = statements;
}
public List<AbstractParameter> getParameters() {
return parameters;
}
public void setParameters(List<AbstractParameter> parameters) {
this.parameters = parameters;
}
public List<String> getThrownsExceptions() {
return thrownsExceptions;
}
public void setThrownsExceptions(List<String> thrownsExceptions) {
this.thrownsExceptions = thrownsExceptions;
}
public int getMaxDepth() {
return maxDepth;
}
public void setMaxDepth(int maxDepth) {
this.maxDepth = maxDepth;
}
public boolean isAccessor() {
return accessor;
}
public void setAccessor(boolean accessor) {
this.accessor = accessor;
}
public String getAccessoredField() {
return accessoredField;
}
public void setAccessoredField(String accessoredField) {
this.accessoredField = accessoredField;
}
}
| 2,522
| 18.710938
| 67
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractMethodInvocation.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents a method invocation.
*/
public class AbstractMethodInvocation extends AbstractStatement {
private String declaringClass;
private boolean accessor;
private String accessedField;
public AbstractMethodInvocation() {
super(NodeType.METHOD_INVOCATION);
}
public AbstractMethodInvocation(String expression, String declaringClass, boolean accessor, String accessedField) {
this();
setExpression(expression);
this.declaringClass = declaringClass;
this.accessor = accessor;
this.accessedField = accessedField;
}
public String getDeclaringClass() {
return declaringClass;
}
public void setDeclaringClass(String declaringClass) {
this.declaringClass = declaringClass;
}
public boolean isAccessor() {
return accessor;
}
public void setAccessor(boolean accessor) {
this.accessor = accessor;
}
public String getAccessedField() {
return accessedField;
}
public void setAccessedField(String accessedField) {
this.accessedField = accessedField;
}
}
| 1,056
| 21.020833
| 116
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractStatement.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents a generic statement.
*/
public class AbstractStatement {
private NodeType nodeType;
private String expression;
public AbstractStatement(NodeType nodeType) {
this.nodeType = nodeType;
}
public AbstractStatement(NodeType nodeType, String expression) {
this.nodeType = nodeType;
this.expression = expression;
}
public NodeType getNodeType() {
return nodeType;
}
public void setNodeType(NodeType nodeType) {
this.nodeType = nodeType;
}
public String getExpression() {
return expression;
}
public void setExpression(String expression) {
this.expression = expression;
}
}
| 673
| 17.722222
| 65
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractImport.java
|
package org.repositoryminer.metrics.ast;
/**
* This class represents a import declaration.
*/
public class AbstractImport {
private String name;
private boolean isStatic;
private boolean isOnDemand;
public AbstractImport() {
}
public AbstractImport(String name, boolean isStatic, boolean isOnDemand) {
this.name = name;
this.isStatic = isStatic;
this.isOnDemand = isOnDemand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isStatic() {
return isStatic;
}
public void setStatic(boolean isStatic) {
this.isStatic = isStatic;
}
public boolean isOnDemand() {
return isOnDemand;
}
public void setOnDemand(boolean isOnDemand) {
this.isOnDemand = isOnDemand;
}
}
| 771
| 16.155556
| 75
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/ast/AbstractField.java
|
package org.repositoryminer.metrics.ast;
import java.util.List;
/**
* This class represents a class field.
*/
public class AbstractField {
private String name;
private String type;
private List<String> modifiers;
private boolean primitive;
private boolean builtIn;
public AbstractField() {
}
public AbstractField(String name, String type, List<String> modifiers, boolean primitive, boolean builtIn) {
this.name = name;
this.type = type;
this.modifiers = modifiers;
this.primitive = primitive;
this.builtIn = builtIn;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public List<String> getModifiers() {
return modifiers;
}
public void setModifiers(List<String> modifiers) {
this.modifiers = modifiers;
}
public boolean isPrimitive() {
return primitive;
}
public void setPrimitive(boolean primitive) {
this.primitive = primitive;
}
public boolean isBuiltIn() {
return builtIn;
}
public void setBuiltIn(boolean builtIn) {
this.builtIn = builtIn;
}
}
| 1,169
| 16.462687
| 109
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/CodeSmellId.java
|
package org.repositoryminer.metrics.codesmell;
public enum CodeSmellId {
BRAIN_CLASS, BRAIN_METHOD, COMPLEX_METHOD, GOD_CLASS, LONG_METHOD, REFUSED_PARENT_BEQUEST, DATA_CLASS, DEPTH_OF_INHERITANCE_TREE, FEATURE_ENVY;
}
| 222
| 30.857143
| 144
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/CodeSmell.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.Map;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public abstract class CodeSmell {
protected CodeSmellId id;
protected Map<String, Number> thresholds;
protected CodeMetricId[] requiredMetrics;
protected CodeSmellId[] requiredCodesmells;
/**
* Detects the code smell and stores the result in the ast.
*
* @param ast
*/
public abstract void detect(FileReport fileReport, ProjectReport projectReport);
/**
* @return the code smell identifier.
*/
public CodeSmellId getId() {
return id;
}
/**
* A code smell/code metric id name should be used as key and the threshold as the value.
* @return a map containing the thresholds values used by the code smell.
*/
public Map<String, Number> getThresholds() {
return thresholds;
}
/**
* @return the required metrics.
*/
public CodeMetricId[] getRequiredMetrics() {
return requiredMetrics;
}
/**
* @return the required code smells.
*/
public CodeSmellId[] getRequiredCodeSmells() {
return requiredCodesmells;
}
}
| 1,206
| 22.211538
| 90
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/CodeSmellFactory.java
|
package org.repositoryminer.metrics.codesmell;
public class CodeSmellFactory {
public static CodeSmell getCodeSmell(CodeSmellId id) {
switch (id) {
case BRAIN_CLASS:
return new BrainClass();
case BRAIN_METHOD:
return new BrainMethod();
case COMPLEX_METHOD:
return new ComplexMethod();
case DATA_CLASS:
return new DataClass();
case FEATURE_ENVY:
return new FeatureEnvy();
case GOD_CLASS:
return new GodClass();
case LONG_METHOD:
return new LongMethod();
default:
return null;
}
}
}
| 530
| 18.666667
| 55
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/ComplexMethod.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class ComplexMethod extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.CYCLO };
private int cycloThreshold = 10;
public ComplexMethod() {
init();
}
public ComplexMethod(int cycloThreshold) {
this.cycloThreshold = cycloThreshold;
init();
}
private void init() {
super.id = CodeSmellId.COMPLEX_METHOD;
super.requiredMetrics = REQUIRED_METRICS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.CYCLO.name(), cycloThreshold);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
for (MethodReport mr : cr.getMethods()) {
int cyclo = mr.getMetricsReport().getCodeMetric(CodeMetricId.CYCLO, Integer.class);
if (cyclo > cycloThreshold) {
mr.getMetricsReport().setCodeSmell(CodeSmellId.COMPLEX_METHOD);
}
}
}
}
/*** GETTERS AND SETTERS ***/
public int getCycloThreshold() {
return cycloThreshold;
}
public void setCycloThreshold(int cycloThreshold) {
this.cycloThreshold = cycloThreshold;
}
}
| 1,465
| 25.178571
| 87
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/LongMethod.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class LongMethod extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.LOC };
private int mlocThreshold = 65;
public LongMethod() {
init();
}
public LongMethod(int mlocThreshold) {
this.mlocThreshold = mlocThreshold;
init();
}
private void init() {
super.id = CodeSmellId.LONG_METHOD;
super.requiredMetrics = REQUIRED_METRICS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.LOC.name(), mlocThreshold);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
for (MethodReport mr : cr.getMethods()) {
int loc = mr.getMetricsReport().getCodeMetric(CodeMetricId.LOC, Integer.class);
if (loc > mlocThreshold) {
mr.getMetricsReport().setCodeSmell(CodeSmellId.LONG_METHOD);
}
}
}
}
/*** GETTERS AND SETTERS ***/
public int getMlocThreshold() {
return mlocThreshold;
}
public void setMlocThreshold(int mlocThreshold) {
this.mlocThreshold = mlocThreshold;
}
}
| 1,428
| 24.517857
| 83
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/BrainMethod.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class BrainMethod extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.LOC, CodeMetricId.CYCLO, CodeMetricId.NOAV,
CodeMetricId.MAXNESTING };
private int locThreshold = 65;
private float ccThreshold = 7;
private int maxNestingThreshold = 5;
private int noavThreshold = 8;
public BrainMethod() {
init();
}
public BrainMethod(int mlocThreshold, float ccThreshold, int maxNestingThreshold, int noavThreshold) {
this.locThreshold = mlocThreshold;
this.ccThreshold = ccThreshold;
this.maxNestingThreshold = maxNestingThreshold;
this.noavThreshold = noavThreshold;
init();
}
private void init() {
super.id = CodeSmellId.BRAIN_METHOD;
super.requiredMetrics = REQUIRED_METRICS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.LOC.name(), locThreshold);
super.thresholds.put(CodeMetricId.CYCLO.name(), ccThreshold);
super.thresholds.put(CodeMetricId.NOAV.name(), noavThreshold);
super.thresholds.put(CodeMetricId.MAXNESTING.name(), maxNestingThreshold);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
for (MethodReport mr : cr.getMethods()) {
int mloc = mr.getMetricsReport().getCodeMetric(CodeMetricId.LOC, Integer.class);
int cyclo = mr.getMetricsReport().getCodeMetric(CodeMetricId.CYCLO, Integer.class);
int noav = mr.getMetricsReport().getCodeMetric(CodeMetricId.NOAV, Integer.class);
int maxnesting = mr.getMetricsReport().getCodeMetric(CodeMetricId.MAXNESTING, Integer.class);
if (detect(cyclo, mloc, noav, maxnesting)) {
mr.getMetricsReport().setCodeSmell(CodeSmellId.BRAIN_METHOD);
}
}
}
}
public boolean detect(int cc, int mloc, int noav, int maxNesting) {
return mloc > locThreshold && cc > ccThreshold && maxNesting >= maxNestingThreshold && noav > noavThreshold;
}
/*** GETTERS AND SETTERS ***/
public int getMlocThreshold() {
return locThreshold;
}
public void setMlocThreshold(int mlocThreshold) {
this.locThreshold = mlocThreshold;
}
public float getCcThreshold() {
return ccThreshold;
}
public void setCcThreshold(float ccThreshold) {
this.ccThreshold = ccThreshold;
}
public int getMaxNestingThreshold() {
return maxNestingThreshold;
}
public void setMaxNestingThreshold(int maxNestingThreshold) {
this.maxNestingThreshold = maxNestingThreshold;
}
public int getNoavThreshold() {
return noavThreshold;
}
public void setNoavThreshold(int noavThreshold) {
this.noavThreshold = noavThreshold;
}
}
| 2,953
| 29.453608
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/DataClass.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class DataClass extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.WOC, CodeMetricId.NOPA, CodeMetricId.NOAM, CodeMetricId.WMC };
private double wocThreshold = 0.33;
private int wmcThreshold1 = 31;
private int wmcThreshold2 = 47;
private int publicMembersThreshold1 = 5;
private int publicMembersThreshold2 = 8;
public DataClass() {
init();
}
public DataClass(double wocThreshold, int wmcThreshold1, int wmcThreshold2, int publicMembersThreshold1, int publicMembersThreshold2) {
this.wocThreshold = wocThreshold;
this.wmcThreshold1 = wmcThreshold1;
this.wmcThreshold2 = wmcThreshold2;
this.publicMembersThreshold1 = publicMembersThreshold1;
this.publicMembersThreshold2 = publicMembersThreshold2;
init();
}
public void init() {
super.id = CodeSmellId.DATA_CLASS;
super.requiredMetrics = REQUIRED_METRICS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.WOC.name(), wocThreshold);
super.thresholds.put(CodeMetricId.WMC.name()+"(1)", wmcThreshold1);
super.thresholds.put(CodeMetricId.WMC.name()+"(2)", wmcThreshold2);
super.thresholds.put(CodeMetricId.NOPA.name()+"+"+CodeMetricId.NOAM.name()+"(1)", publicMembersThreshold1);
super.thresholds.put(CodeMetricId.NOPA.name()+"+"+CodeMetricId.NOAM.name()+"(2)", publicMembersThreshold2);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
double woc = cr.getMetricsReport().getCodeMetric(CodeMetricId.WOC, Double.class);
int nopa = cr.getMetricsReport().getCodeMetric(CodeMetricId.NOPA, Integer.class);
int noam = cr.getMetricsReport().getCodeMetric(CodeMetricId.NOAM, Integer.class);
int wmc = cr.getMetricsReport().getCodeMetric(CodeMetricId.WMC, Integer.class);
if (detect(woc, nopa, noam, wmc)) {
cr.getMetricsReport().setCodeSmell(CodeSmellId.DATA_CLASS);
}
}
}
private boolean detect(double woc, int nopa, int noam, int wmc) {
int publicMembers = nopa + noam;
boolean offerManyData = woc < wocThreshold;
boolean isNotComplex = (publicMembers > publicMembersThreshold1 && wmc < wmcThreshold1)
|| (publicMembers > publicMembersThreshold2 && wmc < wmcThreshold2);
return offerManyData && isNotComplex;
}
/*** GETTERS AND SETTERS ***/
public double getWocThreshold() {
return wocThreshold;
}
public void setWocThreshold(double wocThreshold) {
this.wocThreshold = wocThreshold;
}
public int getWmcThreshold1() {
return wmcThreshold1;
}
public void setWmcThreshold1(int wmcThreshold1) {
this.wmcThreshold1 = wmcThreshold1;
}
public int getWmcThreshold2() {
return wmcThreshold2;
}
public void setWmcThreshold2(int wmcThreshold2) {
this.wmcThreshold2 = wmcThreshold2;
}
public int getPublicMembersThreshold1() {
return publicMembersThreshold1;
}
public void setPublicMembersThreshold1(int publicMembersThreshold1) {
this.publicMembersThreshold1 = publicMembersThreshold1;
}
public int getPublicMembersThreshold2() {
return publicMembersThreshold2;
}
public void setPublicMembersThreshold2(int publicMembersThreshold2) {
this.publicMembersThreshold2 = publicMembersThreshold2;
}
}
| 3,524
| 31.638889
| 136
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/FeatureEnvy.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class FeatureEnvy extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.LAA, CodeMetricId.ATFD, CodeMetricId.FDP };
private double laaThreshold = 0.33;
private int atfdThreshold = 5;
private int fdpThreshold = 5;
public FeatureEnvy() {
init();
}
public FeatureEnvy(double laaThreshold, int atfdThreshold, int fdpThreshold) {
this.laaThreshold = laaThreshold;
this.atfdThreshold = atfdThreshold;
this.fdpThreshold = fdpThreshold;
init();
}
private void init() {
super.id = CodeSmellId.FEATURE_ENVY;
super.requiredMetrics = REQUIRED_METRICS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.LAA.name(), laaThreshold);
super.thresholds.put(CodeMetricId.FDP.name(), fdpThreshold);
super.thresholds.put(CodeMetricId.ATFD.name(), atfdThreshold);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
for (MethodReport mr : cr.getMethods()) {
double laa = mr.getMetricsReport().getCodeMetric(CodeMetricId.LAA, Double.class);
int fdp = mr.getMetricsReport().getCodeMetric(CodeMetricId.FDP, Integer.class);
int atfd = mr.getMetricsReport().getCodeMetric(CodeMetricId.ATFD, Integer.class);
if (detect(laa, atfd, fdp)) {
mr.getMetricsReport().setCodeSmell(CodeSmellId.FEATURE_ENVY);
}
}
}
}
private boolean detect(double laaValue, int atfdValue, int fdpValue) {
return (atfdValue > atfdThreshold) && (laaValue < laaThreshold) && (fdpValue <= fdpThreshold);
}
/*** GETTERS AND SETTERS ***/
public double getLaaThreshold() {
return laaThreshold;
}
public void setLaaThreshold(double laaThreshold) {
this.laaThreshold = laaThreshold;
}
public int getAtfdThreshold() {
return atfdThreshold;
}
public void setAtfdThreshold(int atfdThreshold) {
this.atfdThreshold = atfdThreshold;
}
public int getFdpThreshold() {
return fdpThreshold;
}
public void setFdpThreshold(int fdpThreshold) {
this.fdpThreshold = fdpThreshold;
}
}
| 2,425
| 27.880952
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/BrainClass.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class BrainClass extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.WMC, CodeMetricId.TCC, CodeMetricId.LOC };
private static final CodeSmellId[] REQUIRED_CODESMELLS = { CodeSmellId.BRAIN_METHOD };
private int wmcThreshold = 47;
private double tccThreshold = 0.5;
private int brainMethodThreshold = 1;
private int locThreshold = 195;
public BrainClass() {
init();
}
public BrainClass(int wmcThreshold, double tccThreshold, int brainMethodThreshold, int locThreshold) {
this.wmcThreshold = wmcThreshold;
this.tccThreshold = tccThreshold;
this.brainMethodThreshold = brainMethodThreshold;
this.locThreshold = locThreshold;
init();
}
private void init() {
super.id = CodeSmellId.BRAIN_CLASS;
super.requiredMetrics = REQUIRED_METRICS;
super.requiredCodesmells = REQUIRED_CODESMELLS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.WMC.name(), wmcThreshold);
super.thresholds.put(CodeMetricId.TCC.name(), tccThreshold);
super.thresholds.put(CodeMetricId.LOC.name(), locThreshold);
super.thresholds.put(CodeSmellId.BRAIN_METHOD.name(), brainMethodThreshold);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
int wmc = cr.getMetricsReport().getCodeMetric(CodeMetricId.WMC, Integer.class);
double tcc = cr.getMetricsReport().getCodeMetric(CodeMetricId.TCC, Double.class);
int loc = cr.getMetricsReport().getCodeMetric(CodeMetricId.LOC, Integer.class);
int nbm = 0;
for (MethodReport mr : cr.getMethods()) {
if (mr.getMetricsReport().hasCodeSmell(CodeSmellId.BRAIN_METHOD)) {
nbm++;
}
}
if (detect(nbm, loc, wmc, tcc)) {
cr.getMetricsReport().setCodeSmell(CodeSmellId.BRAIN_CLASS);
}
}
}
public boolean detect(int nbm, int loc, int wmc, double tcc) {
boolean exp1 = nbm > brainMethodThreshold && loc >= locThreshold;
boolean exp2 = nbm == brainMethodThreshold && loc >= (2 * locThreshold) && wmc >= (2 * wmcThreshold);
boolean exp3 = wmc >= wmcThreshold && tcc < tccThreshold;
return (exp1 || exp2) && exp3;
}
// *** GETTERS AND SETTERS ***//
public int getWmcThreshold() {
return wmcThreshold;
}
public void setWmcThreshold(int wmcThreshold) {
this.wmcThreshold = wmcThreshold;
}
public double getTccThreshold() {
return tccThreshold;
}
public void setTccThreshold(double tccThreshold) {
this.tccThreshold = tccThreshold;
}
public int getBrainMethodThreshold() {
return brainMethodThreshold;
}
public void setBrainMethodThreshold(int brainMethodThreshold) {
this.brainMethodThreshold = brainMethodThreshold;
}
public int getLocThreshold() {
return locThreshold;
}
public void setLocThreshold(int locThreshold) {
this.locThreshold = locThreshold;
}
}
| 3,206
| 29.254717
| 113
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codesmell/GodClass.java
|
package org.repositoryminer.metrics.codesmell;
import java.util.HashMap;
import org.repositoryminer.metrics.codemetric.CodeMetricId;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class GodClass extends CodeSmell {
private static final CodeMetricId[] REQUIRED_METRICS = { CodeMetricId.ATFD, CodeMetricId.WMC, CodeMetricId.TCC };
private int atfdThreshold = 5;
private int wmcThreshold = 47;
private double tccThreshold = 0.33;
public GodClass() {
init();
}
public GodClass(int atfdThreshold, int wmcThreshold, double tccThreshold) {
this.atfdThreshold = atfdThreshold;
this.wmcThreshold = wmcThreshold;
this.tccThreshold = tccThreshold;
init();
}
private void init() {
super.id = CodeSmellId.GOD_CLASS;
super.requiredMetrics = REQUIRED_METRICS;
super.thresholds = new HashMap<>();
super.thresholds.put(CodeMetricId.ATFD.name(), atfdThreshold);
super.thresholds.put(CodeMetricId.WMC.name(), wmcThreshold);
super.thresholds.put(CodeMetricId.TCC.name(), tccThreshold);
}
@Override
public void detect(FileReport fileReport, ProjectReport projectReport) {
for (ClassReport cr : fileReport.getClasses()) {
int atfd = cr.getMetricsReport().getCodeMetric(CodeMetricId.ATFD, Integer.class);
int wmc = cr.getMetricsReport().getCodeMetric(CodeMetricId.WMC, Integer.class);
double tcc = cr.getMetricsReport().getCodeMetric(CodeMetricId.TCC, Double.class);
if (detect(atfd, wmc, tcc)) {
cr.getMetricsReport().setCodeSmell(CodeSmellId.GOD_CLASS);
}
}
}
public boolean detect(int atfd, int wmc, double tcc) {
return (atfd > atfdThreshold) && (wmc >= wmcThreshold) && (tcc < tccThreshold);
}
/*** GETTERS AND SETTERS ***/
public int getAtfdThreshold() {
return atfdThreshold;
}
public void setAtfdThreshold(int atfdThreshold) {
this.atfdThreshold = atfdThreshold;
}
public int getWmcThreshold() {
return wmcThreshold;
}
public void setWmcThreshold(int wmcThreshold) {
this.wmcThreshold = wmcThreshold;
}
public double getTccThreshold() {
return tccThreshold;
}
public void setTccThreshold(double tccThreshold) {
this.tccThreshold = tccThreshold;
}
}
| 2,271
| 26.707317
| 114
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/persistence/CodeAnalysisDAO.java
|
package org.repositoryminer.metrics.persistence;
import java.util.List;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.client.model.Filters;
/**
* This class handles rm_code_analysis collection.
*/
public class CodeAnalysisDAO extends GenericDAO {
private static final String COLLECTION_NAME = "rm_code_analysis";
public CodeAnalysisDAO() {
super(COLLECTION_NAME);
}
/**
* Retrieves an analyzed file.
*
* @param fileHash
* the file hash.
* @param commit
* the commit id.
* @param projection
* the query projection.
* @return the code analysis.
*/
public Document findByFileAndCommit(long fileHash, String commit, Bson projection) {
return findOne(Filters.and(Filters.eq("filehash", fileHash), Filters.eq("commit", commit)), projection);
}
public void deleteByReport(ObjectId report) {
deleteMany(Filters.eq("analysis_report", report));
}
public List<Document> findByCommit(String commit, Bson projection) {
return findMany(Filters.eq("commit", commit), projection);
}
public List<Document> findByReport(ObjectId report, Bson projection) {
return findMany(Filters.eq("analysis_report", report), projection);
}
}
| 1,317
| 25.36
| 106
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/persistence/CodeAnalysisReportDAO.java
|
package org.repositoryminer.metrics.persistence;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;
import org.repositoryminer.persistence.GenericDAO;
import com.mongodb.client.model.Filters;
public class CodeAnalysisReportDAO extends GenericDAO {
private static final String COLLECTION_NAME = "rm_code_analysis_report";
public CodeAnalysisReportDAO() {
super(COLLECTION_NAME);
}
public Document findByCommitHash(String hash, Bson projection) {
return findOne(Filters.eq("commit", hash), projection);
}
public void deleteById(ObjectId id) {
deleteOne(Filters.eq("_id", id));
}
}
| 643
| 22.851852
| 73
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/parser/Language.java
|
package org.repositoryminer.metrics.parser;
public enum Language {
JAVA;
}
| 80
| 9.125
| 43
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/parser/Parser.java
|
package org.repositoryminer.metrics.parser;
import org.repositoryminer.metrics.ast.AST;
/**
* This interface defines a parser to a programming language.
*/
public abstract class Parser {
protected Language id;
protected String[] extensions;
private String[] sourceFolders;
/**
* @param filename
* the file path.
* @param source
* the source code.
* @param srcFolders
* the source folders.
*
* @return the AST representing the source code.
*/
public abstract AST generate(String filename, String source, String[] srcFolders);
/**
* @return the file extensions that the parser can deal.
*/
public String[] getExtensions() {
return extensions;
}
/**
* @return the programming language supported by the parser
*/
public Language getId() {
return id;
}
public String[] getSourceFolders() {
return sourceFolders;
}
public void setSourceFolders(String[] sourceFolders) {
this.sourceFolders = sourceFolders;
}
}
| 997
| 19.791667
| 83
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/parser/java/FileVisitor.java
|
package org.repositoryminer.metrics.parser.java;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.repositoryminer.metrics.ast.AbstractAnnotation;
import org.repositoryminer.metrics.ast.AbstractClass;
import org.repositoryminer.metrics.ast.AbstractEnum;
import org.repositoryminer.metrics.ast.AbstractImport;
import org.repositoryminer.metrics.ast.AbstractType;
public class FileVisitor extends ASTVisitor {
private String packageName;
private List<AbstractImport> imports = new ArrayList<>();
private List<AbstractType> types = new ArrayList<>();
public String getPackageName() {
return packageName;
}
public void setPackageName(String packageName) {
this.packageName = packageName;
}
public List<AbstractImport> getImports() {
return imports;
}
public void setImports(List<AbstractImport> imports) {
this.imports = imports;
}
public List<AbstractType> getTypes() {
return types;
}
public void setTypes(List<AbstractType> types) {
this.types = types;
}
@Override
public boolean visit(PackageDeclaration node) {
packageName = node.getName().getFullyQualifiedName();
return true;
}
@Override
public boolean visit(ImportDeclaration node) {
imports.add(new AbstractImport(
node.getName().getFullyQualifiedName(),
node.isStatic(), node.isOnDemand()));
return true;
}
@Override
public boolean visit(TypeDeclaration node) {
AbstractClass clazz = new AbstractClass();
if (node.getSuperclassType() != null) {
ITypeBinding bind = node.getSuperclassType().resolveBinding();
clazz.setSuperClass(bind.getQualifiedName());
}
clazz.setInterface(node.isInterface());
if (packageName != null) {
clazz.setName(packageName+'.'+node.getName().getFullyQualifiedName());
} else {
clazz.setName(node.getName().getFullyQualifiedName());
}
TypeVisitor visitor = new TypeVisitor();
node.accept(visitor);
clazz.setMethods(visitor.getMethods());
clazz.setStartPosition(node.getStartPosition());
clazz.setEndPosition(node.getStartPosition() + node.getLength() - 1);
clazz.setFields(visitor.getFields());
types.add(clazz);
return true;
}
@Override
public boolean visit(EnumDeclaration node) {
AbstractEnum absEnum = new AbstractEnum();
if (packageName != null) {
absEnum.setName(packageName+'.'+node.getName().getFullyQualifiedName());
} else {
absEnum.setName(node.getName().getFullyQualifiedName());
}
TypeVisitor visitor = new TypeVisitor();
node.accept(visitor);
absEnum.setMethods(visitor.getMethods());
absEnum.setFields(visitor.getFields());
absEnum.setStartPosition(node.getStartPosition());
absEnum.setEndPosition(node.getStartPosition() + node.getLength() - 1);
absEnum.setConstants(visitor.getEnumConstants());
types.add(absEnum);
return true;
}
@Override
public boolean visit(AnnotationTypeDeclaration node) {
AbstractAnnotation absAnnotation = new AbstractAnnotation();
if (packageName != null) {
absAnnotation.setName(packageName+'.'+node.getName().getFullyQualifiedName());
} else {
absAnnotation.setName(node.getName().getFullyQualifiedName());
}
TypeVisitor visitor = new TypeVisitor();
node.accept(visitor);
absAnnotation.setMethods(visitor.getMethods());
absAnnotation.setFields(visitor.getFields());
absAnnotation.setStartPosition(node.getStartPosition());
absAnnotation.setEndPosition(node.getStartPosition() + node.getLength() - 1);
absAnnotation.setMembers(visitor.getAnnotationMembers());
types.add(absAnnotation);
return true;
}
}
| 3,895
| 27.647059
| 81
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/parser/java/MethodVisitor.java
|
package org.repositoryminer.metrics.parser.java;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.BreakStatement;
import org.eclipse.jdt.core.dom.CatchClause;
import org.eclipse.jdt.core.dom.ConditionalExpression;
import org.eclipse.jdt.core.dom.ContinueStatement;
import org.eclipse.jdt.core.dom.DoStatement;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SwitchCase;
import org.eclipse.jdt.core.dom.SwitchStatement;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.WhileStatement;
import org.repositoryminer.metrics.ast.AbstractFieldAccess;
import org.repositoryminer.metrics.ast.AbstractMethodInvocation;
import org.repositoryminer.metrics.ast.AbstractStatement;
import org.repositoryminer.metrics.ast.AbstractVariableDeclaration;
import org.repositoryminer.metrics.ast.NodeType;
public class MethodVisitor extends ASTVisitor {
private List<AbstractStatement> statements = new ArrayList<>();
private int maxDepth = 0;
private int depth = 0;
public int getMaxDepth() {
return maxDepth;
}
public List<AbstractStatement> getStatements() {
return statements;
}
@Override
public boolean visit(Block node) {
depth++;
return true;
}
@Override
public void endVisit(Block node) {
maxDepth = depth > maxDepth ? depth : maxDepth;
depth--;
}
@Override
public boolean visit(BreakStatement node) {
statements.add(new AbstractStatement(NodeType.BREAK, null));
return true;
}
@Override
public boolean visit(ContinueStatement node) {
statements.add(new AbstractStatement(NodeType.CONTINUE, null));
return true;
}
@Override
public boolean visit(ReturnStatement node) {
statements.add(new AbstractStatement(NodeType.RETURN, null));
return true;
}
@Override
public boolean visit(DoStatement node) {
statements.add(new AbstractStatement(NodeType.DO_WHILE, node.getExpression().toString()));
return true;
}
@Override
public boolean visit(EnhancedForStatement node) {
statements.add(new AbstractStatement(NodeType.FOR,
node.getExpression() != null ? node.getExpression().toString() : ""));
return true;
}
@Override
public boolean visit(ForStatement node) {
statements.add(new AbstractStatement(NodeType.FOR,
node.getExpression() != null ? node.getExpression().toString() : ""));
return true;
}
@Override
public boolean visit(IfStatement node) {
statements.add(new AbstractStatement(NodeType.IF, node.getExpression().toString()));
return true;
}
@Override
public boolean visit(WhileStatement node) {
statements.add(new AbstractStatement(NodeType.WHILE, node.getExpression().toString()));
return true;
}
@Override
public boolean visit(SwitchStatement node) {
statements.add(new AbstractStatement(NodeType.SWITCH, node.getExpression().toString()));
return true;
}
@Override
public boolean visit(SwitchCase node) {
if (node.isDefault()) {
statements.add(new AbstractStatement(NodeType.SWITCH_DEFAULT, null));
} else {
statements.add(new AbstractStatement(NodeType.SWITCH_CASE, node.getExpression().toString()));
}
return true;
}
@Override
public boolean visit(CatchClause node) {
statements.add(new AbstractStatement(NodeType.CATCH, node.getException().toString()));
return true;
}
@Override
public boolean visit(ConditionalExpression node) {
statements.add(new AbstractStatement(NodeType.CONDITIONAL_EXPRESSION, node.getExpression().toString()));
return true;
}
@Override
public boolean visit(ExpressionStatement node) {
statements.add(new AbstractStatement(NodeType.EXPRESSION, node.getExpression().toString()));
return true;
}
@SuppressWarnings("unchecked")
@Override
public boolean visit(VariableDeclarationStatement node) {
ITypeBinding bind = node.getType().resolveBinding();
String type = null;
if (bind != null)
type = bind.getQualifiedName();
for (VariableDeclarationFragment frag : (List<VariableDeclarationFragment>) node.fragments()) {
statements.add(new AbstractVariableDeclaration(frag.getName().getIdentifier(), type,
frag.getInitializer() != null ? frag.getInitializer().toString() : null));
}
return true;
}
@Override
public boolean visit(SimpleName node) {
IBinding bind = node.resolveBinding();
if (bind == null) {
return true;
}
if (bind.getKind() == IBinding.VARIABLE) {
IVariableBinding varBind = (IVariableBinding) bind;
if (varBind.isField()) {
String type = varBind.getType().getQualifiedName();
statements.add(new AbstractFieldAccess(varBind.getName(), type,
varBind.getDeclaringClass() != null ? varBind.getDeclaringClass().getQualifiedName() : null,
varBind.getType().isPrimitive(),
type.startsWith("java") || type.startsWith("javax") ? true : false));
}
} else if (bind.getKind() == IBinding.METHOD) {
IMethodBinding mBind = (IMethodBinding) bind;
analyzeMethodInvocation(mBind);
}
return true;
}
private void analyzeMethodInvocation(IMethodBinding mBind) {
AbstractMethodInvocation methodInv = new AbstractMethodInvocation();
methodInv.setDeclaringClass(mBind.getDeclaringClass().getQualifiedName());
StringBuilder parameters = new StringBuilder();
for (ITypeBinding type : mBind.getParameterTypes()) {
parameters.append(type.getQualifiedName() + ",");
}
if (mBind.getParameterTypes().length > 0) {
parameters.deleteCharAt(parameters.length() - 1);
}
methodInv.setExpression(mBind.getName() + '(' + parameters.toString() + ')');
String fieldName = null;
if ((mBind.getName().startsWith("get") || mBind.getName().startsWith("set")) && mBind.getName().length() > 3) {
fieldName = mBind.getName().substring(3);
} else if (mBind.getName().startsWith("is") && mBind.getName().length() > 2) {
fieldName = mBind.getName().substring(2);
} else {
statements.add(methodInv);
return;
}
methodInv.setAccessor(true);
methodInv.setAccessedField(Character.toLowerCase(fieldName.charAt(0)) + fieldName.substring(1));
statements.add(methodInv);
}
}
| 6,632
| 30.436019
| 113
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/parser/java/JavaParser.java
|
package org.repositoryminer.metrics.parser.java;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.parser.Language;
import org.repositoryminer.metrics.parser.Parser;
/**
* Java AST generator
*
* This class has the job to create an abstract AST upon Java source code.
*
* The extensions accepted for this generator are: java
*/
public class JavaParser extends Parser {
private static final String[] EXTENSIONS = {"java"};
public JavaParser() {
super.id = Language.JAVA;
super.extensions = EXTENSIONS;
}
@Override
public AST generate(String filename, String source, String[] srcFolders) {
AST ast = new AST();
ast.setFileName(filename);
ast.setSource(source);
ASTParser parser = ASTParser.newParser(org.eclipse.jdt.core.dom.AST.JLS10);
parser.setResolveBindings(true);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setBindingsRecovery(true);
parser.setCompilerOptions(JavaCore.getOptions());
parser.setUnitName(filename);
parser.setSource(source.toCharArray());
parser.setEnvironment(null, srcFolders, null, true);
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
FileVisitor visitor = new FileVisitor();
cu.accept(visitor);
ast.setImports(visitor.getImports());
ast.setPackageDeclaration(visitor.getPackageName());
ast.setTypes(visitor.getTypes());
ast.setLanguage(Language.JAVA);
return ast;
}
}
| 1,548
| 26.660714
| 77
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/parser/java/TypeVisitor.java
|
package org.repositoryminer.metrics.parser.java;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.repositoryminer.metrics.ast.AbstractAnnotationMember;
import org.repositoryminer.metrics.ast.AbstractEnumConstant;
import org.repositoryminer.metrics.ast.AbstractField;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractParameter;
import org.repositoryminer.metrics.ast.AbstractStatement;
public class TypeVisitor extends ASTVisitor {
private List<AbstractMethod> methods = new ArrayList<>();
private List<AbstractAnnotationMember> annotationMembers = new ArrayList<>();
private List<AbstractField> fields = new ArrayList<>();
private List<AbstractEnumConstant> enumConstants = new ArrayList<>();
public List<AbstractMethod> getMethods() {
return methods;
}
public void setMethods(List<AbstractMethod> methods) {
this.methods = methods;
}
public List<AbstractAnnotationMember> getAnnotationMembers() {
return annotationMembers;
}
public void setAnnotationMembers(List<AbstractAnnotationMember> annotationMembers) {
this.annotationMembers = annotationMembers;
}
public List<AbstractField> getFields() {
return fields;
}
public void setFields(List<AbstractField> fields) {
this.fields = fields;
}
public List<AbstractEnumConstant> getEnumConstants() {
return enumConstants;
}
public void setEnumConstants(List<AbstractEnumConstant> enumConstants) {
this.enumConstants = enumConstants;
}
@Override
public boolean visit(AnnotationTypeMemberDeclaration node) {
AbstractAnnotationMember annoMember = new AbstractAnnotationMember(
node.getType().resolveBinding().getQualifiedName(), node.getName().getIdentifier());
annoMember.setDefaultExpression(node.getDefault() != null ? node.getDefault().toString() : null);
annotationMembers.add(annoMember);
return true;
}
@Override
@SuppressWarnings("unchecked")
public boolean visit(EnumConstantDeclaration node) {
AbstractEnumConstant constant = new AbstractEnumConstant(node.getName().getIdentifier());
List<String> expressions = new ArrayList<>();
for (Expression exp : (List<Expression>) node.arguments()) {
expressions.add(exp.toString());
}
constant.setArguments(expressions);
enumConstants.add(constant);
return true;
}
@SuppressWarnings("unchecked")
@Override
public boolean visit(FieldDeclaration node) {
List<AbstractField> fields2 = new ArrayList<>();
ITypeBinding bind = node.getType().resolveBinding();
String type = "";
boolean primitive = false;
if (bind != null) {
type = bind.getQualifiedName();
primitive = bind.isPrimitive();
}
List<String> modifiers = new ArrayList<String>();
for (Object modifier : node.modifiers()) {
modifiers.add(modifier.toString());
}
boolean builtIn = type.startsWith("java.") || type.startsWith("javax.") ? true : false;
for (VariableDeclarationFragment vdf : (List<VariableDeclarationFragment>) node.fragments()) {
fields2.add(new AbstractField(vdf.getName().getIdentifier(), type, modifiers, primitive, builtIn));
}
fields.addAll(fields2);
return true;
}
@SuppressWarnings("unchecked")
@Override
public boolean visit(MethodDeclaration node) {
AbstractMethod method = new AbstractMethod();
method.setConstructor(node.isConstructor());
method.setVarargs(node.isVarargs());
StringBuilder builder = null;
builder = new StringBuilder();
builder.append(node.getName().getIdentifier()).append("(");
List<AbstractParameter> params = new ArrayList<>();
for (SingleVariableDeclaration var : (List<SingleVariableDeclaration>) node.parameters()) {
IVariableBinding varBind = var.resolveBinding();
AbstractParameter param = new AbstractParameter(varBind.getType().getQualifiedName(), varBind.getName());
params.add(param);
builder.append(param.getType() + ",");
}
if (builder.substring(builder.length() - 1).equals(",")) {
builder.replace(builder.length() - 1, builder.length(), ")");
} else {
builder.append(")");
}
method.setName(builder.toString());
method.setParameters(params);
verifyAccessorMethod(method);
List<String> throwsList = new ArrayList<String>();
List<Type> types = node.thrownExceptionTypes();
for (Type type : types) {
throwsList.add(type.toString());
}
method.setThrownsExceptions(throwsList);
List<String> modifiers = new ArrayList<String>();
for (Object modifier : node.modifiers()) {
modifiers.add(modifier.toString());
}
method.setModifiers(modifiers);
if (node.getBody() != null) {
MethodVisitor visitor = new MethodVisitor();
node.getBody().accept(visitor);
method.setMaxDepth(visitor.getMaxDepth());
method.setStatements(visitor.getStatements());
} else {
method.setStatements(new ArrayList<AbstractStatement>());
}
if (node.getReturnType2() != null) {
ITypeBinding bind = node.getReturnType2().resolveBinding();
if (bind != null)
method.setReturnType(bind.getQualifiedName());
}
method.setStartPosition(node.getStartPosition());
method.setEndPosition(node.getStartPosition() + node.getLength() - 1);
methods.add(method);
return true;
}
public void verifyAccessorMethod(AbstractMethod method) {
String name = method.getName();
String field = null;
if ((name.startsWith("get") || name.startsWith("set")) && name.length() > 3) {
field = name.substring(3);
} else if (name.startsWith("is") && name.length() > 2) {
field = name.substring(2);
} else {
return;
}
char c[] = field.toCharArray();
c[0] = Character.toLowerCase(c[0]);
String field2 = new String(c);
for (AbstractField fd : fields) {
if (fd.getName().equals(field) || fd.getName().equals(field2)) {
method.setAccessor(true);
method.setAccessoredField(fd.getName());
break;
}
}
}
}
| 6,399
| 29.917874
| 108
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/NOM.java
|
package org.repositoryminer.metrics.codemetric;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class NOM extends CodeMetric {
public NOM() {
super.id = CodeMetricId.NOM;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.NOM, type.getMethods().size());
}
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 759
| 28.230769
| 85
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/LOC.java
|
package org.repositoryminer.metrics.codemetric;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class LOC extends CodeMetric {
private Pattern pattern;
public LOC() {
super.id = CodeMetricId.LOC;
pattern = Pattern.compile("(\r\n)|(\n)|(\r)");
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
fileReport.getMetricsReport().setCodeMetric(CodeMetricId.LOC, calculate(ast.getSource()));
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.LOC, calculate(ast, type));
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.LOC, calculate(ast, method));
}
}
}
public int calculate(AST ast, AbstractType type) {
String clazz = ast.getSource().substring(type.getStartPosition(), type.getEndPosition());
String body = clazz.substring(clazz.indexOf('{'));
return calculate(body);
}
public int calculate(AST ast, AbstractMethod method) {
String m = ast.getSource().substring(method.getStartPosition(), method.getEndPosition());
return m.contains("{") ? calculate(m.substring(m.indexOf('{'))) : 0;
}
public int calculate(String source) {
if (source == null || source.length() == 0) {
return 0;
}
int lines = 1;
Matcher matcher = pattern.matcher(source);
while (matcher.find()) {
lines++;
}
return lines;
}
@Override
public void clean(ProjectReport projectReport) {
}
}
| 1,988
| 29.6
| 92
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/NOA.java
|
package org.repositoryminer.metrics.codemetric;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class NOA extends CodeMetric {
public NOA() {
super.id = CodeMetricId.NOA;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.NOA, type.getFields().size());
}
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 758
| 28.192308
| 85
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/NProtM.java
|
package org.repositoryminer.metrics.codemetric;
import java.util.List;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractField;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class NProtM extends CodeMetric {
public NProtM() {
super.id = CodeMetricId.NProtM;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.NProtM, calculate(type.getMethods(), type.getFields()));
}
}
public int calculate(List<AbstractMethod> methods, List<AbstractField> fields) {
int members = 0;
for (AbstractMethod method : methods) {
if (isProtected(method.getModifiers())) {
members++;
}
}
for (AbstractField field : fields) {
if (isProtected(field.getModifiers())) {
members++;
}
}
return members;
}
public boolean isProtected(List<String> modifiers) {
if (modifiers.contains("protected") || (!modifiers.contains("public") && !modifiers.contains("private"))) {
return true;
}
return false;
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 1,474
| 25.818182
| 109
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/CYCLO.java
|
package org.repositoryminer.metrics.codemetric;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractStatement;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.ast.NodeType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class CYCLO extends CodeMetric {
public CYCLO() {
super.id = CodeMetricId.CYCLO;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.CYCLO, calculate(method));
}
}
}
public int calculate(AbstractMethod method) {
if (method.getStatements() == null) {
return 1;
}
int cc = 1;
for (AbstractStatement statement : method.getStatements()) {
switch (statement.getNodeType()) {
case SWITCH_CASE:
cc++;
break;
case IF:
case FOR:
case DO_WHILE:
case WHILE:
case CATCH:
case CONDITIONAL_EXPRESSION:
cc += calculateExpression(statement.getExpression(), statement.getNodeType());
break;
default:
break;
}
}
return cc;
}
private int calculateExpression(String expression, NodeType type) {
int cc = 1;
char[] chars = expression.toCharArray();
if (type != NodeType.CATCH) {
for (int i = 0; i < chars.length - 1; i++) {
char next = chars[i];
if ((next == '&' || next == '|') && (next == chars[i + 1])) {
cc++;
}
}
} else {
for (int i = 0; i < chars.length - 1; i++) {
if (chars[i] == '|') {
cc++;
}
}
}
return cc;
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 2,064
| 24.182927
| 85
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/CodeMetric.java
|
package org.repositoryminer.metrics.codemetric;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public abstract class CodeMetric {
protected CodeMetricId id;
protected CodeMetricId[] requiredMetrics;
/**
* Calculates the metric and stores the result in the AST.
*
* @param ast
*/
public abstract void calculate(AST ast, FileReport fileReport, ProjectReport projectReport);
/**
* Performs any final work after process all the ASTs. This method can be
* interesting for some metrics that needs informations about all the classes
* before perform any calculus.
*/
public abstract void clean(ProjectReport projectReport);
/**
* @return the metric identifier.
*/
public CodeMetricId getId() {
return id;
}
/**
* @return the required metrics.
*/
public CodeMetricId[] getRequiredMetrics() {
return requiredMetrics;
}
}
| 968
| 23.225
| 93
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/NOAM.java
|
package org.repositoryminer.metrics.codemetric;
import java.util.List;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractField;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class NOAM extends CodeMetric {
public NOAM() {
super.id = CodeMetricId.NOAM;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.NOAM, calculate(type.getMethods(), type.getFields()));
}
}
public int calculate(List<AbstractMethod> methods, List<AbstractField> fields) {
int accessorMehtods = 0;
for (AbstractMethod method : methods) {
if (method.getModifiers().contains("public") && method.isAccessor()) {
accessorMehtods++;
}
}
return accessorMehtods;
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 1,206
| 28.439024
| 106
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/LVAR.java
|
package org.repositoryminer.metrics.codemetric;
import java.util.ArrayList;
import java.util.List;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractStatement;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.ast.NodeType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class LVAR extends CodeMetric {
public LVAR() {
super.id = CodeMetricId.LVAR;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.LVAR, calculate(method));
}
}
}
public int calculate(AbstractMethod method) {
List<String> lvar = new ArrayList<String>();
for (AbstractStatement statement : method.getStatements()) {
if (statement.getNodeType() == NodeType.VARIABLE_DECLARATION && !lvar.contains(statement.getExpression())) {
lvar.add(statement.getExpression());
}
}
return lvar.size();
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 1,495
| 31.521739
| 111
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/MAXNESTING.java
|
package org.repositoryminer.metrics.codemetric;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class MAXNESTING extends CodeMetric {
public MAXNESTING() {
super.id = CodeMetricId.MAXNESTING;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.MAXNESTING, method.getMaxDepth());
}
}
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 1,019
| 31.903226
| 87
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/WOC.java
|
package org.repositoryminer.metrics.codemetric;
import java.math.BigDecimal;
import java.util.List;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractField;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class WOC extends CodeMetric {
public WOC() {
super.id = CodeMetricId.WOC;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.WOC, calculate(type.getMethods(), type.getFields()));
}
}
public double calculate(List<AbstractMethod> methods, List<AbstractField> fields) {
int publicMembers = 0;
int functionalMembers = 0;
for (AbstractField field : fields) {
if (field.getModifiers().contains("public")) {
publicMembers++;
}
}
for (AbstractMethod method : methods) {
if (method.getModifiers().contains("public")) {
publicMembers++;
if (!method.isAccessor()) {
functionalMembers++;
}
}
}
double result = publicMembers == 0 ? 0 : functionalMembers * 1.0 / publicMembers;
return new BigDecimal(result).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 1,564
| 27.981481
| 105
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/TCC.java
|
package org.repositoryminer.metrics.codemetric;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractFieldAccess;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractMethodInvocation;
import org.repositoryminer.metrics.ast.AbstractStatement;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.ast.NodeType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class TCC extends CodeMetric {
public TCC() {
super.id = CodeMetricId.TCC;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.TCC, calculate(type));
}
}
public double calculate(AbstractType type) {
List<AbstractMethod> methodList = new ArrayList<AbstractMethod>();
for (AbstractMethod m : type.getMethods()) {
if (!(m.getModifiers().contains("abstract") || m.isConstructor())) {
methodList.add(m);
}
}
int n = methodList.size();
int npc = (n * (n - 1)) / 2;
int ndc = 0;
List<List<String>> accessedFieldsByMethods = new ArrayList<List<String>>();
for (AbstractMethod method : methodList) {
accessedFieldsByMethods.add(processAccessedFields(type, method));
}
for (int i = 0; i < accessedFieldsByMethods.size(); i++) {
for (int j = i + 1; j < accessedFieldsByMethods.size(); j++) {
if (isConnected(accessedFieldsByMethods.get(i), accessedFieldsByMethods.get(j))) {
ndc++;
}
}
}
double result = npc > 0 ? ndc * 1.0 / npc : 0;
return new BigDecimal(result).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
}
public List<String> processAccessedFields(AbstractType currType, AbstractMethod method) {
Set<String> fields = new HashSet<String>();
for (AbstractStatement stmt : method.getStatements()) {
if (stmt.getNodeType() == NodeType.FIELD_ACCESS) {
AbstractFieldAccess fdAccess = (AbstractFieldAccess) stmt;
if (currType.getName().equals(fdAccess.getDeclaringClass())) {
fields.add(stmt.getExpression());
}
} else if (stmt.getNodeType() == NodeType.METHOD_INVOCATION) {
AbstractMethodInvocation methodInv = (AbstractMethodInvocation) stmt;
if (methodInv.isAccessor() && currType.getName().equals(methodInv.getDeclaringClass())) {
fields.add(methodInv.getAccessedField());
}
} else {
continue;
}
}
return new ArrayList<String>(fields);
}
private boolean isConnected(List<String> method1, List<String> method2) {
for (String field : method1) {
if (method2.contains(field)) {
return true;
}
}
return false;
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 3,064
| 31.263158
| 93
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/FDP.java
|
package org.repositoryminer.metrics.codemetric;
import java.util.HashSet;
import java.util.Set;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractFieldAccess;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractMethodInvocation;
import org.repositoryminer.metrics.ast.AbstractStatement;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.ast.NodeType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class FDP extends CodeMetric {
public FDP() {
super.id = CodeMetricId.FDP;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.FDP, calculate(type, method));
}
}
}
public int calculate(AbstractType currType, AbstractMethod method) {
Set<String> accessedClasses = new HashSet<String>();
for (AbstractStatement stmt : method.getStatements()) {
String declarringClass = null;
if (stmt.getNodeType() == NodeType.FIELD_ACCESS) {
AbstractFieldAccess fieldAccess = (AbstractFieldAccess) stmt;
declarringClass = fieldAccess.getDeclaringClass();
} else if (stmt.getNodeType() == NodeType.METHOD_INVOCATION) {
AbstractMethodInvocation methodInvocation = (AbstractMethodInvocation) stmt;
if (!methodInvocation.isAccessor()) {
continue;
}
declarringClass = methodInvocation.getDeclaringClass();
} else {
continue;
}
if (!currType.getName().equals(declarringClass)) {
accessedClasses.add(declarringClass);
}
}
return accessedClasses.size();
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 2,113
| 32.03125
| 85
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/LAA.java
|
package org.repositoryminer.metrics.codemetric;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractFieldAccess;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractMethodInvocation;
import org.repositoryminer.metrics.ast.AbstractStatement;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.ast.NodeType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class LAA extends CodeMetric {
public LAA() {
super.id = CodeMetricId.LAA;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.LAA, calculate(type, method));
}
}
}
public double calculate(AbstractType type, AbstractMethod method) {
int countFields = countAccessedFields(method);
double result = countFields > 0 ? (type.getFields().size() * 1.0) / countFields : 0;
return new BigDecimal(result).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static int countAccessedFields(AbstractMethod method) {
Set<String> accessedFields = new HashSet<String>();
for (AbstractStatement stmt : method.getStatements()) {
if (stmt.getNodeType() == NodeType.FIELD_ACCESS) {
AbstractFieldAccess fieldAccess = (AbstractFieldAccess) stmt;
accessedFields.add(fieldAccess.getDeclaringClass() + '.' + fieldAccess.getExpression());
} else if (stmt.getNodeType() == NodeType.METHOD_INVOCATION) {
AbstractMethodInvocation methodInvocation = (AbstractMethodInvocation) stmt;
if (methodInvocation.isAccessor()) {
accessedFields.add(methodInvocation.getDeclaringClass() + '.' + methodInvocation.getExpression());
}
} else {
continue;
}
}
return accessedFields.size();
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 2,355
| 36.396825
| 103
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/PAR.java
|
package org.repositoryminer.metrics.codemetric;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractMethod;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.MethodReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class PAR extends CodeMetric {
public PAR() {
super.id = CodeMetricId.PAR;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
for (AbstractMethod method : type.getMethods()) {
MethodReport mr = cr.getMethodBySignature(method.getName());
mr.getMetricsReport().setCodeMetric(CodeMetricId.PAR, method.getParameters().size());
}
}
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 999
| 31.258065
| 89
|
java
|
repositoryminer
|
repositoryminer-master/repositoryminer-metrics/src/main/java/org/repositoryminer/metrics/codemetric/NOPA.java
|
package org.repositoryminer.metrics.codemetric;
import java.util.List;
import org.repositoryminer.metrics.ast.AST;
import org.repositoryminer.metrics.ast.AbstractField;
import org.repositoryminer.metrics.ast.AbstractType;
import org.repositoryminer.metrics.report.ClassReport;
import org.repositoryminer.metrics.report.FileReport;
import org.repositoryminer.metrics.report.ProjectReport;
public class NOPA extends CodeMetric {
public NOPA() {
super.id = CodeMetricId.NOPA;
}
@Override
public void calculate(AST ast, FileReport fileReport, ProjectReport projectReport) {
for (AbstractType type : ast.getTypes()) {
ClassReport cr = fileReport.getClass(type.getName());
cr.getMetricsReport().setCodeMetric(CodeMetricId.NOPA, calculate(type.getFields()));
}
}
public int calculate(List<AbstractField> fields) {
int publicMembers = 0;
for (AbstractField field : fields) {
if (field.getModifiers().contains("public")) {
publicMembers++;
}
}
return publicMembers;
}
@Override
public void clean(ProjectReport projectReport) {}
}
| 1,068
| 26.410256
| 87
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.