From 1bd11390e626f8fa00a11c2f61dd1f6d9cea877a Mon Sep 17 00:00:00 2001
From: Ole Martin Ruud <barskern@outlook.com>
Date: Fri, 30 Aug 2019 20:42:34 +0200
Subject: [PATCH 1/2] Run cargo fmt on whole project

---
 examples/document.rs            |  2 +-
 examples/fragment.rs            |  2 +-
 src/element_ref/element.rs      | 12 +++---
 src/element_ref/mod.rs          | 12 ++++--
 src/element_ref/serializable.rs | 13 +++---
 src/html/mod.rs                 | 19 ++++++---
 src/html/tree_sink.rs           | 55 ++++++++++++++-----------
 src/lib.rs                      | 18 ++++++---
 src/main.rs                     | 72 +++++++++++++++++----------------
 src/node.rs                     |  6 +--
 src/selector.rs                 |  4 +-
 11 files changed, 125 insertions(+), 90 deletions(-)

diff --git a/examples/document.rs b/examples/document.rs
index 00621eb7..a8a0eeca 100644
--- a/examples/document.rs
+++ b/examples/document.rs
@@ -2,7 +2,7 @@ extern crate scraper;
 
 use std::io::{self, Read, Write};
 
-use scraper::{Selector, Html};
+use scraper::{Html, Selector};
 
 fn main() {
     let mut input = String::new();
diff --git a/examples/fragment.rs b/examples/fragment.rs
index eb944bd7..7ab0a2bf 100644
--- a/examples/fragment.rs
+++ b/examples/fragment.rs
@@ -2,7 +2,7 @@ extern crate scraper;
 
 use std::io::{self, Read, Write};
 
-use scraper::{Selector, Html};
+use scraper::{Html, Selector};
 
 fn main() {
     let mut input = String::new();
diff --git a/src/element_ref/element.rs b/src/element_ref/element.rs
index 28c5cb11..ad4fb1e1 100644
--- a/src/element_ref/element.rs
+++ b/src/element_ref/element.rs
@@ -1,7 +1,7 @@
-use selectors::{Element, OpaqueElement};
-use selectors::attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint};
 use html5ever::{LocalName, Namespace};
+use selectors::attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint};
 use selectors::matching;
+use selectors::{Element, OpaqueElement};
 
 use super::ElementRef;
 use selector::{NonTSPseudoClass, PseudoElement, Simple};
@@ -59,7 +59,8 @@ impl<'a> Element for ElementRef<'a> {
     ) -> bool {
         self.value().attrs.iter().any(|(key, value)| {
             !matches!(*ns, NamespaceConstraint::Specific(url) if *url != key.ns)
-                && *local_name == key.local && operation.eval_str(value)
+                && *local_name == key.local
+                && operation.eval_str(value)
         })
     }
 
@@ -100,7 +101,8 @@ impl<'a> Element for ElementRef<'a> {
     }
 
     fn is_empty(&self) -> bool {
-        !self.children()
+        !self
+            .children()
             .any(|child| child.value().is_element() || child.value().is_text())
     }
 
