Removed unnecessary comparisons against bool literals

See this clippy lint for details:
https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison

Author: Raminder Singh

src/channel/command.rs

@@ -149,7 +149,7 @@ impl ChannelCommandBase {
                 ))])
             }
             (Some(manual_key), next_part) => {
-                if next_part.is_none() == true {
+                if next_part.is_none() {
                     if let Some(manual_data) = manuals.get(manual_key) {
                         Ok(vec![ChannelCommandResponse::Result(format!(
                             "{}({})",
@@ -171,7 +171,7 @@ impl ChannelCommandBase {
         let mut text_raw = String::new();
 
         while let Some(text_part) = parts.next() {
-            if text_raw.is_empty() == false {
+            if !text_raw.is_empty() {
                 text_raw.push_str(" ");
             }
 
@@ -209,7 +209,7 @@ impl ChannelCommandBase {
         let text_bytes = text_raw.as_bytes();
         let text_bytes_len = text_bytes.len();
 
-        if text_raw.is_empty() == true
+        if text_raw.is_empty()
             || text_bytes_len < 2
             || text_bytes[0] as char != TEXT_PART_BOUNDARY
             || text_bytes[text_bytes_len - 1] as char != TEXT_PART_BOUNDARY
@@ -231,7 +231,7 @@ impl ChannelCommandBase {
                     debug!("parsed text parts (post-processed): {}", text_inner_string);
 
                     // Text must not be empty
-                    if text_inner_string.is_empty() == false {
+                    if !text_inner_string.is_empty() {
                         Some(text_inner_string)
                     } else {
                         None
@@ -254,7 +254,7 @@ impl ChannelCommandBase {
     ) -> Option<MetaPartsResult<'a>> {
         if let Some(part) = parts.next() {
             // Parse meta (with format: 'KEY(VALUE)'; no '(' or ')' is allowed in KEY and VALUE)
-            if part.is_empty() == false {
+            if !part.is_empty() {
                 if let Some(index_open) = part.find(META_PART_GROUP_OPEN) {
                     let (key_bound_start, key_bound_end) = (0, index_open);
                     let (value_bound_start, value_bound_end) = (index_open + 1, part.len() - 1);
@@ -266,10 +266,10 @@ impl ChannelCommandBase {
                         );
 
                         // Ensure final key and value do not contain reserved syntax characters
-                        return if key.contains(META_PART_GROUP_OPEN) == false
-                            && key.contains(META_PART_GROUP_CLOSE) == false
-                            && value.contains(META_PART_GROUP_OPEN) == false
-                            && value.contains(META_PART_GROUP_CLOSE) == false
+                        return if !key.contains(META_PART_GROUP_OPEN)
+                            && !key.contains(META_PART_GROUP_CLOSE)
+                            && !value.contains(META_PART_GROUP_OPEN)
+                            && !value.contains(META_PART_GROUP_CLOSE)
                         {
                             debug!("parsed meta part as: {} = {}", key, value);
 
@@ -781,7 +781,7 @@ impl ChannelCommandControl {
                 CONTROL_TRIGGER_ACTIONS.join(", ")
             ))]),
             (Some(action_key), next_part) => {
-                if next_part.is_none() == true {
+                if next_part.is_none() {
                     let action_key_lower = action_key.to_lowercase();
 
                     match action_key_lower.as_str() {

src/channel/handle.rs

@@ -98,7 +98,7 @@ impl ChannelHandle {
     }
 
     fn configure_stream(stream: &TcpStream, is_established: bool) {
-        let tcp_timeout = if is_established == true {
+        let tcp_timeout = if is_established {
             APP_CONF.channel.tcp_timeout
         } else {
             TCP_TIMEOUT_NON_ESTABLISHED
@@ -170,7 +170,7 @@ impl ChannelHandle {
                         }
 
                         // Incomplete line remaining? Put it back in buffer.
-                        if processed_line.is_empty() == false {
+                        if !processed_line.is_empty() {
                             buffer.extend(processed_line);
                         }
                     }

src/channel/message.rs

@@ -69,7 +69,7 @@ impl ChannelMessage {
 
         // Serve response messages on socket
         for response_args in response_args_groups {
-            if response_args.0.is_empty() == false {
+            if !response_args.0.is_empty() {
                 if let Some(ref values) = response_args.1 {
                     let values_string = values.join(" ");
 

src/executor/flushb.rs

@@ -21,7 +21,7 @@ impl ExecutorFlushB {
                 // Important: acquire bucket store write lock
                 executor_kv_lock_write!(kv_store);
 
-                if kv_store.is_some() == true {
+                if kv_store.is_some() {
                     // Store exists, proceed erasure.
                     debug!(
                         "collection store exists, erasing: {} from {}",
@@ -35,7 +35,7 @@ impl ExecutorFlushB {
                     //   erasing a bucket requires a database lock, which would incur a dead-lock, \
                     //   thus we need to perform the erasure from there.
                     if let Ok(erase_count) = kv_action.batch_erase_bucket() {
-                        if StoreFSTActionBuilder::erase(collection, Some(bucket)).is_ok() == true {
+                        if StoreFSTActionBuilder::erase(collection, Some(bucket)).is_ok() {
                             debug!("done with bucket erasure");
 
                             return Ok(erase_count);

src/executor/pop.rs

@@ -89,20 +89,20 @@ impl ExecutorPop {
                                     // Nuke IID in Term-to-IIDs list
                                     for (pop_term, pop_term_hashed) in &pop_terms {
                                         // Check that term is linked to IID (and should be removed)
-                                        if iid_terms_hashed.contains(pop_term_hashed) == true {
+                                        if iid_terms_hashed.contains(pop_term_hashed) {
                                             if let Ok(Some(mut pop_term_iids)) =
                                                 kv_action.get_term_to_iids(*pop_term_hashed)
                                             {
                                                 // Remove IID from list of IIDs to be popped
                                                 pop_term_iids.retain(|cur_iid| cur_iid != &iid);
 
-                                                if pop_term_iids.is_empty() == true {
+                                                if pop_term_iids.is_empty() {
                                                     // IIDs list was empty, delete whole key
                                                     executor_ensure_op!(kv_action
                                                         .delete_term_to_iids(*pop_term_hashed));
 
                                                     // Pop from FST graph (does not exist anymore)
-                                                    if fst_action.pop_word(pop_term) == true {
+                                                    if fst_action.pop_word(pop_term) {
                                                         debug!(
                                                             "pop term hash nuked from graph: {}",
                                                             pop_term_hashed

src/executor/push.rs

@@ -58,7 +58,6 @@ impl ExecutorPush {
                                 StoreMetaValue::IIDIncr(iid_incr),
                             )
                             .is_ok()
-                            == true
                         {
                             // Associate OID <> IID (bidirectional)
                             executor_ensure_op!(kv_action.set_oid_to_iid(oid, iid_incr));
@@ -96,7 +95,7 @@ impl ExecutorPush {
 
                     while let Some((term, term_hashed)) = lexer.next() {
                         // Check that term is not already linked to IID
-                        if iid_terms_hashed.contains(&term_hashed) == false {
+                        if !iid_terms_hashed.contains(&term_hashed) {
                             if let Ok(term_iids) = kv_action.get_term_to_iids(term_hashed) {
                                 has_commits = true;
 
@@ -105,7 +104,7 @@ impl ExecutorPush {
 
                                 // Remove IID from list of IIDs to be popped before inserting in \
                                 //   first position?
-                                if term_iids.contains(&iid) == true {
+                                if term_iids.contains(&iid) {
                                     term_iids.retain(|cur_iid| cur_iid != &iid);
                                 }
 
@@ -141,13 +140,13 @@ impl ExecutorPush {
                         }
 
                         // Push to FST graph? (this consumes the term; to avoid sub-clones)
-                        if fst_action.push_word(&term) == true {
+                        if fst_action.push_word(&term) {
                             debug!("push term commited to graph: {}", term);
                         }
                     }
 
                     // Commit updated list of terms for IID? (if any commit made)
-                    if has_commits == true {
+                    if has_commits {
                         let collected_iids: Vec<StoreTermHashed> =
                             iid_terms_hashed.into_iter().collect();
 

src/executor/search.rs

@@ -101,7 +101,7 @@ impl ExecutorSearch {
                                         // Do not append the same IID twice (can happen a lot \
                                         //   when completing from suggested results that point \
                                         //   to the same end-OID)
-                                        if iids.contains(&suggested_iid) == false {
+                                        if !iids.contains(&suggested_iid) {
                                             iids.insert(suggested_iid);
 
                                             iids_new_len += 1;
@@ -133,7 +133,7 @@ impl ExecutorSearch {
                     debug!("got search executor iids: {:?} for term: {}", iids, term);
 
                     // Intersect found IIDs with previous batch
-                    if found_iids.is_empty() == true {
+                    if found_iids.is_empty() {
                         found_iids = iids;
                     } else {
                         found_iids = found_iids.intersection(&iids).map(|value| *value).collect();
@@ -145,7 +145,7 @@ impl ExecutorSearch {
                     );
 
                     // No IID found? (stop there)
-                    if found_iids.is_empty() == true {
+                    if found_iids.is_empty() {
                         info!(
                             "stop search executor as no iid was found in common for term: {}",
                             term
@@ -177,7 +177,7 @@ impl ExecutorSearch {
 
                 info!("got search executor final oids: {:?}", result_oids);
 
-                return Ok(if result_oids.is_empty() == false {
+                return Ok(if !result_oids.is_empty() {
                     Some(result_oids)
                 } else {
                     None

src/lexer/stopwords.rs

@@ -139,7 +139,7 @@ impl LexerStopWord {
     pub fn is(word: &str, locale: Option<Lang>) -> bool {
         if let Some(locale) = locale {
             // Word is a stopword (given locale)
-            if Self::lang_stopwords(locale).contains(word) == true {
+            if Self::lang_stopwords(locale).contains(word) {
                 return true;
             }
         }
@@ -171,14 +171,14 @@ impl LexerStopWord {
         for script_lang in script_langs {
             let lang_stopwords = Self::lang_stopwords(*script_lang);
 
-            if lang_stopwords.is_empty() == false {
+            if !lang_stopwords.is_empty() {
                 let mut lang_count = 0;
 
                 // This is a simple split, that does not take into account uppercase letters and \
                 //   punctuation, as to prevent memory allocations and other heavy operations. \
                 //   Trade-offs are made as this is a best-effort last-resort check.
                 for word in &text_split {
-                    if lang_stopwords.contains(word) == true {
+                    if lang_stopwords.contains(word) {
                         lang_count += 1;
                     }
                 }

src/lexer/token.rs

@@ -144,7 +144,7 @@ impl TokenLexerBuilder {
                 // Confidence is low, try to detect locale from stop-words.
                 // Notice: this is a fallback but should not be too reliable for short \
                 //   texts.
-                if detector.is_reliable() == false {
+                if !detector.is_reliable() {
                     debug!("[slow lexer] trying to detect locale from stopwords instead");
 
                     // Better alternate locale found?
@@ -238,15 +238,15 @@ impl<'a> Iterator for TokenLexer<'a> {
 
             // Check if normalized word is a stop-word? (if should normalize and cleanup)
             if self.mode == TokenLexerMode::NormalizeOnly
-                || LexerStopWord::is(&word, self.locale) == false
+                || !LexerStopWord::is(&word, self.locale)
             {
                 // Hash the term (this is used by all iterator consumers, as well as internally \
                 //   in the iterator to keep track of already-yielded words in a space-optimized \
                 //   manner, ie. by using 32-bit unsigned integer hashes)
                 let term_hash = StoreTermHash::from(&word);
 
                 // Check if word was not already yielded? (we return unique words)
-                if self.yields.contains(&term_hash) == false {
+                if !self.yields.contains(&term_hash) {
                     debug!("lexer yielded word: {}", word);
 
                     self.yields.insert(term_hash);