yuqei/difflib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reformat code with rustfmt

Browse Source
This commit is contained in:
Dima Kudosh
2017-02-26 19:32:22 +03:00
parent 7fc731ab99
commit 07de887127
6 changed files with 939 additions and 792 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/example.rs
+14 -4
View File
@@ -8,15 +8,25 @@ fn main() {
// unified_diff
let first_text = "one two three four".split(" ").collect::<Vec<&str>>();
let second_text = "zero one tree four".split(" ").collect::<Vec<&str>>();
let diff = difflib::unified_diff(&first_text, &second_text, "Original", "Current",
"2005-01-26 23:30:50", "2010-04-02 10:20:52", 3);
let diff = difflib::unified_diff(&first_text,
&second_text,
"Original",
"Current",
"2005-01-26 23:30:50",
"2010-04-02 10:20:52",
3);
for line in &diff {
println!("{:?}", line);
}
//context_diff
let diff = difflib::context_diff(&first_text, &second_text, "Original", "Current",
"2005-01-26 23:30:50", "2010-04-02 10:20:52", 3);
let diff = difflib::context_diff(&first_text,
&second_text,
"Original",
"Current",
"2005-01-26 23:30:50",
"2010-04-02 10:20:52",
3);
for line in &diff {
println!("{:?}", line);
}
src/differ.rs
+136 -55
View File
@@ -5,29 +5,44 @@ use std::cmp;
pub struct Differ {
pub line_junk: Option<fn(&str) -> bool>,
pub char_junk: Option<fn(&str) -> bool>
pub char_junk: Option<fn(&str) -> bool>,
}
impl Differ{
impl Differ {
pub fn new() -> Differ {
Differ{
Differ {
line_junk: None,
char_junk: None
char_junk: None,
}
}
pub fn compare<T: ?Sized + Sequence>(&self, first_sequence: &T, second_sequence: &T) -> Vec<String> {
pub fn compare<T: ?Sized + Sequence>(&self,
first_sequence: &T,
second_sequence: &T)
-> Vec<String> {
let mut matcher = SequenceMatcher::new(first_sequence, second_sequence);
matcher.set_is_junk(self.line_junk);
let mut res = Vec::new();
for opcode in matcher.get_opcodes(){
for opcode in matcher.get_opcodes() {
let mut gen = Vec::new();
match opcode.tag.as_ref() {
"replace" => { gen = self.fancy_replace(first_sequence, opcode.first_start, opcode.first_end,
second_sequence, opcode.second_start, opcode.second_end) },
"delete" => { gen = self.dump("-", first_sequence, opcode.first_start, opcode.first_end) },
"insert" => { gen = self.dump("+", second_sequence, opcode.second_start, opcode.second_end) },
"equal" => { gen = self.dump(" ", first_sequence, opcode.first_start, opcode.first_end) },
"replace" => {
gen = self.fancy_replace(first_sequence,
opcode.first_start,
opcode.first_end,
second_sequence,
opcode.second_start,
opcode.second_end)
}
"delete" => {
gen = self.dump("-", first_sequence, opcode.first_start, opcode.first_end)
}
"insert" => {
gen = self.dump("+", second_sequence, opcode.second_start, opcode.second_end)
}
"equal" => {
gen = self.dump(" ", first_sequence, opcode.first_start, opcode.first_end)
}
_ => {}
}
for i in gen {
@@ -37,51 +52,68 @@ impl Differ{
res
}
fn dump<T: ?Sized + Sequence>(&self, tag: &str, sequence: &T, start: usize, end: usize) -> Vec<String> {
fn dump<T: ?Sized + Sequence>(&self,
tag: &str,
sequence: &T,
start: usize,
end: usize)
-> Vec<String> {
let mut res = Vec::new();
for i in start..end {
match sequence.at_index(i) {
Some(s) => res.push(format!("{} {}", tag, s)),
None => {},
None => {}
}
}
res
}
fn plain_replace<T: ?Sized + Sequence>(&self, first_sequence: &T, first_start: usize, first_end: usize,
second_sequence: &T, second_start: usize, second_end: usize) -> Vec<String> {
if !(first_start < first_end && second_start < second_end){
fn plain_replace<T: ?Sized + Sequence>(&self,
first_sequence: &T,
first_start: usize,
first_end: usize,
second_sequence: &T,
second_start: usize,
second_end: usize)
-> Vec<String> {
if !(first_start < first_end && second_start < second_end) {
return Vec::new();
}
let mut first;
let second;
if second_end - second_start < first_end - first_start{
if second_end - second_start < first_end - first_start {
first = self.dump("+", second_sequence, second_start, second_end);
second = self.dump("-", first_sequence, first_start, first_end);
} else {
first = self.dump("-", first_sequence, first_start, first_end);
second = self.dump("+", second_sequence, second_start, second_end);
}
for s in second{
for s in second {
first.push(s);
}
first
}
fn fancy_replace<T: ?Sized + Sequence>(&self, first_sequence: &T, first_start: usize, first_end: usize,
second_sequence: &T, second_start: usize, second_end: usize) -> Vec<String> {
fn fancy_replace<T: ?Sized + Sequence>(&self,
first_sequence: &T,
first_start: usize,
first_end: usize,
second_sequence: &T,
second_start: usize,
second_end: usize)
-> Vec<String> {
let mut res = Vec::new();
let (mut best_ratio, cutoff) = (0.74, 0.75);
let (mut best_i, mut best_j) = (0, 0);
let (mut second_sequence_str, mut first_sequence_str);
let mut eqi: Option<usize> = None;
let mut eqj: Option<usize> = None;
for j in second_start..second_end{
for j in second_start..second_end {
second_sequence_str = second_sequence.at_index(j).unwrap();
for i in first_start..first_end{
for i in first_start..first_end {
first_sequence_str = first_sequence.at_index(i).unwrap();
if first_sequence_str == second_sequence_str{
if eqi.is_none(){
if first_sequence_str == second_sequence_str {
if eqi.is_none() {
eqi = Some(i);
eqj = Some(j);
}
@@ -89,65 +121,101 @@ impl Differ{
}
let mut cruncher = SequenceMatcher::new(first_sequence_str, second_sequence_str);
cruncher.set_is_junk(self.char_junk);
if cruncher.ratio() > best_ratio{
if cruncher.ratio() > best_ratio {
best_ratio = cruncher.ratio();
best_i = i;
best_j = j;
}
}
}
if best_ratio < cutoff{
if eqi.is_none(){
res.extend(self.plain_replace(first_sequence, first_start, first_end, second_sequence, second_start, second_end).iter().cloned());
return res
if best_ratio < cutoff {
if eqi.is_none() {
res.extend(self.plain_replace(first_sequence,
first_start,
first_end,
second_sequence,
second_start,
second_end)
.iter()
.cloned());
return res;
}
best_i = eqi.unwrap();
best_j = eqj.unwrap();
} else {
eqi = None;
}
res.extend(self.fancy_helper(first_sequence, first_start, best_i, second_sequence, second_start, best_j).iter().cloned());
let (first_element, second_element) = (first_sequence.at_index(best_i).unwrap(), second_sequence.at_index(best_j).unwrap());
if eqi.is_none(){
res.extend(self.fancy_helper(first_sequence,
first_start,
best_i,
second_sequence,
second_start,
best_j)
.iter()
.cloned());
let (first_element, second_element) = (first_sequence.at_index(best_i).unwrap(),
second_sequence.at_index(best_j).unwrap());
if eqi.is_none() {
let (mut first_tag, mut second_tag) = (String::new(), String::new());
let mut cruncher = SequenceMatcher::new(first_element, second_element);
cruncher.set_is_junk(self.char_junk);
for opcode in &cruncher.get_opcodes(){
let (first_length, second_length) = (opcode.first_end - opcode.first_start, opcode.second_end - opcode.second_start);
for opcode in &cruncher.get_opcodes() {
let (first_length, second_length) = (opcode.first_end - opcode.first_start,
opcode.second_end - opcode.second_start);
match opcode.tag.as_ref() {
"replace" => {
first_tag.push_str(&str_with_similar_chars('^', first_length));
second_tag.push_str(&str_with_similar_chars('^', second_length));
},
}
"delete" => {
first_tag.push_str(&str_with_similar_chars('-', first_length));
},
}
"insert" => {
second_tag.push_str(&str_with_similar_chars('+', second_length));
},
}
"equal" => {
first_tag.push_str(&str_with_similar_chars(' ', first_length));
second_tag.push_str(&str_with_similar_chars(' ', second_length));
},
}
_ => {}
}
}
res.extend(self.qformat(&first_element, &second_element, &first_tag, &second_tag).iter().cloned());
res.extend(self.qformat(&first_element, &second_element, &first_tag, &second_tag)
.iter()
.cloned());
} else {
let mut s = String::from(" ");
s.push_str(&first_element);
res.push(s);
}
res.extend(self.fancy_helper(first_sequence, best_i + 1, first_end, second_sequence, best_j + 1, second_end).iter().cloned());
res.extend(self.fancy_helper(first_sequence,
best_i + 1,
first_end,
second_sequence,
best_j + 1,
second_end)
.iter()
.cloned());
res
}
fn fancy_helper<T: ?Sized + Sequence>(&self, first_sequence: &T, first_start: usize, first_end: usize,
second_sequence: &T, second_start: usize, second_end: usize) -> Vec<String> {
fn fancy_helper<T: ?Sized + Sequence>(&self,
first_sequence: &T,
first_start: usize,
first_end: usize,
second_sequence: &T,
second_start: usize,
second_end: usize)
-> Vec<String> {
let mut res = Vec::new();
if first_start < first_end{
if second_start < second_end{
res = self.fancy_replace(first_sequence, first_start, first_end, second_sequence, second_start, second_end);
if first_start < first_end {
if second_start < second_end {
res = self.fancy_replace(first_sequence,
first_start,
first_end,
second_sequence,
second_start,
second_end);
} else {
res = self.dump("-", first_sequence, first_start, first_end);
}
@@ -157,25 +225,33 @@ impl Differ{
res
}
fn qformat(&self, first_line: &str, second_line: &str, first_tags: &str, second_tags: &str) -> Vec<String> {
fn qformat(&self,
first_line: &str,
second_line: &str,
first_tags: &str,
second_tags: &str)
-> Vec<String> {
let mut res = Vec::new();
let mut first_tags = first_tags;
let mut second_tags = second_tags;
let mut common = cmp::min(count_leading(first_line, '\t'), count_leading(second_line, '\t'));
let mut common = cmp::min(count_leading(first_line, '\t'),
count_leading(second_line, '\t'));
common = cmp::min(common, count_leading(first_tags.split_at(common).0, ' '));
common = cmp::min(common, count_leading(first_tags.split_at(common).0, ' '));
first_tags = first_tags.split_at(common).1.trim_right();
second_tags = second_tags.split_at(common).1.trim_right();
let mut s = String::from(format!("- {}", first_line));
res.push(s);
if first_tags != ""{
if first_tags != "" {
s = String::from(format!("? {}{}\n", str_with_similar_chars('\t', common), first_tags));
res.push(s);
}
s = String::from(format!("+ {}", second_line));
res.push(s);
if second_tags != "" {
s = String::from(format!("? {}{}\n", str_with_similar_chars('\t', common), second_tags));
s = String::from(format!("? {}{}\n",
str_with_similar_chars('\t', common),
second_tags));
res.push(s);
}
res
@@ -196,25 +272,30 @@ impl Differ{
for line in delta {
for prefix in &prefixes {
if line.starts_with(prefix) {
res.push( line.split_at(2).1.to_string() );
res.push(line.split_at(2).1.to_string());
}
}
}
res
}
}
#[test]
fn test_fancy_replace() {
let differ = Differ::new();
let result = differ.fancy_replace(&vec!["abcDefghiJkl\n"], 0, 1, &vec!["abcdefGhijkl\n"], 0, 1).join("");
assert_eq!(result, "- abcDefghiJkl\n? ^ ^ ^\n+ abcdefGhijkl\n? ^ ^ ^\n");
let result = differ.fancy_replace(&vec!["abcDefghiJkl\n"], 0, 1, &vec!["abcdefGhijkl\n"], 0, 1)
.join("");
assert_eq!(result,
"- abcDefghiJkl\n? ^ ^ ^\n+ abcdefGhijkl\n? ^ ^ ^\n");
}
#[test]
fn test_qformat() {
let differ = Differ::new();
let result = differ.qformat("\tabcDefghiJkl\n", "\tabcdefGhijkl\n", " ^ ^ ^ ", " ^ ^ ^ ");
assert_eq!(result, vec!["- \tabcDefghiJkl\n", "? \t ^ ^ ^\n", "+ \tabcdefGhijkl\n", "? \t ^ ^ ^\n"]);
let result = differ.qformat("\tabcDefghiJkl\n",
"\tabcdefGhijkl\n",
" ^ ^ ^ ",
" ^ ^ ^ ");
assert_eq!(result,
vec!["- \tabcDefghiJkl\n", "? \t ^ ^ ^\n", "+ \tabcdefGhijkl\n", "? \t ^ ^ ^\n"]);
}
src/lib.rs
+35 -15
View File
@@ -8,7 +8,11 @@ use sequencematcher::{SequenceMatcher, Sequence};
use utils::{format_range_unified, format_range_context};
pub fn get_close_matches<'a>(word: &str, possibilities: Vec<&'a str>, n: usize, cutoff: f32) -> Vec<&'a str> {
pub fn get_close_matches<'a>(word: &str,
possibilities: Vec<&'a str>,
n: usize,
cutoff: f32)
-> Vec<&'a str> {
if !(0.0 <= cutoff && cutoff <= 1.0) {
panic!("Cutoff must be greater than 0.0 and lower than 1.0");
}
@@ -26,8 +30,14 @@ pub fn get_close_matches<'a>(word: &str, possibilities: Vec<&'a str>, n: usize,
res.iter().map(|x| x.1).collect()
}
pub fn unified_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_file: &str, to_file: &str,
from_file_date: &str, to_file_date: &str, n: usize) -> Vec<String> {
pub fn unified_diff<T: Sequence>(first_sequence: &T,
second_sequence: &T,
from_file: &str,
to_file: &str,
from_file_date: &str,
to_file_date: &str,
n: usize)
-> Vec<String> {
let mut res = Vec::new();
let lineterm = '\n';
let mut started = false;
@@ -37,28 +47,28 @@ pub fn unified_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_f
started = true;
let from_date = format!("\t{}", from_file_date);
let to_date = format!("\t{}", to_file_date);
res.push( format!("--- {}{}{}", from_file, from_date, lineterm) );
res.push( format!("+++ {}{}{}", to_file, to_date, lineterm) );
res.push(format!("--- {}{}{}", from_file, from_date, lineterm));
res.push(format!("+++ {}{}{}", to_file, to_date, lineterm));
}
let (first, last) = (group.first().unwrap(), group.last().unwrap());
let file1_range = format_range_unified(first.first_start, last.first_end);
let file2_range = format_range_unified(first.second_start, last.second_end);
res.push( format!("@@ -{} +{} @@{}", file1_range, file2_range, lineterm) );
res.push(format!("@@ -{} +{} @@{}", file1_range, file2_range, lineterm));
for code in group {
if code.tag == "equal" {
for i in code.first_start..code.first_end {
res.push( format!(" {}", first_sequence.at_index(i).unwrap()) );
res.push(format!(" {}", first_sequence.at_index(i).unwrap()));
}
continue;
}
if code.tag == "replace" || code.tag == "delete" {
for i in code.first_start..code.first_end {
res.push( format!("-{}", first_sequence.at_index(i).unwrap()) );
res.push(format!("-{}", first_sequence.at_index(i).unwrap()));
}
}
if code.tag == "replace" || code.tag == "insert" {
for i in code.second_start..code.second_end {
res.push( format!("+{}", second_sequence.at_index(i).unwrap()) );
res.push(format!("+{}", second_sequence.at_index(i).unwrap()));
}
}
}
@@ -67,8 +77,14 @@ pub fn unified_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_f
}
pub fn context_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_file: &str, to_file: &str,
from_file_date: &str, to_file_date: &str, n: usize) -> Vec<String> {
pub fn context_diff<T: Sequence>(first_sequence: &T,
second_sequence: &T,
from_file: &str,
to_file: &str,
from_file_date: &str,
to_file_date: &str,
n: usize)
-> Vec<String> {
let mut res = Vec::new();
let lineterm = '\n';
let mut prefix: HashMap<String, String> = HashMap::new();
@@ -83,8 +99,8 @@ pub fn context_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_f
started = true;
let from_date = format!("\t{}", from_file_date);
let to_date = format!("\t{}", to_file_date);
res.push( format!("*** {}{}{}", from_file, from_date, lineterm) );
res.push( format!("--- {}{}{}", to_file, to_date, lineterm) );
res.push(format!("*** {}{}{}", from_file, from_date, lineterm));
res.push(format!("--- {}{}{}", to_file, to_date, lineterm));
}
let (first, last) = (group.first().unwrap(), group.last().unwrap());
res.push(format!("***************{}", lineterm));
@@ -101,7 +117,9 @@ pub fn context_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_f
for opcode in group {
if opcode.tag != "insert" {
for i in opcode.first_start..opcode.first_end {
res.push( format!("{}{}", prefix.get(&opcode.tag).unwrap(), first_sequence.at_index(i).unwrap()) );
res.push(format!("{}{}",
prefix.get(&opcode.tag).unwrap(),
first_sequence.at_index(i).unwrap()));
}
}
}
@@ -119,7 +137,9 @@ pub fn context_diff<T: Sequence>(first_sequence: &T, second_sequence: &T, from_f
for opcode in group {
if opcode.tag != "delete" {
for i in opcode.second_start..opcode.second_end {
res.push( format!("{}{}", prefix.get(&opcode.tag).unwrap(), second_sequence.at_index(i).unwrap()) );
res.push(format!("{}{}",
prefix.get(&opcode.tag).unwrap(),
second_sequence.at_index(i).unwrap()));
}
}
}
src/sequencematcher.rs
+86 -67
View File
@@ -4,39 +4,44 @@ use utils::calculate_ratio;
use std::fmt::Debug;
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord)]
pub struct Match{
pub struct Match {
pub first_start: usize,
pub second_start: usize,
pub size: usize
pub size: usize,
}
impl Match{
impl Match {
fn new(first_start: usize, second_start: usize, size: usize) -> Match {
Match{
Match {
first_start: first_start,
second_start: second_start,
size: size
size: size,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct Opcode{
pub struct Opcode {
pub tag: String,
pub first_start: usize,
pub first_end: usize,
pub second_start: usize,
pub second_end: usize
pub second_end: usize,
}
impl Opcode{
fn new(tag: String, first_start: usize, first_end: usize, second_start: usize, second_end: usize) -> Opcode {
Opcode{
impl Opcode {
fn new(tag: String,
first_start: usize,
first_end: usize,
second_start: usize,
second_end: usize)
-> Opcode {
Opcode {
tag: tag,
first_start: first_start,
first_end: first_end,
second_start: second_start,
second_end: second_end
second_end: second_end,
}
}
}
@@ -52,12 +57,10 @@ impl Sequence for str {
}
fn at_index(&self, index: usize) -> Option<&str> {
if index > self.len(){
return None
}
unsafe{
Some(self.slice_unchecked(index, index + 1))
if index > self.len() {
return None;
}
unsafe { Some(self.slice_unchecked(index, index + 1)) }
}
}
@@ -68,7 +71,7 @@ impl<'a> Sequence for Vec<&'a str> {
fn at_index(&self, index: usize) -> Option<&str> {
if index < self.len() {
return Some(self[index])
return Some(self[index]);
}
None
}
@@ -100,28 +103,27 @@ impl<'a> Sequence for Vec<String> {
}
}
pub struct SequenceMatcher<'a, T: 'a + ?Sized + Sequence>{
pub struct SequenceMatcher<'a, T: 'a + ?Sized + Sequence> {
first_sequence: &'a T,
second_sequence: &'a T,
matching_blocks: Option<Vec<Match>>,
opcodes: Option<Vec<Opcode>>,
is_junk: Option<fn(&str) -> bool>,
second_sequence_elements: HashMap<&'a str, Vec<usize>>,
second_sequence_popular: Vec<&'a str>
second_sequence_popular: Vec<&'a str>,
}
impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
pub fn new(first_sequence: &'a T, second_sequence: &'a T) -> SequenceMatcher<'a, T> {
let mut matcher =
SequenceMatcher{
let mut matcher = SequenceMatcher {
first_sequence: first_sequence,
second_sequence: second_sequence,
matching_blocks: None,
opcodes: None,
is_junk: None,
second_sequence_elements: HashMap::new(),
second_sequence_popular: Vec::new()
second_sequence_popular: Vec::new(),
};
matcher.set_seqs(first_sequence, second_sequence);
matcher
@@ -154,7 +156,8 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
let second_sequence = self.second_sequence;
let mut second_sequence_elements = HashMap::new();
for i in 0..second_sequence.len() {
let mut counter = second_sequence_elements.entry(second_sequence.at_index(i).unwrap()).or_insert(Vec::new());
let mut counter = second_sequence_elements.entry(second_sequence.at_index(i).unwrap())
.or_insert(Vec::new());
counter.push(i);
}
if self.is_junk.is_some() {
@@ -185,7 +188,12 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
self.second_sequence_popular = popular;
}
pub fn find_longest_match(&self, first_start: usize, first_end: usize, second_start: usize, second_end: usize) -> Match {
pub fn find_longest_match(&self,
first_start: usize,
first_end: usize,
second_start: usize,
second_end: usize)
-> Match {
let first_sequence = &self.first_sequence;
let second_sequence = &self.second_sequence;
let second_sequence_elements = &self.second_sequence_elements;
@@ -205,10 +213,10 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
};
let mut size = 0;
if j > 0 {
match j2len.get(&(j-1)){
match j2len.get(&(j - 1)) {
Some(k) => {
size = k.clone();
},
}
None => {}
}
}
@@ -220,20 +228,21 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
best_size = size;
}
}
},
None => {},
}
None => {}
}
j2len = new_j2len;
}
for _ in 0..2 {
while best_i > first_start && best_j > second_start &&
first_sequence.at_index(best_i - 1) == second_sequence.at_index(best_j-1){
first_sequence.at_index(best_i - 1) == second_sequence.at_index(best_j - 1) {
best_i = best_i - 1;
best_j = best_j - 1;
best_size = best_size + 1;
}
while best_i + best_size < first_end && best_j + best_size < second_end &&
first_sequence.at_index(best_i + best_size) == second_sequence.at_index(best_j + best_size) {
first_sequence.at_index(best_i + best_size) ==
second_sequence.at_index(best_j + best_size) {
best_size += 1;
}
}
@@ -241,37 +250,39 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
}
pub fn get_matching_blocks(&mut self) -> Vec<Match> {
if self.matching_blocks.as_ref().is_some(){
return self.matching_blocks.as_ref().unwrap().clone()
if self.matching_blocks.as_ref().is_some() {
return self.matching_blocks.as_ref().unwrap().clone();
}
let (first_length, second_length) = (self.first_sequence.len(), self.second_sequence.len());
let mut matches = Vec::new();
let mut queue = vec![(0, first_length, 0, second_length)];
while !queue.is_empty(){
while !queue.is_empty() {
let (first_start, first_end, second_start, second_end) = queue.pop().unwrap();
let m = self.find_longest_match(first_start, first_end, second_start, second_end);
match m.size {
0 => {},
0 => {}
_ => {
if first_start < m.first_start && second_start < m.second_start{
if first_start < m.first_start && second_start < m.second_start {
queue.push((first_start, m.first_start, second_start, m.second_start));
}
if m.first_start + m.size < first_end && m.second_start + m.size < second_end{
queue.push((m.first_start + m.size, first_end, m.second_start + m.size, second_end));
if m.first_start + m.size < first_end && m.second_start + m.size < second_end {
queue.push((m.first_start + m.size,
first_end,
m.second_start + m.size,
second_end));
}
matches.push(m);
},
}
}
}
matches.sort_by(|a, b| a.cmp(b));
let (mut first_start, mut second_start, mut size) = (0, 0, 0);
let mut non_adjacent = Vec::new();
for m in &matches{
if first_start + size == m.first_start && second_start + size == m.second_start{
for m in &matches {
if first_start + size == m.first_start && second_start + size == m.second_start {
size += m.size
}
else {
if size != 0{
} else {
if size != 0 {
non_adjacent.push(Match::new(first_start, second_start, size));
}
first_start = m.first_start;
@@ -279,7 +290,7 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
size = m.size;
}
}
if size != 0{
if size != 0 {
non_adjacent.push(Match::new(first_start, second_start, size));
}
non_adjacent.push(Match::new(first_length, second_length, 0));
@@ -287,34 +298,34 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
self.matching_blocks.as_ref().unwrap().clone()
}
pub fn get_opcodes(&mut self) -> Vec<Opcode>{
if self.opcodes.as_ref().is_some(){
return self.opcodes.as_ref().unwrap().clone()
pub fn get_opcodes(&mut self) -> Vec<Opcode> {
if self.opcodes.as_ref().is_some() {
return self.opcodes.as_ref().unwrap().clone();
}
let mut opcodes = Vec::new();
let (mut i, mut j) = (0, 0);
for m in self.get_matching_blocks(){
for m in self.get_matching_blocks() {
let mut tag = String::new();
if i < m.first_start && j < m.second_start{
if i < m.first_start && j < m.second_start {
tag = String::from("replace");
}
else if i < m.first_start{
} else if i < m.first_start {
tag = String::from("delete");
}
else if j < m.second_start{
} else if j < m.second_start {
tag = String::from("insert");
}
if !tag.is_empty(){
opcodes.push( Opcode::new(tag, i, m.first_start, j, m.second_start) );
if !tag.is_empty() {
opcodes.push(Opcode::new(tag, i, m.first_start, j, m.second_start));
}
i = m.first_start + m.size;
j = m.second_start + m.size;
if m.size != 0{
opcodes.push( Opcode::new(String::from("equal"), m.first_start, i, m.second_start, j) );
if m.size != 0 {
opcodes.push(
Opcode::new(String::from("equal"), m.first_start, i, m.second_start, j)
);
}
}
self.opcodes = Some(opcodes);
return self.opcodes.as_ref().unwrap().clone()
return self.opcodes.as_ref().unwrap().clone();
}
pub fn get_grouped_opcodes(&mut self, n: usize) -> Vec<Vec<Opcode>> {
@@ -338,24 +349,32 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T>{
let mut group = Vec::new();
for code in &codes {
let (mut first_start, mut second_start) = (code.first_start, code.second_start);
if code.tag == "equal" && code.first_end-code.first_start > nn {
group.push( Opcode::new(code.tag.clone(), code.first_start, min(code.first_end, code.first_start+n),
code.second_start, min(code.second_end, code.second_start+n)) );
if code.tag == "equal" && code.first_end - code.first_start > nn {
group.push(Opcode::new(code.tag.clone(),
code.first_start,
min(code.first_end, code.first_start + n),
code.second_start,
min(code.second_end, code.second_start + n)));
res.push(group.clone());
group.clear();
first_start = max(first_start, code.first_end-n);
first_start = max(first_start, code.first_end - n);
second_start = max(second_start, code.second_end - n);
}
group.push( Opcode::new(code.tag.clone(), first_start, code.first_end, second_start, code.second_end) );
group.push(Opcode::new(code.tag.clone(),
first_start,
code.first_end,
second_start,
code.second_end));
}
if !group.is_empty() && !(group.len()==1 && group.first().unwrap().tag == "equal") {
if !group.is_empty() && !(group.len() == 1 && group.first().unwrap().tag == "equal") {
res.push(group.clone());
}
res
}
pub fn ratio(&mut self) -> f32{
pub fn ratio(&mut self) -> f32 {
let matches = self.get_matching_blocks().iter().fold(0, |res, &m| res + m.size);
calculate_ratio(matches, self.first_sequence.len() + self.second_sequence.len())
calculate_ratio(matches,
self.first_sequence.len() + self.second_sequence.len())
}
}
src/utils.rs
+9 -9
View File
@@ -1,14 +1,14 @@
pub fn calculate_ratio(matches: usize, length: usize) -> f32{
if length != 0{
return 2.0 * matches as f32 / length as f32
pub fn calculate_ratio(matches: usize, length: usize) -> f32 {
if length != 0 {
return 2.0 * matches as f32 / length as f32;
}
return 1.0
return 1.0;
}
pub fn str_with_similar_chars(c: char, length: usize) -> String {
let mut s = String::new();
for _ in 0..length{
for _ in 0..length {
s.push_str(&c.to_string());
}
s
@@ -21,15 +21,15 @@ pub fn count_leading(line: &str, c: char) -> usize {
while (i < n) && line[i] == c {
i += 1;
}
return i
return i;
}
pub fn format_range_unified(start:usize, end: usize) -> String {
pub fn format_range_unified(start: usize, end: usize) -> String {
let mut beginning = start + 1;
let length = end - start;
if length == 1 {
return beginning.to_string()
return beginning.to_string();
}
if length == 0 {
beginning -= 1;
@@ -45,7 +45,7 @@ pub fn format_range_context(start: usize, end: usize) -> String {
beginning -= 1
}
if length <= 1 {
return beginning.to_string()
return beginning.to_string();
}
format!("{},{}", beginning, beginning + length - 1)
}
tests/tests.rs
+46 -29
View File
@@ -4,8 +4,7 @@ use difflib::sequencematcher::{SequenceMatcher, Match, Opcode};
use difflib::differ::Differ;
#[test]
fn test_longest_match()
{
fn test_longest_match() {
let matcher = SequenceMatcher::new(" abcd", "abcd abcd");
let m = matcher.find_longest_match(0, 5, 0, 9);
assert_eq!(m.first_start, 0);
@@ -14,25 +13,24 @@ fn test_longest_match()
}
#[test]
fn test_all_matches()
{
fn test_all_matches() {
let mut matcher = SequenceMatcher::new("abxcd", "abcd");
let result = matcher.get_matching_blocks();
let mut expected_result = Vec::new();
expected_result.push(Match{
expected_result.push(Match {
first_start: 0,
second_start: 0,
size: 2
size: 2,
});
expected_result.push(Match{
expected_result.push(Match {
first_start: 3,
second_start: 2,
size: 2
size: 2,
});
expected_result.push(Match{
expected_result.push(Match {
first_start: 5,
second_start: 4,
size: 0
size: 0,
});
assert_eq!(result, expected_result);
}
@@ -42,40 +40,40 @@ fn test_get_opcodes() {
let mut matcher = SequenceMatcher::new("qabxcd", "abycdf");
let result = matcher.get_opcodes();
let mut expected_result = Vec::new();
expected_result.push(Opcode{
expected_result.push(Opcode {
tag: "delete".to_string(),
first_start: 0,
first_end: 1,
second_start: 0,
second_end: 0
second_end: 0,
});
expected_result.push(Opcode{
expected_result.push(Opcode {
tag: "equal".to_string(),
first_start: 1,
first_end: 3,
second_start: 0,
second_end: 2
second_end: 2,
});
expected_result.push(Opcode{
expected_result.push(Opcode {
tag: "replace".to_string(),
first_start: 3,
first_end: 4,
second_start: 2,
second_end: 3
second_end: 3,
});
expected_result.push(Opcode{
expected_result.push(Opcode {
tag: "equal".to_string(),
first_start: 4,
first_end: 6,
second_start: 3,
second_end: 5
second_end: 5,
});
expected_result.push(Opcode{
expected_result.push(Opcode {
tag: "insert".to_string(),
first_start: 6,
first_end: 6,
second_start: 5,
second_end: 6
second_end: 6,
});
assert_eq!(result, expected_result);
}
@@ -99,12 +97,13 @@ fn test_differ_compare() {
let second_text = vec!["ore\n", "tree\n", "emu\n"];
let differ = Differ::new();
let result = differ.compare(&first_text, &second_text).join("");
assert_eq!(result, "- one\n? ^\n+ ore\n? ^\n- two\n- three\n? -\n+ tree\n+ emu\n");
assert_eq!(result,
"- one\n? ^\n+ ore\n? ^\n- two\n- three\n? -\n+ tree\n+ emu\n");
}
fn is_junk_char(ch: &str) -> bool {
if ch == " " || ch == "\t" {
return true
return true;
}
false
}
@@ -116,7 +115,8 @@ fn test_differ_compare_with_func() {
let mut differ = Differ::new();
differ.char_junk = Some(is_junk_char);
let result = differ.compare(&first_text, &second_text).join("");
assert_eq!(result, "- one\n? ^\n+ ore\n? ^\n- two\n- three\n? -\n+ tree\n+ emu\n");
assert_eq!(result,
"- one\n? ^\n+ ore\n? ^\n- two\n- three\n? -\n+ tree\n+ emu\n");
}
#[test]
@@ -133,16 +133,33 @@ fn test_differ_restore() {
fn test_unified_diff() {
let first_text = "one two three four".split(" ").collect::<Vec<&str>>();
let second_text = "zero one tree four".split(" ").collect::<Vec<&str>>();
let result = difflib::unified_diff(&first_text, &second_text, "Original", "Current",
"2005-01-26 23:30:50", "2010-04-02 10:20:52", 3).join("");
assert_eq!(result, "--- Original\t2005-01-26 23:30:50\n+++ Current\t2010-04-02 10:20:52\n@@ -1,4 +1,4 @@\n+zero one-two-three+tree four");
let result = difflib::unified_diff(&first_text,
&second_text,
"Original",
"Current",
"2005-01-26 23:30:50",
"2010-04-02 10:20:52",
3)
.join("");
assert_eq!(result,
"--- Original\t2005-01-26 23:30:50\n+++ Current\t2010-04-02 10:20:52\n@@ -1,4 \
+1,4 @@\n+zero one-two-three+tree four");
}
#[test]
fn test_context_diff() {
let first_text = "one two three four".split(" ").collect::<Vec<&str>>();
let second_text = "zero one tree four".split(" ").collect::<Vec<&str>>();
let result = difflib::context_diff(&first_text, &second_text, "Original", "Current",
"2005-01-26 23:30:50", "2010-04-02 10:20:52", 3).join("");
assert_eq!(result, "*** Original\t2005-01-26 23:30:50\n--- Current\t2010-04-02 10:20:52\n***************\n*** 1,4 ****\n one! two! three four--- 1,4 ----\n+ zero one! tree four");
let result = difflib::context_diff(&first_text,
&second_text,
"Original",
"Current",
"2005-01-26 23:30:50",
"2010-04-02 10:20:52",
3)
.join("");
assert_eq!(result,
"*** Original\t2005-01-26 23:30:50\n--- Current\t2010-04-02 \
10:20:52\n***************\n*** 1,4 ****\n one! two! three four--- 1,4 ----\n+ \
zero one! tree four");
}