@@ -114,8 +116,8 @@ impl<'a> Element for ElementRef<'a> {
 mod tests {
     use html::Html;
     use selector::Selector;
-    use selectors::Element;
     use selectors::attr::CaseSensitivity;
+    use selectors::Element;
 
     #[test]
     fn test_has_id() {
diff --git a/src/element_ref/mod.rs b/src/element_ref/mod.rs
index 5f644e3d..3003701b 100644
--- a/src/element_ref/mod.rs
+++ b/src/element_ref/mod.rs
@@ -2,12 +2,12 @@
 
 use std::ops::Deref;
 
+use ego_tree::iter::{Edge, Traverse};
 use ego_tree::NodeRef;
-use ego_tree::iter::{Traverse, Edge};
 use html5ever::serialize::{serialize, SerializeOpts, TraversalScope};
 
-use {Node, Selector};
 use node::Element;
+use {Node, Selector};
 
 /// Wrapper around a reference to an element node.
 ///
@@ -71,13 +71,17 @@ impl<'a> ElementRef<'a> {
 
     /// Returns an iterator over descendent text nodes.
     pub fn text(&self) -> Text<'a> {
-        Text { inner: self.traverse() }
+        Text {
+            inner: self.traverse(),
+        }
     }
 }
 
 impl<'a> Deref for ElementRef<'a> {
     type Target = NodeRef<'a, Node>;
-    fn deref(&self) -> &NodeRef<'a, Node> { &self.node }
+    fn deref(&self) -> &NodeRef<'a, Node> {
+        &self.node
+    }
 }
 
 /// Iterator over descendent elements matching a selector.
diff --git a/src/element_ref/serializable.rs b/src/element_ref/serializable.rs
index 79971e32..568e788c 100644
--- a/src/element_ref/serializable.rs
+++ b/src/element_ref/serializable.rs
@@ -5,7 +5,6 @@ use html5ever::serialize::{Serialize, Serializer, TraversalScope};
 
 use {ElementRef, Node};
 
-
 impl<'a> Serialize for ElementRef<'a> {
     fn serialize<S: Serializer>(
         &self,
@@ -22,20 +21,20 @@ impl<'a> Serialize for ElementRef<'a> {
                     match *node.value() {
                         Node::Doctype(ref doctype) => {
                             try!(serializer.write_doctype(doctype.name()));
-                        },
+                        }
                         Node::Comment(ref comment) => {
                             try!(serializer.write_comment(comment));
-                        },
+                        }
                         Node::Text(ref text) => {
                             try!(serializer.write_text(text));
-                        },
+                        }
                         Node::Element(ref elem) => {
                             let attrs = elem.attrs.iter().map(|(k, v)| (k, &v[..]));
                             try!(serializer.start_elem(elem.name.clone(), attrs));
-                        },
+                        }
                         _ => (),
                     }
-                },
+                }
 
                 Edge::Close(node) => {
                     if node == **self && traversal_scope == TraversalScope::ChildrenOnly(None) {
@@ -45,7 +44,7 @@ impl<'a> Serialize for ElementRef<'a> {
                     if let Some(elem) = node.value().as_element() {
                         try!(serializer.end_elem(elem.name.clone()));
                     }
-                },
+                }
             }
         }
 
diff --git a/src/html/mod.rs b/src/html/mod.rs
index b174f37c..2962916f 100644
--- a/src/html/mod.rs
+++ b/src/html/mod.rs
@@ -2,15 +2,15 @@
 
 use std::borrow::Cow;
 
-use ego_tree::Tree;
 use ego_tree::iter::Nodes;
+use ego_tree::Tree;
 use html5ever::driver;
 use html5ever::tree_builder::QuirksMode;
 use html5ever::QualName;
 use tendril::TendrilSink;
 
-use {Node, ElementRef};
 use selector::Selector;
+use {ElementRef, Node};
 
 /// An HTML tree.
 ///
