Add support for Schema.org/Recipe

java/org/chromium/distiller/SchemaOrgParser.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.distiller;
 
 import org.chromium.distiller.proto.DomDistillerProtos.TimingInfo;
 
 import com.google.gwt.dom.client.Element;
 import com.google.gwt.dom.client.Node;
@@ skipping 20 matching lines @@
  * The value of a Schema.Org property can be a Schema.Org type, i.e. embedded.  E.g., the author or
  * publisher of article or publisher of image could be a Schema.Org Person or Organization type;
  * in fact, this is the reason we support Person and Organization types.
  */
 public class SchemaOrgParser {
     static final String NAME_PROP = "name";
     static final String URL_PROP = "url";
     static final String DESCRIPTION_PROP = "description";
     static final String IMAGE_PROP = "image";
     static final String HEADLINE_PROP = "headline";
+    static final String MAIN_ENTITY_OF_PAGE = "mainEntityOfPage";
+    static final String MAIN_ENTITY = "mainEntity";
     static final String PUBLISHER_PROP = "publisher";
     static final String COPYRIGHT_HOLDER_PROP = "copyrightHolder";
     static final String COPYRIGHT_YEAR_PROP = "copyrightYear";
     static final String CONTENT_URL_PROP = "contentUrl";
     static final String ENCODING_FORMAT_PROP = "encodingFormat";
     static final String CAPTION_PROP = "caption";
     static final String REPRESENTATIVE_PROP = "representativeOfPage";
     static final String WIDTH_PROP = "width";
     static final String HEIGHT_PROP = "height";
     static final String DATE_PUBLISHED_PROP = "datePublished";
     static final String DATE_MODIFIED_PROP = "dateModified";
     static final String AUTHOR_PROP = "author";
     static final String CREATOR_PROP = "creator";
     static final String SECTION_PROP = "articleSection";
     static final String ASSOCIATED_MEDIA_PROP = "associatedMedia";
     static final String ENCODING_PROP = "encoding";
     static final String FAMILY_NAME_PROP = "familyName";
     static final String GIVEN_NAME_PROP = "givenName";
     static final String LEGAL_NAME_PROP = "legalName";
     static final String AUTHOR_REL = "author";
+    static final String COOK_TIME = "cookTime";
+    static final String COOKING_METHOD = "cookingMethod";
+    static final String NUTRITION = "nutrition";
+    static final String PREP_TIME = "prepTime";
+    static final String RECIPE_CATEGORY = "recipeCategory";
+    static final String RECIPE_CUISINE = "recipeCuisine";
+    static final String RECIPE_INGREDIENT = "recipeIngredient";
+    static final String INGREDIENTS = "ingredients";
+    static final String RECIPE_INSTRUCTIONS = "recipeInstructions";
+    static final String RECIPE_YIELD = "recipeYield";
+    static final String TOTAL_TIME = "totalTime";
 
     enum Type {  // All these types are extended from Thing, directly or indirectly.
         IMAGE,
         ARTICLE,
         PERSON,
         ORGANIZATION,
+        RECIPE,
         UNSUPPORTED,
     }
 
-    static class ThingItem {
+    static abstract class ThingItem {
         private final Type mType;
-        private final Map<String, String> mStringProperties;
+        private final Map<String, List<String>> mStringProperties;
         private final Map<String, ThingItem> mItemProperties;
 
         ThingItem(Type type) {
             mType = type;
-            mStringProperties = new HashMap<String, String>();
+            mStringProperties = new HashMap<String, List<String>>();
             mItemProperties = new HashMap<String, ThingItem>();
 
            addStringPropertyName(NAME_PROP);
            addStringPropertyName(URL_PROP);
            addStringPropertyName(DESCRIPTION_PROP);
            addStringPropertyName(IMAGE_PROP);
+           addStringPropertyName(MAIN_ENTITY_OF_PAGE);
+           addStringPropertyName(MAIN_ENTITY);
         }
 
         final void addStringPropertyName(String name) {
-            mStringProperties.put(name, "");
+            if (mStringProperties.get(name) == null) {
+                mStringProperties.put(name, new ArrayList<String>());
+            }
         }
 
         final void addItemPropertyName(String name) {
             mItemProperties.put(name, null);
         }
 
         final String getStringProperty(String name) {
-            return !mStringProperties.containsKey(name) ? "" : mStringProperties.get(name);
+            return !mStringProperties.containsKey(name) ? "" : DomUtil.join(mStringProperties.get(name).toArray(), ", ");

[wychen, 2016/03/14 22:58:42]

Possible l10n issues here. Not all languages use ",", but this is less an issue
than other l10n issues.

+        }
+
+        final List<String> getProperty(String name) {
+            return mStringProperties.get(name);
         }
 
         final ThingItem getItemProperty(String name) {
             return !mItemProperties.containsKey(name) ? null : mItemProperties.get(name);
         }
 
         final Type getType() { return mType; }
 
         final boolean isSupported() { return mType != Type.UNSUPPORTED; }
 
-        // Store |value| for property with |name|, unless the property already has a non-empty
-        // value, in which case |value| will be ignored.  This means we only keep the first value.
+        // Store |value| for property with |name|. Values are added
+        // into a list indexed by |name|. Using a list of values is
+        // necessary in order to support duplicated properties like
+        // 'recipeIngredient' which appears frequently more than once
+        // in a Recipe.
         final void putStringValue(String name, String value) {
-            if (mStringProperties.containsKey(name) && mStringProperties.get(name).isEmpty()) {
-                mStringProperties.put(name, value);
+            if (mStringProperties.containsKey(name)) {
+                mStringProperties.get(name).add(value);
             }
         }
 
         // Store |value| for property with |name|, unless the property already has a non-null value,
         // in which case, |value| will be ignored.  This means we only keep the first value.
         final void putItemValue(String name, ThingItem value) {
             if (mItemProperties.containsKey(name)) mItemProperties.put(name, value);
         }
+
+        /**
+         * Derived items should provide their own implementations.
+         *
+         * @return HTML output.
+         */
+        public abstract String generateOutput();
     }
 
     private final List<ThingItem> mItemScopes = new ArrayList<ThingItem>();
     private final Map<Element, ThingItem> mItemElement = new HashMap<Element, ThingItem>();
     private String mAuthorFromRel = "";
     private static final Map<String, Type> sTypeUrls;
 
     static {
         sTypeUrls = new HashMap<String, Type>();
         sTypeUrls.put("http://schema.org/ImageObject", Type.IMAGE);
         sTypeUrls.put("http://schema.org/Article", Type.ARTICLE);
         sTypeUrls.put("http://schema.org/BlogPosting", Type.ARTICLE);
         sTypeUrls.put("http://schema.org/NewsArticle", Type.ARTICLE);
         sTypeUrls.put("http://schema.org/ScholarlyArticle", Type.ARTICLE);
         sTypeUrls.put("http://schema.org/TechArticle", Type.ARTICLE);
         sTypeUrls.put("http://schema.org/Person", Type.PERSON);
         sTypeUrls.put("http://schema.org/Organization", Type.ORGANIZATION);
         sTypeUrls.put("http://schema.org/Corporation", Type.ORGANIZATION);
         sTypeUrls.put("http://schema.org/EducationalOrganization", Type.ORGANIZATION);
         sTypeUrls.put("http://schema.org/GovernmentOrganization", Type.ORGANIZATION);
         sTypeUrls.put("http://schema.org/NGO", Type.ORGANIZATION);
+        sTypeUrls.put("http://schema.org/Recipe", Type.RECIPE);
     }
 
     private final TimingInfo mTimingInfo;
 
     /**
      * The object that extracts and verifies Schema.org markup tags from |root|.
      */
     public SchemaOrgParser(Element root, TimingInfo timingInfo) {
         // TODO(kuan): Parsing all tags is pretty expensive, should we do so only lazily?
         // If parse lazily, all get* methods will need to check for parsed state and, if necessary,
@@ skipping 17 matching lines @@
 
     final List<ImageItem> getImageItems() {
         List<ImageItem> images = new ArrayList<ImageItem>();
         for (int i = 0; i < mItemScopes.size(); i++) {
             ThingItem item = mItemScopes.get(i);
             if (item.mType == Type.IMAGE) images.add((ImageItem) item);
         }
         return images;
     }
 
+    /**
+     * Get the main entity of a page if any.
+     *
+     * Main entity of a page is retrieved by the mainEntityOfPage
+     * or by its inverse property mainEntity.
+     *
+     * @return ThingItem which is the main entity of this page.
+     */
+    final ThingItem getMainEntity() {
+        for (ThingItem mItemScope : mItemScopes) {
+            if(!mItemScope.getStringProperty(MAIN_ENTITY).isEmpty() ||
+                    !mItemScope.getStringProperty(MAIN_ENTITY_OF_PAGE).isEmpty()) {
+                return mItemScope;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Look for all top level entities on the page. As we are
+     * representing the graph hierarchy by having a set of
+     * children in every node, the top level entities (roots) are those
+     * nodes that do not appear as children in any other node.
+     *
+     * @return List<ThingItem> which are considered top level entities.
+     */
+    final List<ThingItem> getTopLevelEntities() {
+        List<ThingItem> candidates = new ArrayList<>(mItemScopes);
+        for (ThingItem mItemScope : mItemScopes) {
+            for (Map.Entry<String, ThingItem> entry :
+                    mItemScope.mItemProperties.entrySet()) {
+                candidates.remove(entry.getValue());
+            }
+        }
+        return candidates;
+    }
+
     final String getAuthorFromRel() { return mAuthorFromRel; }
 
     private void parse(Element root) {
         NodeList<Element> allProp = DomUtil.querySelectorAll(root, "[ITEMPROP],[ITEMSCOPE]");
 
         // Root node (html) is not included in the result of querySelectorAll, so need to
         // handle it explicitly here.
         parseElement(root, null);
 
         for (int i = 0; i < allProp.getLength(); i++) {
@@ skipping 84 matching lines @@
                 break;
             case ARTICLE:
                 newItem = new ArticleItem();
                 break;
             case PERSON:
                 newItem = new PersonItem();
                 break;
             case ORGANIZATION:
                 newItem = new OrganizationItem();
                 break;
+            case RECIPE:
+                newItem = new RecipeItem();
+                break;
             case UNSUPPORTED:
                 newItem = new UnsupportedItem();
                 break;
             default:
                 return null;
         }
         return newItem;
     }
 
     static class ImageItem extends ThingItem {
@@ skipping 15 matching lines @@
         final MarkupParser.Image getImage() {
             MarkupParser.Image image = new MarkupParser.Image();
             image.url = getStringProperty(CONTENT_URL_PROP);
             if (image.url.isEmpty()) image.url = getStringProperty(URL_PROP);
             image.type = getStringProperty(ENCODING_FORMAT_PROP);
             image.caption = getStringProperty(CAPTION_PROP);
             image.width = JavaScript.parseInt(getStringProperty(WIDTH_PROP), 10);
             image.height = JavaScript.parseInt(getStringProperty(HEIGHT_PROP), 10);
             return image;
         }
+
+        @Override
+        public String generateOutput() {
+            return "";
+        }
     }
 
     static class ArticleItem extends ThingItem {
         ArticleItem() {
             super(Type.ARTICLE);
 
             addStringPropertyName(HEADLINE_PROP);
             addStringPropertyName(PUBLISHER_PROP);
             addStringPropertyName(COPYRIGHT_HOLDER_PROP);
             addStringPropertyName(COPYRIGHT_YEAR_PROP);
@@ skipping 56 matching lines @@
         }
 
         final MarkupParser.Image getImage() {
             // Use value of "image" property to create a MarkupParser.Image.
             String imageUrl = getStringProperty(IMAGE_PROP);
             if (imageUrl.isEmpty()) return null;
             MarkupParser.Image image = new MarkupParser.Image();
             image.url = imageUrl;
             return image;
         }
+
+        @Override
+        public String generateOutput() {
+            return "";
+        }
     }
 
-    private static class PersonItem extends ThingItem {
+    static class PersonItem extends ThingItem {
         PersonItem() {
             super(Type.PERSON);
 
             addStringPropertyName(FAMILY_NAME_PROP);
             addStringPropertyName(GIVEN_NAME_PROP);
         }
 
         String getName() {
             // Returns either the value of NAME_PROP, or concatenated values of GIVEN_NAME_PROP and
             // FAMILY_NAME_PROP delimited by a whitespace.
             String name = getStringProperty(NAME_PROP);
             return !name.isEmpty() ? name :
                     concat(getStringProperty(GIVEN_NAME_PROP), getStringProperty(FAMILY_NAME_PROP));
         }
+
+        Person getPerson() {
+            Person person = new Person();
+            person.name = getName();
+            return person;
+        }
+
+        class Person {
+            String name;
+        }
+
+        @Override
+        public String generateOutput() {
+            return MarkupGenerator.generateMarkup(getPerson());
+        }
     }
 
     private static class OrganizationItem extends ThingItem {
         OrganizationItem() {
             super(Type.ORGANIZATION);
 
             addStringPropertyName(LEGAL_NAME_PROP);
         }
 
         String getName() {
             // Returns either the value of NAME_PROP or LEGAL_NAME_PROP.
             String name = getStringProperty(NAME_PROP);
             return !name.isEmpty() ? name : getStringProperty(LEGAL_NAME_PROP);
         }
+
+        @Override
+        public String generateOutput() {
+            return "";
+        }
+    }
+
+    static class RecipeItem extends ThingItem {
+
+        RecipeItem() {
+            super(Type.RECIPE);
+
+            addStringPropertyName(AUTHOR_PROP);
+            addStringPropertyName(CREATOR_PROP);
+            addStringPropertyName(COOK_TIME);
+            addStringPropertyName(COOKING_METHOD);
+            addStringPropertyName(NUTRITION);
+            addStringPropertyName(PREP_TIME);
+            addStringPropertyName(RECIPE_CATEGORY);
+            addStringPropertyName(RECIPE_CUISINE);
+            addStringPropertyName(RECIPE_INGREDIENT);
+            addStringPropertyName(INGREDIENTS);
+            addStringPropertyName(RECIPE_INSTRUCTIONS);
+            addStringPropertyName(RECIPE_YIELD);
+            addStringPropertyName(TOTAL_TIME);
+
+            addItemPropertyName(AUTHOR_PROP);
+            addItemPropertyName(CREATOR_PROP);
+        }
+
+        final Recipe getRecipe() {
+            Recipe recipe = new Recipe();
+            recipe.title = getStringProperty(NAME_PROP);
+            recipe.imageSrc = getStringProperty(IMAGE_PROP);
+            recipe.cookTime = DomUtil.formatDuration(
+                    getStringProperty(COOK_TIME));
+            recipe.author = retrieveProperty(AUTHOR_PROP);
+            recipe.creator = retrieveProperty(CREATOR_PROP);
+            recipe.description = getStringProperty(DESCRIPTION_PROP);
+            recipe.recipeYield = getStringProperty(RECIPE_YIELD);
+            recipe.prepTime = DomUtil.formatDuration(
+                    getStringProperty(PREP_TIME));
+            recipe.recipeIngredient = getProperty(RECIPE_INGREDIENT).isEmpty() ?
+                    getProperty(INGREDIENTS) : getProperty(RECIPE_INGREDIENT);
+            recipe.recipeInstructions = getProperty(RECIPE_INSTRUCTIONS);
+            recipe.totalTime = DomUtil.formatDuration(
+                    getStringProperty(TOTAL_TIME));
+            return recipe;
+        }
+
+        String retrieveProperty(String property) {
+            String value = getStringProperty(property);
+            if(value.isEmpty()) {
+                ThingItem itemProperty = getItemProperty(property);
+                if (itemProperty != null) {
+                    value = itemProperty.generateOutput();
+                }
+            }
+            return value;
+        }
+
+        @Override
+        public String generateOutput() {
+            return MarkupGenerator.generateMarkup(getRecipe());
+        }
+
+        class Recipe {
+            String title;
+            String imageSrc;
+            String author;
+            String creator;
+            String description;
+            String recipeYield;
+            String prepTime;
+            String cookTime;
+            String totalTime;
+            List<String> recipeIngredient;
+            List<String> recipeInstructions;
+        }
     }
 
     private static class UnsupportedItem extends ThingItem {
         UnsupportedItem() {
             super(Type.UNSUPPORTED);
         }
+
+        @Override
+        public String generateOutput() {
+            return "";
+        }
     }
 
     private static boolean isItemScope(Element e) {
         return e.hasAttribute("ITEMSCOPE") && e.hasAttribute("ITEMTYPE");
     }
 
     private static String[] getItemProp(Element e) {
         // "itemprop" attribute is case-sensitive, and can have multiple properties.
         String itemprop = e.getAttribute("ITEMPROP");
         if (itemprop.isEmpty()) return new String[0];
@@ skipping 52 matching lines @@
         return author;
     }
 
     private static String concat(String first, String second) {
         String concat = first;
         if (!concat.isEmpty() && !second.isEmpty()) concat += " ";
         concat += second;
         return concat;
     }
 }