servo: Merge #6625 - Implement Range#cloneContents (from dzbarsky:range-clonecontents); r=Ms2ger

Source-Repo: https://github.com/servo/servo
Source-Revision: a0cf597946446c427c54da363fe989ff68db4270

UltraBlame original commit: 8b4c5111a66d6d0fa67b73323ab124215a3986a4

Author: marco-c

servo/components/script/dom/range.rs

@@ -2,22 +2,25 @@
 
 
 
+use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeConstants;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
 use dom::bindings::codegen::Bindings::RangeBinding::{self, RangeConstants};
 use dom::bindings::codegen::Bindings::RangeBinding::RangeMethods;
 use dom::bindings::codegen::Bindings::TextBinding::TextMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{NodeCast, TextCast};
+use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeCast, TextCast};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::error::Error::HierarchyRequest;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root, RootedReference};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::characterdata::CharacterDataTypeId;
 use dom::document::{Document, DocumentHelpers};
+use dom::documentfragment::DocumentFragment;
 use dom::node::{Node, NodeHelpers, NodeTypeId};
+
 use std::cell::RefCell;
 use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
 use std::rc::Rc;
@@ -60,6 +63,25 @@ impl Range {
         let document = global.as_window().Document();
         Ok(Range::new_with_doc(document.r()))
     }
+
+    
+    fn contains(&self, node: &Node) -> bool {
+        let inner = self.inner.borrow();
+        let start = &inner.start;
+        let end = &inner.end;
+        match (bp_position(node, 0, start.node().r(), start.offset()),
+               bp_position(node, node.len(), end.node().r(), end.offset())) {
+            (Some(Ordering::Greater), Some(Ordering::Less)) => true,
+            _ => false
+        }
+    }
+
+    
+    fn partially_contains(&self, node: &Node) -> bool {
+        let inner = self.inner.borrow();
+        inner.start.node().inclusive_ancestors().any(|n| n.r() == node) !=
+            inner.end.node().inclusive_ancestors().any(|n| n.r() == node)
+    }
 }
 
 pub trait RangeHelpers<'a> {
@@ -288,6 +310,145 @@ impl<'a> RangeMethods for &'a Range {
     }
 
 
+    
+    fn CloneContents(self) -> Fallible<Root<DocumentFragment>> {
+        let inner = self.inner.borrow();
+        let start = &inner.start;
+        let end = &inner.end;
+
+        
+        let start_node = start.node();
+        let start_offset = start.offset();
+        let end_node = end.node();
+        let end_offset = end.offset();
+
+        
+        let fragment = DocumentFragment::new(start_node.owner_doc().r());
+
+        
+        if start == end {
+            return Ok(fragment);
+        }
+
+        if end_node == start_node {
+            if let Some(text) = CharacterDataCast::to_ref(start_node.r()) {
+                
+                let clone = start_node.CloneNode(true);
+                
+                let text = text.SubstringData(start_offset, end_offset - start_offset);
+                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                
+                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                
+                return Ok(fragment);
+            }
+        }
+
+        
+        let common_ancestor = self.CommonAncestorContainer();
+
+        let first_contained_child =
+            if start_node.is_inclusive_ancestor_of(end_node.r()) {
+                
+                None
+            } else {
+                
+                common_ancestor.children()
+                               .find(|node| Range::partially_contains(self, node))
+            };
+
+        let last_contained_child =
+            if end_node.is_inclusive_ancestor_of(start_node.r()) {
+                
+                None
+            } else {
+                
+                common_ancestor.rev_children()
+                               .find(|node| Range::partially_contains(self, node))
+            };
+
+        
+        let contained_children =
+            common_ancestor.children().filter(|n| Range::contains(self, n));
+
+        
+        if common_ancestor.children()
+                          .filter(|n| Range::contains(self, n))
+                          .any(|n| n.is_doctype()) {
+            return Err(HierarchyRequest);
+        }
+
+        if let Some(child) = first_contained_child {
+            
+            if let Some(text) = CharacterDataCast::to_ref(child.r()) {
+                assert!(child == start_node);
+                
+                let clone = start_node.CloneNode(true); 
+                
+                let text = text.SubstringData(start_offset, start_node.len() - start_offset);
+                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                
+                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+            } else {
+                
+                let clone = child.CloneNode(false);
+                
+                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                
+                let subrange = Range::new(clone.owner_doc().r(),
+                                          start_node.r(),
+                                          start_offset,
+                                          child.r(),
+                                          child.len());
+                
+                let subfragment = try!(subrange.CloneContents());
+                
+                try!(clone.AppendChild(NodeCast::from_ref(subfragment.r())));
+            }
+        }
+
+        
+        for child in contained_children {
+            
+            let clone = child.CloneNode(true);
+            
+            try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+        }
+
+        if let Some(child) = last_contained_child {
+            
+            if let Some(text) = CharacterDataCast::to_ref(child.r()) {
+                assert!(child == end_node);
+                
+                let clone = end_node.CloneNode(true); 
+                
+                let text = text.SubstringData(0, end_offset);
+                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                
+                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+            } else {
+                
+                let clone = child.CloneNode(false);
+                
+                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                
+                let subrange = Range::new(clone.owner_doc().r(),
+                                          child.r(),
+                                          0,
+                                          end_node.r(),
+                                          end_offset);
+                
+                let subfragment = try!(subrange.CloneContents());
+                
+                try!(clone.AppendChild(NodeCast::from_ref(subfragment.r())));
+            }
+        }
+
+        
+        Ok(fragment)
+    }
+
+    
     fn Detach(self) {
 
     }

servo/components/script/dom/webidls/Range.webidl

@@ -46,8 +46,8 @@ interface Range {
   // void deleteContents();
   // [NewObject, Throws]
   // DocumentFragment extractContents();
-  // [NewObject, Throws]
-  // DocumentFragment cloneContents();
+  [NewObject, Throws]
+  DocumentFragment cloneContents();
   [Throws]
   void insertNode(Node node);
   // [Throws]