@@ -136,7 +136,10 @@ mod tests {
     fn root_element_fragment() {
         let html = Html::parse_fragment(r#"<a href="http://github.com">1</a>"#);
         let root_ref = html.root_element();
-        let href = root_ref.select(&Selector::parse("a").unwrap()).next().unwrap();
+        let href = root_ref
+            .select(&Selector::parse("a").unwrap())
+            .next()
+            .unwrap();
         assert_eq!(href.inner_html(), "1");
         assert_eq!(href.value().attr("href").unwrap(), "http://github.com");
     }
@@ -145,7 +148,10 @@ mod tests {
     fn root_element_document_doctype() {
         let html = Html::parse_document("<!DOCTYPE html>\n<title>abc</title>");
         let root_ref = html.root_element();
-        let title = root_ref.select(&Selector::parse("title").unwrap()).next().unwrap();
+        let title = root_ref
+            .select(&Selector::parse("title").unwrap())
+            .next()
+            .unwrap();
         assert_eq!(title.inner_html(), "abc");
     }
 
@@ -153,7 +159,10 @@ mod tests {
     fn root_element_document_comment() {
         let html = Html::parse_document("<!-- comment --><title>abc</title>");
         let root_ref = html.root_element();
-        let title = root_ref.select(&Selector::parse("title").unwrap()).next().unwrap();
+        let title = root_ref
+            .select(&Selector::parse("title").unwrap())
+            .next()
+            .unwrap();
         assert_eq!(title.inner_html(), "abc");
     }
 }
diff --git a/src/html/tree_sink.rs b/src/html/tree_sink.rs
index 2737c4b3..3cfbe1b0 100644
--- a/src/html/tree_sink.rs
+++ b/src/html/tree_sink.rs
@@ -1,19 +1,21 @@
 use std::borrow::Cow;
 
+use super::Html;
 use ego_tree::NodeId;
-use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, ElementFlags};
-use html5ever::Attribute;
-use html5ever::{QualName, ExpandedName};
 use html5ever::tendril::StrTendril;
-use super::Html;
-use node::{Node, Doctype, Comment, Text, Element, ProcessingInstruction};
+use html5ever::tree_builder::{ElementFlags, NodeOrText, QuirksMode, TreeSink};
+use html5ever::Attribute;
+use html5ever::{ExpandedName, QualName};
+use node::{Comment, Doctype, Element, Node, ProcessingInstruction, Text};
 
 /// Note: does not support the `<template>` element.
 impl TreeSink for Html {
     type Output = Self;
     type Handle = NodeId;
 
-    fn finish(self) -> Self { self }
+    fn finish(self) -> Self {
+        self
+    }
 
     // Signal a parse error.
     fn parse_error(&mut self, msg: Cow<'static, str>) {
@@ -60,7 +62,9 @@ impl TreeSink for Html {
         attrs: Vec<Attribute>,
         _flags: ElementFlags,
     ) -> Self::Handle {
-        let mut node = self.tree.orphan(Node::Element(Element::new(name.clone(), attrs)));
+        let mut node = self
+            .tree
+            .orphan(Node::Element(Element::new(name.clone(), attrs)));
         if name.expanded() == expanded_name!(html "template") {
             node.append(Node::Fragment);
         }
@@ -69,7 +73,9 @@ impl TreeSink for Html {
 
     // Create a comment node.
     fn create_comment(&mut self, text: StrTendril) -> Self::Handle {
-        self.tree.orphan(Node::Comment(Comment { comment: text })).id()
+        self.tree
+            .orphan(Node::Comment(Comment { comment: text }))
+            .id()
     }
 
     // Append a DOCTYPE element to the Document node.
@@ -77,7 +83,7 @@ impl TreeSink for Html {
         &mut self,
         name: StrTendril,
         public_id: StrTendril,
-        system_id: StrTendril
+        system_id: StrTendril,
     ) {
         let doctype = Doctype {
             name: name,
@@ -97,10 +103,11 @@ impl TreeSink for Html {
         match child {
             NodeOrText::AppendNode(id) => {
                 parent.append_id(id);
-            },
+            }
 
             NodeOrText::AppendText(text) => {
-                let can_concat = parent.last_child()
+                let can_concat = parent
+                    .last_child()
                     .map_or(false, |mut n| n.value().is_text());
 
                 if can_concat {
@@ -127,7 +134,7 @@ impl TreeSink for Html {
     fn append_before_sibling(
         &mut self,
         sibling: &Self::Handle,
-        new_node: NodeOrText<Self::Handle>
+        new_node: NodeOrText<Self::Handle>,
     ) {
         if let NodeOrText::AppendNode(id) = new_node {
             self.tree.get_mut(id).unwrap().detach();
@@ -138,13 +145,12 @@ impl TreeSink for Html {
             match new_node {
                 NodeOrText::AppendNode(id) => {
                     sibling.insert_id_before(id);
-                },
+                }
 
                 NodeOrText::AppendText(text) => {
-                    let can_concat = sibling.prev_sibling().map_or(
-                        false,
-                        |mut n| n.value().is_text(),
-                    );
+                    let can_concat = sibling
+                        .prev_sibling()
+                        .map_or(false, |mut n| n.value().is_text());
 
                     if can_concat {
                         let mut prev_sibling = sibling.prev_sibling().unwrap();
@@ -167,7 +173,10 @@ impl TreeSink for Html {
 
     // Remove all the children from node and append them to new_parent.
     fn reparent_children(&mut self, node: &Self::Handle, new_parent: &Self::Handle) {
-        self.tree.get_mut(*new_parent).unwrap().reparent_from_id_append(*node);
+        self.tree
+            .get_mut(*new_parent)
+            .unwrap()
+            .reparent_from_id_append(*node);
     }
 
     // Add each attribute to the given element, if no attribute with that name already exists. The
@@ -193,15 +202,15 @@ impl TreeSink for Html {
     }
 
     // Mark a HTML <script> element as "already started".
-    fn mark_script_already_started(&mut self, _node: &Self::Handle) {
-    }
+    fn mark_script_already_started(&mut self, _node: &Self::Handle) {}
 
     // Create Processing Instruction.
     fn create_pi(&mut self, target: StrTendril, data: StrTendril) -> Self::Handle {
         self.tree
-            .orphan(Node::ProcessingInstruction(
-                ProcessingInstruction { target, data },
-            ))
+            .orphan(Node::ProcessingInstruction(ProcessingInstruction {
+                target,
+                data,
+            }))
             .id()
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index 260dbb7a..4d37f813 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -123,9 +123,17 @@
 //! assert_eq!(vec!["Hello, ", "world!"], text);
 //! ```
 
-#![warn(missing_docs, missing_debug_implementations, missing_copy_implementations, trivial_casts,
-        trivial_numeric_casts, unused_extern_crates, unused_import_braces, unused_qualifications,
-        variant_size_differences)]
+#![warn(
+    missing_docs,
+    missing_debug_implementations,
+    missing_copy_implementations,
+    trivial_casts,
+    trivial_numeric_casts,
+    unused_extern_crates,
+    unused_import_braces,
+    unused_qualifications,
+    variant_size_differences
+)]
 
 extern crate cssparser;
 extern crate ego_tree;
@@ -137,12 +145,12 @@ extern crate selectors;
 extern crate smallvec;
 extern crate tendril;
 
+pub use element_ref::ElementRef;
 pub use html::Html;
 pub use node::Node;
-pub use element_ref::ElementRef;
 pub use selector::Selector;
 
+pub mod element_ref;
 pub mod html;
 pub mod node;
-pub mod element_ref;
 pub mod selector;
diff --git a/src/main.rs b/src/main.rs
index 667c35c8..b18f7090 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -40,7 +40,10 @@ fn query<T: Read>(input: &Input, output: &Output, selector: &Selector, file: &mu
             Html => println!("{}", element.html()),
             InnerHtml => println!("{}", element.inner_html()),
             Attr(ref attr) => println!("{}", element.value().attr(attr).unwrap_or("")),
-            Classes => println!("{}", element.value().classes().collect::<Vec<_>>().join(" ")),
+            Classes => println!(
+                "{}",
+                element.value().classes().collect::<Vec<_>>().join(" ")
+            ),
             Id => println!("{}", element.value().id().unwrap_or("")),
             Name => println!("{}", element.value().name()),
             Text => println!("{}", element.text().collect::<String>()),
@@ -70,7 +73,10 @@ fn main() {
         Err(f) => panic!(f.to_string()),
     };
     if matches.opt_present("h") {
-        print!("{}", opts.usage("Usage: scraper [options] SELECTOR [FILE ...]"));
+        print!(
+            "{}",
+            opts.usage("Usage: scraper [options] SELECTOR [FILE ...]")
+        );
         return;
     }
 
@@ -85,45 +91,43 @@ fn main() {
         return;
     }
 
-    let input =
-        if matches.opt_present("f") {
-            Input::Fragment
-        } else {
-            Input::Document
-        };
+    let input = if matches.opt_present("f") {
+        Input::Fragment
+    } else {
+        Input::Document
+    };
 
-    let output =
-        if matches.opt_present("I") {
-            Output::InnerHtml
-        } else if matches.opt_present("a") {
-            Output::Attr(matches.opt_str("a").unwrap())
-        } else if matches.opt_present("c") {
-            Output::Classes
-        } else if matches.opt_present("i") {
-            Output::Id
-        } else if matches.opt_present("n") {
-            Output::Name
-        } else if matches.opt_present("t") {
-            Output::Text
-        } else {
-            Output::Html
-        };
+    let output = if matches.opt_present("I") {
+        Output::InnerHtml
+    } else if matches.opt_present("a") {
+        Output::Attr(matches.opt_str("a").unwrap())
+    } else if matches.opt_present("c") {
+        Output::Classes
+    } else if matches.opt_present("i") {
+        Output::Id
+    } else if matches.opt_present("n") {
+        Output::Name
+    } else if matches.opt_present("t") {
+        Output::Text
+    } else {
+        Output::Html
+    };
 
     let selector = matches.free.first().expect("missing selector");
     let files = &matches.free[1..];
 
     let selector = Selector::parse(selector).unwrap();
 
-    let matched =
-        if files.is_empty() {
-            query(&input, &output, &selector, &mut io::stdin())
-        } else {
-            files.into_iter()
-                .map(File::open)
-                .map(Result::unwrap)
-                .map(|mut f| query(&input, &output, &selector, &mut f))
-                .fold(false, |a, m| a || m)
-        };
+    let matched = if files.is_empty() {
+        query(&input, &output, &selector, &mut io::stdin())
+    } else {
+        files
+            .into_iter()
+            .map(File::open)
+            .map(Result::unwrap)
+            .map(|mut f| query(&input, &output, &selector, &mut f))
+            .fold(false, |a, m| a || m)
+    };
 
     process::exit(if matched { 0 } else { 1 });
 }
diff --git a/src/node.rs b/src/node.rs
index 364729a7..91221bd3 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -1,12 +1,12 @@
 //! HTML nodes.
 
+use std::collections::{hash_map, hash_set};
+use std::collections::{HashMap, HashSet};
 use std::fmt;
 use std::ops::Deref;
-use std::collections::{HashMap, HashSet};
-use std::collections::{hash_map, hash_set};
 
-use html5ever::{Attribute, LocalName, QualName};
 use html5ever::tendril::StrTendril;
+use html5ever::{Attribute, LocalName, QualName};
 
 use selectors::attr::CaseSensitivity;
 
diff --git a/src/selector.rs b/src/selector.rs
index 59ba0373..354cfca7 100644
--- a/src/selector.rs
+++ b/src/selector.rs
@@ -4,10 +4,10 @@ use std::fmt;
 
 use smallvec::SmallVec;
 
-use html5ever::{LocalName, Namespace};
 use cssparser;
-use selectors::{matching, parser, visitor};
+use html5ever::{LocalName, Namespace};
 use selectors::parser::SelectorParseErrorKind;
+use selectors::{matching, parser, visitor};
 
 use ElementRef;
 

From cffc8f7193e1eb995b13a8184b2f809638aee2d8 Mon Sep 17 00:00:00 2001
From: Ole Martin Ruud <barskern@outlook.com>
Date: Fri, 30 Aug 2019 20:39:47 +0200
Subject: [PATCH 2/2] Add 'try_select' which takes a 'str'

---
 src/element_ref/mod.rs | 37 +++++++++++++++++++++++++++++++++++++
 src/html/mod.rs        | 36 ++++++++++++++++++++++++++++++++++++
 src/selector.rs        |  6 +++---
 3 files changed, 76 insertions(+), 3 deletions(-)

diff --git a/src/element_ref/mod.rs b/src/element_ref/mod.rs
index 3003701b..a5ab7746 100644
--- a/src/element_ref/mod.rs
+++ b/src/element_ref/mod.rs
@@ -7,6 +7,7 @@ use ego_tree::NodeRef;
 use html5ever::serialize::{serialize, SerializeOpts, TraversalScope};
 
 use node::Element;
+use selectors::parser::SelectorParseErrorKind;
 use {Node, Selector};
 
 /// Wrapper around a reference to an element node.
@@ -48,6 +49,18 @@ impl<'a> ElementRef<'a> {
         }
     }
 
+    /// Returns an iterator over descendent elements matching a selector.
+    pub fn try_select<'s>(
+        &self,
+        selector: &'s str,
+    ) -> Result<SelectOwned<'_>, cssparser::ParseError<'s, SelectorParseErrorKind<'s>>> {
+        let mut inner = self.traverse();
+        inner.next(); // Skip Edge::Open(self).
+        let selector = Selector::parse(selector)?;
+
+        Ok(SelectOwned { inner, selector })
+    }
+
     fn serialize(&self, traversal_scope: TraversalScope) -> String {
         let opts = SerializeOpts {
             scripting_enabled: false, // It's not clear what this does.
@@ -108,6 +121,30 @@ impl<'a, 'b> Iterator for Select<'a, 'b> {
     }
 }
 
+/// Iterator over descendent elements matching a selector.
+#[derive(Debug, Clone)]
+pub struct SelectOwned<'a> {
+    inner: Traverse<'a, Node>,
+    selector: Selector,
+}
+
+impl<'a> Iterator for SelectOwned<'a> {
+    type Item = ElementRef<'a>;
+
+    fn next(&mut self) -> Option<ElementRef<'a>> {
+        for edge in &mut self.inner {
+            if let Edge::Open(node) = edge {
+                if let Some(element) = ElementRef::wrap(node) {
+                    if self.selector.matches(&element) {
+                        return Some(element);
+                    }
+                }
+            }
+        }
+        None
+    }
+}
+
 /// Iterator over descendent text nodes.
 #[derive(Debug, Clone)]
 pub struct Text<'a> {
diff --git a/src/html/mod.rs b/src/html/mod.rs
index 2962916f..6db44511 100644
--- a/src/html/mod.rs
+++ b/src/html/mod.rs
@@ -10,6 +10,7 @@ use html5ever::QualName;
 use tendril::TendrilSink;
 
 use selector::Selector;
+use selectors::parser::SelectorParseErrorKind;
 use {ElementRef, Node};
 
 /// An HTML tree.
@@ -91,6 +92,19 @@ impl Html {
         }
     }
 
+    /// Returns an iterator over elements matching a selector.
+    pub fn try_select<'a, 's>(
+        &'a self,
+        selector: &'s str,
+    ) -> Result<SelectOwned<'a>, cssparser::ParseError<'s, SelectorParseErrorKind<'s>>> {
+        let selector = Selector::parse(selector)?;
+
+        Ok(SelectOwned {
+            inner: self.tree.nodes(),
+            selector,
+        })
+    }
+
     /// Returns the root `<html>` element.
     pub fn root_element(&self) -> ElementRef {
         let root_node = self
@@ -125,6 +139,28 @@ impl<'a, 'b> Iterator for Select<'a, 'b> {
     }
 }
 
+/// Iterator over elements matching a owned selector.
+#[derive(Debug)]
+pub struct SelectOwned<'a> {
+    inner: Nodes<'a, Node>,
+    selector: Selector,
+}
+
+impl<'a> Iterator for SelectOwned<'a> {
+    type Item = ElementRef<'a>;
+
+    fn next(&mut self) -> Option<ElementRef<'a>> {
+        for node in self.inner.by_ref() {
+            if let Some(element) = ElementRef::wrap(node) {
+                if element.parent().is_some() && self.selector.matches(&element) {
+                    return Some(element);
+                }
+            }
+        }
+        None
+    }
+}
+
 mod tree_sink;
 
 #[cfg(test)]
diff --git a/src/selector.rs b/src/selector.rs
index 354cfca7..f8a6d90b 100644
--- a/src/selector.rs
+++ b/src/selector.rs
@@ -23,9 +23,9 @@ pub struct Selector {
 impl Selector {
     /// Parses a CSS selector group.
 
-    pub fn parse<'t, 'i>(
-        selectors: &'i str,
-    ) -> Result<Self, cssparser::ParseError<'i, SelectorParseErrorKind<'i>>> {
+    pub fn parse(
+        selectors: &str,
+    ) -> Result<Self, cssparser::ParseError<'_, SelectorParseErrorKind<'_>>> {
         let mut parser_input = cssparser::ParserInput::new(selectors);
         let mut parser = cssparser::Parser::new(&mut parser_input);
         parser::SelectorList::parse(&Parser, &mut parser).map(|list| Selector { selectors: list.0 })