@Override
public boolean accept(Commit commit) {

	if (super.accept(commit)) {
		int nbHunks = 0;
		List<FileCommit> javaFiles = commit.getJavaFileCommits();

		for (FileCommit fileCommit : javaFiles) {

			List<RangeDifference> hunks = getNumberChanges(fileCommit.getPreviousVersion(),
					fileCommit.getNextVersion());
			nbHunks += hunks.size();
		}

		if (nbHunks >= min_included && nbHunks <= max_included) {
			return true;
		}

	}

	return false;

}
 

/**
 *
 * @param previousVersion
 * @param nextVersion
 * @return
 */
protected List<RangeDifference> getNumberChanges(String previousVersion, String nextVersion) {
	List<RangeDifference> ranges = new ArrayList<RangeDifference>();

	Fragmentable fPreviousVersion = comparator.createFragmentable(previousVersion);
	Fragmentable fNextVersion = comparator.createFragmentable(nextVersion);
	RangeDifference[] results = comparator.compare(fPreviousVersion, fNextVersion);

	for (RangeDifference diff : results) {
		if (diff.kind() != RangeDifference.NOCHANGE) {
			int length = diff.rightEnd() - diff.rightStart();
			if (length <= ComingProperties.getPropertyInteger("max_lines_per_hunk"))
				ranges.add(diff);

		}
	}

	return ranges;
}
 

public List<String> getAfterDifferences(Fragmentable sbefore, Fragmentable safter)  {
	    RangeDifference[] results = RangeDifferencer.findRanges(new LCSSettings(), sbefore, safter); 
	    List<String> l = new ArrayList<String>();
//	    System.err.println("Diffs: " + results.length);
	    

	    for (RangeDifference diff : results) {
	      if (diff.kind() != RangeDifference.NOCHANGE) {
//	        System.err.println("####change " + diff.toString());

//	        for (int i = diff.leftStart(); i < diff.leftEnd(); i++) {
//	          System.err.println("before:" + sbefore.getFragment(i));
//	        }
	        for (int i = diff.rightStart(); i < diff.rightEnd(); i++) {
	          l.add(safter.getFragment(i));
	        }

	      }
	    }
	    return l;

	  }
 

protected HunkDiff getNumberChanges(String previousVersion, String nextVersion) {
	HunkDiff ranges = new HunkDiff();

	Fragmentable fPreviousVersion = comparator.createFragmentable(previousVersion);
	Fragmentable fNextVersion = comparator.createFragmentable(nextVersion);
	RangeDifference[] results = comparator.compare(fPreviousVersion, fNextVersion);

	for (RangeDifference diffInfo : results) {
		if (diffInfo.kind() != RangeDifference.NOCHANGE /* && diffInfo.kind() != RangeDifference.ANCESTOR */) {
			// TODO: for the moment, ignoring here hunk filtering
			// int length = diff.rightEnd() - diff.rightStart();
			// if (length <= ComingProperties.getPropertyInteger("max_lines_per_hunk"))
			ranges.add(diffInfo);
			String left = "";
			String right = "";

			if (diffInfo.ancestorStart() == 0 && diffInfo.ancestorEnd() == 0
					|| diffInfo.ancestorStart() == 1 && diffInfo.ancestorLength() == 0)
				continue;

			for (int i = diffInfo.ancestorStart(); i < diffInfo.ancestorEnd(); i++) {
				left += fPreviousVersion.getFragment(i) + "\n";
			}

			for (int i = diffInfo.rightStart(); i < diffInfo.rightEnd(); i++) {

				right += fNextVersion.getFragment(i) + "\n";
			}

			ranges.getHunkpairs().add(new HunkPair(left, right));

		}
	}

	return ranges;
}
 

public RangeDifference[] compare(String file1, String file2) {
  Fragmentable sbefore = createFragmentable(file1);
  Fragmentable safter = createFragmentable(file2);
  return compare(sbefore, safter);
}
 

public RangeDifference[] compare(Fragmentable sbefore, Fragmentable safter) {
  RangeDifference[] results = RangeDifferencer.findRanges(new LCSSettings(), sbefore, safter, safter);
  return results;
}
 

/**
 * Return all the changed lines.
 * 
 * @param oldDocument a document containing the old content
 * @param currentDocument a document containing the current content
 * @return the changed regions
 * @throws BadLocationException if fetching the line information fails
 */
public static int[] getChangedLines(IDocument oldDocument, IDocument currentDocument) throws BadLocationException {
    /*
     * Do not change the type of those local variables. We use Object
     * here in order to prevent loading of the Compare plug-in at load
     * time of this class.
     */
    Object leftSide = new LineComparator(oldDocument);
    Object rightSide = new LineComparator(currentDocument);

    RangeDifference[] differences = RangeDifferencer.findDifferences((IRangeComparator) leftSide,
            (IRangeComparator) rightSide);

    //It holds that:
    //1. Ranges are sorted:
    //     forAll r1,r2 element differences: indexOf(r1)<indexOf(r2) -> r1.rightStart()<r2.rightStart();
    //2. Successive changed lines are merged into on RangeDifference
    //     forAll r1,r2 element differences: r1.rightStart()<r2.rightStart() -> r1.rightEnd()<r2.rightStart

    ArrayList<Integer> regions = new ArrayList<Integer>();
    for (int i = 0; i < differences.length; i++) {
        RangeDifference curr = differences[i];
        if (curr.kind() == RangeDifference.CHANGE && curr.rightLength() > 0) {
            int startLine = curr.rightStart();
            int endLine = curr.rightEnd() - 1;

            if (startLine == endLine) {
                regions.add(startLine);
            } else {
                for (int iLine = startLine; iLine <= endLine; iLine++) {
                    regions.add(iLine);
                }
            }
        }
    }

    int size = regions.size();
    int[] ret = new int[size];
    for (int i = 0; i < size; i++) {
        ret[i] = regions.get(i);
    }
    return ret;
}
 

/**
 * Compute and return an array of {@link RangeDifference}s for two given strings.
 * 
 * @param left
 * @param right
 * @return An array of {@link RangeDifference}s.
 */
public static RangeDifference[] getDiff(String left, String right)
{
	IRangeComparator leftRangeComparator = new TokenComparator(left);
	IRangeComparator rightRangeComparator = new TokenComparator(right);
	return RangeDifferencer.findRanges(leftRangeComparator, rightRangeComparator);
}