Apply all Clippy lints that don't break the API
This commit is contained in:
+32
-32
@@ -2,6 +2,7 @@ use sequencematcher::SequenceMatcher;
|
||||
use std::cmp;
|
||||
use utils::{count_leading, str_with_similar_chars};
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Differ {
|
||||
pub line_junk: Option<fn(&str) -> bool>,
|
||||
pub char_junk: Option<fn(&str) -> bool>,
|
||||
@@ -53,9 +54,8 @@ impl Differ {
|
||||
fn dump(&self, tag: &str, sequence: &[&str], start: usize, end: usize) -> Vec<String> {
|
||||
let mut res = Vec::new();
|
||||
for i in start..end {
|
||||
match sequence.get(i) {
|
||||
Some(s) => res.push(format!("{} {}", tag, s)),
|
||||
None => {}
|
||||
if let Some(s) = sequence.get(i) {
|
||||
res.push(format!("{} {}", tag, s))
|
||||
}
|
||||
}
|
||||
res
|
||||
@@ -73,15 +73,17 @@ impl Differ {
|
||||
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 {
|
||||
first = self.dump("+", second_sequence, second_start, second_end);
|
||||
second = self.dump("-", first_sequence, first_start, first_end);
|
||||
let (mut first, second) = if second_end - second_start < first_end - first_start {
|
||||
(
|
||||
self.dump("+", second_sequence, second_start, second_end),
|
||||
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);
|
||||
}
|
||||
(
|
||||
self.dump("-", first_sequence, first_start, first_end),
|
||||
self.dump("+", second_sequence, second_start, second_end),
|
||||
)
|
||||
};
|
||||
for s in second {
|
||||
first.push(s);
|
||||
}
|
||||
@@ -100,13 +102,20 @@ impl Differ {
|
||||
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 {
|
||||
second_sequence_str = &second_sequence[j];
|
||||
for i in first_start..first_end {
|
||||
first_sequence_str = &first_sequence[i];
|
||||
for (j, second_sequence_str) in second_sequence
|
||||
.iter()
|
||||
.enumerate()
|
||||
.take(second_end)
|
||||
.skip(second_start)
|
||||
{
|
||||
for (i, first_sequence_str) in first_sequence
|
||||
.iter()
|
||||
.enumerate()
|
||||
.take(second_end)
|
||||
.skip(second_start)
|
||||
{
|
||||
if first_sequence_str == second_sequence_str {
|
||||
if eqi.is_none() {
|
||||
eqi = Some(i);
|
||||
@@ -254,40 +263,31 @@ impl Differ {
|
||||
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));
|
||||
let mut s = format!("- {}", first_line);
|
||||
res.push(s);
|
||||
if first_tags != "" {
|
||||
s = String::from(format!(
|
||||
"? {}{}\n",
|
||||
str_with_similar_chars('\t', common),
|
||||
first_tags
|
||||
));
|
||||
s = format!("? {}{}\n", str_with_similar_chars('\t', common), first_tags);
|
||||
res.push(s);
|
||||
}
|
||||
s = String::from(format!("+ {}", second_line));
|
||||
s = format!("+ {}", second_line);
|
||||
res.push(s);
|
||||
if second_tags != "" {
|
||||
s = String::from(format!(
|
||||
s = format!(
|
||||
"? {}{}\n",
|
||||
str_with_similar_chars('\t', common),
|
||||
second_tags
|
||||
));
|
||||
);
|
||||
res.push(s);
|
||||
}
|
||||
res
|
||||
}
|
||||
|
||||
pub fn restore(delta: &Vec<String>, which: usize) -> Vec<String> {
|
||||
pub fn restore(delta: &[String], which: usize) -> Vec<String> {
|
||||
if !(which == 1 || which == 2) {
|
||||
panic!("Second parameter must be 1 or 2");
|
||||
}
|
||||
let mut res = Vec::new();
|
||||
let tag;
|
||||
if which == 1 {
|
||||
tag = "- ".to_string();
|
||||
} else {
|
||||
tag = "+ ".to_string();
|
||||
}
|
||||
let tag = if which == 1 { "- " } else { "+ " }.to_string();
|
||||
let prefixes = vec![tag, " ".to_string()];
|
||||
for line in delta {
|
||||
for prefix in &prefixes {
|
||||
|
||||
+2
-2
@@ -122,7 +122,7 @@ pub fn context_diff<T: Sequence>(
|
||||
for i in opcode.first_start..opcode.first_end {
|
||||
res.push(format!(
|
||||
"{}{}",
|
||||
prefix.get(&opcode.tag).unwrap(),
|
||||
&prefix[&opcode.tag],
|
||||
first_sequence.at_index(i).unwrap()
|
||||
));
|
||||
}
|
||||
@@ -144,7 +144,7 @@ pub fn context_diff<T: Sequence>(
|
||||
for i in opcode.second_start..opcode.second_end {
|
||||
res.push(format!(
|
||||
"{}{}",
|
||||
prefix.get(&opcode.tag).unwrap(),
|
||||
&prefix[&opcode.tag],
|
||||
second_sequence.at_index(i).unwrap()
|
||||
));
|
||||
}
|
||||
|
||||
+21
-26
@@ -13,9 +13,9 @@ pub struct Match {
|
||||
impl Match {
|
||||
fn new(first_start: usize, second_start: usize, size: usize) -> Match {
|
||||
Match {
|
||||
first_start: first_start,
|
||||
second_start: second_start,
|
||||
size: size,
|
||||
first_start,
|
||||
second_start,
|
||||
size,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -38,11 +38,11 @@ impl Opcode {
|
||||
second_end: usize,
|
||||
) -> Opcode {
|
||||
Opcode {
|
||||
tag: tag,
|
||||
first_start: first_start,
|
||||
first_end: first_end,
|
||||
second_start: second_start,
|
||||
second_end: second_end,
|
||||
tag,
|
||||
first_start,
|
||||
first_end,
|
||||
second_start,
|
||||
second_end,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -129,8 +129,8 @@ pub struct SequenceMatcher<'a, T: 'a + ?Sized + Sequence> {
|
||||
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 {
|
||||
first_sequence: first_sequence,
|
||||
second_sequence: second_sequence,
|
||||
first_sequence,
|
||||
second_sequence,
|
||||
matching_blocks: None,
|
||||
opcodes: None,
|
||||
is_junk: None,
|
||||
@@ -169,7 +169,7 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
for i in 0..second_sequence.len() {
|
||||
let mut counter = second_sequence_elements
|
||||
.entry(second_sequence.at_index(i).unwrap())
|
||||
.or_insert(Vec::new());
|
||||
.or_insert_with(Vec::new);
|
||||
counter.push(i);
|
||||
}
|
||||
if let Some(junk_func) = self.is_junk {
|
||||
@@ -204,10 +204,10 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
let mut j2len: HashMap<usize, usize> = HashMap::new();
|
||||
for i in first_start..first_end {
|
||||
let mut new_j2len: HashMap<usize, usize> = HashMap::new();
|
||||
match second_sequence_elements.get(first_sequence.at_index(i).unwrap()) {
|
||||
Some(indexes) => {
|
||||
if let Some(indexes) = second_sequence_elements.get(first_sequence.at_index(i).unwrap())
|
||||
{
|
||||
for j in indexes {
|
||||
let j = j.clone();
|
||||
let j = *j;
|
||||
if j < second_start {
|
||||
continue;
|
||||
};
|
||||
@@ -216,11 +216,8 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
};
|
||||
let mut size = 0;
|
||||
if j > 0 {
|
||||
match j2len.get(&(j - 1)) {
|
||||
Some(k) => {
|
||||
size = k.clone();
|
||||
}
|
||||
None => {}
|
||||
if let Some(k) = j2len.get(&(j - 1)) {
|
||||
size = *k;
|
||||
}
|
||||
}
|
||||
size += 1;
|
||||
@@ -232,8 +229,6 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
}
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
j2len = new_j2len;
|
||||
}
|
||||
for _ in 0..2 {
|
||||
@@ -241,9 +236,9 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
&& best_j > second_start
|
||||
&& 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;
|
||||
best_i -= 1;
|
||||
best_j -= 1;
|
||||
best_size += 1;
|
||||
}
|
||||
while best_i + best_size < first_end && best_j + best_size < second_end
|
||||
&& first_sequence.at_index(best_i + best_size)
|
||||
@@ -337,7 +332,7 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
}
|
||||
}
|
||||
self.opcodes = Some(opcodes);
|
||||
return self.opcodes.as_ref().unwrap().clone();
|
||||
self.opcodes.as_ref().unwrap().clone()
|
||||
}
|
||||
|
||||
pub fn get_grouped_opcodes(&mut self, n: usize) -> Vec<Vec<Opcode>> {
|
||||
@@ -382,7 +377,7 @@ impl<'a, T: ?Sized + Sequence> SequenceMatcher<'a, T> {
|
||||
code.second_end,
|
||||
));
|
||||
}
|
||||
if !group.is_empty() && !(group.len() == 1 && group.first().unwrap().tag == "equal") {
|
||||
if !(group.len() == 1 && group.first().unwrap().tag == "equal") || group.is_empty() {
|
||||
res.push(group.clone());
|
||||
}
|
||||
res
|
||||
|
||||
+2
-2
@@ -2,7 +2,7 @@ pub fn calculate_ratio(matches: usize, length: usize) -> f32 {
|
||||
if length != 0 {
|
||||
return 2.0 * matches as f32 / length as f32;
|
||||
}
|
||||
return 1.0;
|
||||
1.0
|
||||
}
|
||||
|
||||
pub fn str_with_similar_chars(c: char, length: usize) -> String {
|
||||
@@ -19,7 +19,7 @@ pub fn count_leading(line: &str, c: char) -> usize {
|
||||
while (i < n) && line[i] == c {
|
||||
i += 1;
|
||||
}
|
||||
return i;
|
||||
i
|
||||
}
|
||||
|
||||
pub fn format_range_unified(start: usize, end: usize) -> String {
|
||||
|
||||
Reference in New Issue
Block a user