Merged vcard and json logic

components/script/Cargo.toml

@@ -82,6 +82,7 @@ script_plugins = {path = "../script_plugins"}
 script_traits = {path = "../script_traits"}
 selectors = { path = "../selectors" }
 serde = "1.0"
+serde_derive = "1.0"
 serde_json = "1.0"
 servo_allocator = {path = "../allocator"}
 servo_arc = {path = "../servo_arc"}

components/script/dom/document.rs

@@ -1710,9 +1710,15 @@ impl Document {
         // TODO: completely loaded.
 
         // Step 13.
-        let result = Microdata::parse(self);
-        let event = ScriptMsg::SendMicrodata(result);
-        self.send_to_constellation(event);
+        let htmlelement = self.get_html_element();
+        let result = Microdata::parse(self, htmlelement.unwrap().upcast::<Node>()); //Chirag
+        if !result.get("vcard").unwrap().is_empty() {
+            let event = ScriptMsg::SendMicrodata(result.get("vcard").unwrap().to_string());
+            self.send_to_constellation(event);
+        } else {
+            let event = ScriptMsg::SendMicrodata(result.get("json").unwrap().to_string());
+            self.send_to_constellation(event);
+        }
     }
 
     // https://html.spec.whatwg.org/multipage/#pending-parsing-blocking-script

components/script/dom/element.rs

@@ -923,6 +923,10 @@ impl Element {
         &self.local_name
     }
 
+    pub fn tag_name(&self) -> DOMString{
+        self.TagName()
+    }
+
     pub fn parsed_name(&self, mut name: DOMString) -> LocalName {
         if self.html_element_in_html_document() {
             name.make_ascii_lowercase();

components/script/lib.rs

@@ -85,6 +85,8 @@ extern crate script_layout_interface;
 extern crate script_traits;
 extern crate selectors;
 extern crate serde;
+#[macro_use]
+extern crate serde_derive;
 extern crate serde_json;
 extern crate servo_allocator;
 extern crate servo_arc;

components/script/microdata.rs

@@ -6,18 +6,39 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentBinding::Document
 use dom::bindings::codegen::Bindings::ElementBinding::ElementBinding::ElementMethods;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::root::DomRoot;
+use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::element::Element;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
+use dom::text::Text;
 use std::borrow::Cow;
 use std::collections::HashMap;
+use serde_json;
 
 pub struct Microdata {}
+#[derive(Serialize,Clone)]
+#[serde(untagged)]
+enum Data {
+    StrValue(String),
+    VecValue(Vec<Data>),
+    DataValue(Box<Data>),
+    HashValue(HashMap<String,Data>)
+}
 
 impl Microdata {
     //[Pref="dom.microdata.testing.enabled"]
-    pub fn parse(doc: &Document) -> String {
+    pub fn parse(doc: &Document, node : &Node) -> HashMap<String, String> {
+        //let dup_doc = Cow::Borrowed(doc);
+        let serialized_vcard = Self::parse_vcard(doc);
+        let serialized_json = Self::parse_json(node);
+        let mut serialized_data : HashMap<String, String> = HashMap::new();
+        serialized_data.insert("vcard".to_string(), serialized_vcard);
+        serialized_data.insert("json".to_string(), serialized_json);
+        return serialized_data;
+    }
+
+    pub fn parse_vcard(doc: &Document) -> String {
 
         let ele = doc.upcast::<Node>();
         let mut start_vcard = false;
@@ -131,4 +152,69 @@ impl Microdata {
         println!("{}", result);
         return result;
     }
+
+    pub fn parse_json(node: &Node) -> String {
+        let json_data : Data = Self::traverse(node).unwrap();
+        let json = serde_json::to_string(&json_data);
+        //println!("printing json from microdata {:?}", json);
+        return json.ok().unwrap();
+    }
+
+    fn get_attr_value(element: &Element, property: &str)-> Option<String> {
+        println!("{:?}",property);
+        // let mut atoms =  match property {
+        //   "itemprop" => element.get_tokenlist_attribute(&local_name!("itemprop"), ),
+        //   "itemtype" =>  element.get_tokenlist_attribute(&local_name!("itemtype"), ),
+        //   _ => {},
+        // };
+        // if !atoms.is_empty() {
+        //   let temp_key = atoms.remove(0);
+        //   return Some(String::from(temp_key.trim()).to_owned());
+        // }
+        // else {
+        //   return None;
+        // }
+        Some(String::from("itemprop"))
+    }
+
+    fn traverse( node: &Node)-> Option<Data> {
+        if !node.is::<Element>(){
+            if let Some(ref text) = node.downcast::<Text>(){
+                let mut content = String::new();
+                content.push_str(&text.upcast::<CharacterData>().data());
+                return Some(Data::StrValue(String::from(content)));
+            }
+            None
+        }
+        else {
+            let element = node.downcast::<Element>().unwrap();
+            let mut head_str = String::from("");
+            let mut parent_vec:Vec<Data> = Vec::new();
+            let item_type = Self::get_attr_value(element,"itemtype").unwrap();
+            // if element.has_attribute(&local_name!("itemscope")) && element.has_attribute(&local_name!("itemtype")) && !element.has_attribute(&local_name!("itemprop")) {
+            //     head_str = String::from("items");
+            //     let mut propMap:HashMap<String,Data> = HashMap::new();
+            //     //Data::HashValue(propMap)
+            //     let item_type = Self::get_attr_value(element,"item_type").unwrap();
+
+            // }
+            // else if element.has_attribute(&local_name!("itemprop")) && element.has_attribute(&local_name!("item_type")) {
+
+            //     head_str = Self::get_attr_value(element,"itemprop").unwrap();
+            //     let item_type = Self::get_attr_value(element,"item_type").unwrap();
+
+            // }
+            // else {
+            //     return None;
+            // }
+            let mut inner_map:HashMap<String,Data> = HashMap::new();
+            for child in node.children(){
+                if let Some(childData) = Self::traverse(child.upcast::<Node>()){
+                    parent_vec.push(childData);
+                }
+            }
+            inner_map.insert(head_str,Data::VecValue(parent_vec));
+            Some(Data::HashValue(inner_map))
+        }
+    }
 }