Merge pull request #75 from AY1920S2-CS2103T-W12-4/main-kevin

Add Recipe model and Name, Ingredients & Instructions fields

Author: kevinswk94

src/main/java/seedu/address/model/recipe/Ingredients.java

@@ -0,0 +1,57 @@
+package seedu.address.model.recipe;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.commons.util.AppUtil.checkArgument;
+
+/**
+ * Represents a Recipe's ingredients in the recipe book.
+ * Guarantees: immutable; is valid as declared in {@link #isValidIngredients(String)}
+ */
+public class Ingredients {
+
+    public static final String MESSAGE_CONSTRAINTS = "Ingredients can take any values, and it should not be blank";
+
+    /*
+     * The first character of the ingredients must not be a whitespace,
+     * otherwise " " (a blank string) becomes a valid input.
+     */
+    public static final String VALIDATION_REGEX = "[^\\s].*";
+
+    public final String value;
+
+    /**
+     * Constructs an {@code Ingredients}.
+     *
+     * @param ingredients A valid ingredient string.
+     */
+    public Ingredients(String ingredients) {
+        requireNonNull(ingredients);
+        checkArgument(isValidIngredients(ingredients), MESSAGE_CONSTRAINTS);
+        value = ingredients;
+    }
+
+    /**
+     * Returns true if a given string is a valid email.
+     */
+    public static boolean isValidIngredients(String test) {
+        return test.matches(VALIDATION_REGEX);
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof Ingredients // instanceof handles nulls
+                    && value.equals(((Ingredients) other).value)); // state check
+    }
+
+    @Override
+    public int hashCode() {
+        return value.hashCode();
+    }
+
+}

src/main/java/seedu/address/model/recipe/Instructions.java

@@ -0,0 +1,57 @@
+package seedu.address.model.recipe;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.commons.util.AppUtil.checkArgument;
+
+/**
+ * Represents a Recipe's instructions in the recipe book.
+ * Guarantees: immutable; is valid as declared in {@link #isValidInstructions(String)}
+ */
+public class Instructions {
+
+    public static final String MESSAGE_CONSTRAINTS = "Instructions can take any values, and it should not be blank";
+
+    /*
+     * The first character of the instructions must not be a whitespace,
+     * otherwise " " (a blank string) becomes a valid input.
+     */
+    public static final String VALIDATION_REGEX = "[^\\s].*";
+
+    public final String value;
+
+    /**
+     * Constructs an {@code Instructions}.
+     *
+     * @param instructions A valid instruction string.
+     */
+    public Instructions(String instructions) {
+        requireNonNull(instructions);
+        checkArgument(isValidInstructions(instructions), MESSAGE_CONSTRAINTS);
+        value = instructions;
+    }
+
+    /**
+     * Returns true if a given string is a valid instruction.
+     */
+    public static boolean isValidInstructions(String test) {
+        return test.matches(VALIDATION_REGEX);
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof Instructions // instanceof handles nulls
+                    && value.equals(((Instructions) other).value)); // state check
+    }
+
+    @Override
+    public int hashCode() {
+        return value.hashCode();
+    }
+
+}

src/main/java/seedu/address/model/recipe/Name.java

@@ -4,7 +4,7 @@
 import static seedu.address.commons.util.AppUtil.checkArgument;
 
 /**
- * Represents a Recipe's name in the address book.
+ * Represents a Recipe's name in the recipe book.
  * Guarantees: immutable; is valid as declared in {@link #isValidName(String)}
  */
 public class Name {
@@ -13,12 +13,12 @@ public class Name {
             "Names should only contain alphanumeric characters and spaces, and it should not be blank";
 
     /*
-     * The first character of the address must not be a whitespace,
+     * The first character of the name must not be a whitespace,
      * otherwise " " (a blank string) becomes a valid input.
      */
     public static final String VALIDATION_REGEX = "[\\p{Alnum}][\\p{Alnum} ]*";
 
-    public final String fullName;
+    public final String name;
 
     /**
      * Constructs a {@code Name}.
@@ -28,7 +28,7 @@ public class Name {
     public Name(String name) {
         requireNonNull(name);
         checkArgument(isValidName(name), MESSAGE_CONSTRAINTS);
-        fullName = name;
+        this.name = name;
     }
 
     /**
@@ -41,19 +41,19 @@ public static boolean isValidName(String test) {
 
     @Override
     public String toString() {
-        return fullName;
+        return name;
     }
 
     @Override
     public boolean equals(Object other) {
         return other == this // short circuit if same object
                 || (other instanceof Name // instanceof handles nulls
-                && fullName.equals(((Name) other).fullName)); // state check
+                    && name.equals(((Name) other).name)); // state check
     }
 
     @Override
     public int hashCode() {
-        return fullName.hashCode();
+        return name.hashCode();
     }
 
 }

src/main/java/seedu/address/model/recipe/Recipe.java

@@ -2,81 +2,55 @@
 
 import static seedu.address.commons.util.CollectionUtil.requireAllNonNull;
 
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.Objects;
-import java.util.Set;
-
-import seedu.address.model.tag.Tag;
 
 /**
- * Represents a Recipe in the address book.
+ * Represents a Recipe in the recipe book.
  * Guarantees: details are present and not null, field values are validated, immutable.
  */
 public class Recipe {
-
     // Identity fields
     private final Name name;
-    private final Phone phone;
-    private final Email email;
 
     // Data fields
-    private final Address address;
-    private final Set<Tag> tags = new HashSet<>();
+    private final Ingredients ingredients;
+    private final Instructions instructions;
 
-    /**
-     * Every field must be present and not null.
-     */
-    public Recipe(Name name, Phone phone, Email email, Address address, Set<Tag> tags) {
-        requireAllNonNull(name, phone, email, address, tags);
+
+    public Recipe(Name name, Ingredients ingredients, Instructions instructions) {
+        requireAllNonNull(name, ingredients, instructions);
         this.name = name;
-        this.phone = phone;
-        this.email = email;
-        this.address = address;
-        this.tags.addAll(tags);
+        this.ingredients = ingredients;
+        this.instructions = instructions;
     }
 
     public Name getName() {
         return name;
     }
 
-    public Phone getPhone() {
-        return phone;
-    }
-
-    public Email getEmail() {
-        return email;
-    }
-
-    public Address getAddress() {
-        return address;
+    public Ingredients getIngredients() {
+        return ingredients;
     }
 
-    /**
-     * Returns an immutable tag set, which throws {@code UnsupportedOperationException}
-     * if modification is attempted.
-     */
-    public Set<Tag> getTags() {
-        return Collections.unmodifiableSet(tags);
+    public Instructions getInstructions() {
+        return instructions;
     }
 
     /**
-     * Returns true if both persons of the same name have at least one other identity field that is the same.
-     * This defines a weaker notion of equality between two persons.
+     * Returns true if both recipes have the same name.
      */
-    public boolean isSamePerson(Recipe otherRecipe) {
+    public boolean isSameRecipe(Recipe otherRecipe) {
         if (otherRecipe == this) {
             return true;
         }
 
         return otherRecipe != null
-                && otherRecipe.getName().equals(getName())
-                && (otherRecipe.getPhone().equals(getPhone()) || otherRecipe.getEmail().equals(getEmail()));
+               && otherRecipe.getName().equals(getName());
     }
 
     /**
-     * Returns true if both persons have the same identity and data fields.
-     * This defines a stronger notion of equality between two persons.
+     * Returns true if both recipes have the same identity and data fields.
+     * This defines a stronger notion of equality between two recipes.
      */
     @Override
     public boolean equals(Object other) {
@@ -90,31 +64,24 @@ public boolean equals(Object other) {
 
         Recipe otherRecipe = (Recipe) other;
         return otherRecipe.getName().equals(getName())
-                && otherRecipe.getPhone().equals(getPhone())
-                && otherRecipe.getEmail().equals(getEmail())
-                && otherRecipe.getAddress().equals(getAddress())
-                && otherRecipe.getTags().equals(getTags());
+               && otherRecipe.getIngredients().equals(getIngredients())
+               && otherRecipe.getInstructions().equals(getInstructions());
     }
 
     @Override
     public int hashCode() {
         // use this method for custom fields hashing instead of implementing your own
-        return Objects.hash(name, phone, email, address, tags);
+        return Objects.hash(name, ingredients, instructions);
     }
 
     @Override
     public String toString() {
         final StringBuilder builder = new StringBuilder();
         builder.append(getName())
-                .append(" Phone: ")
-                .append(getPhone())
-                .append(" Email: ")
-                .append(getEmail())
-                .append(" Address: ")
-                .append(getAddress())
-                .append(" Tags: ");
-        getTags().forEach(builder::append);
+                .append(" Ingredients: ")
+                .append(getIngredients())
+                .append(" Instructions: ")
+                .append(getInstructions());
         return builder.toString();
     }
-
 }

src/main/java/seedu/address/model/recipe/UniqueRecipeList.java

@@ -12,15 +12,15 @@
 import seedu.address.model.recipe.exceptions.RecipeNotFoundException;
 
 /**
- * A list of persons that enforces uniqueness between its elements and does not allow nulls.
- * A recipe is considered unique by comparing using {@code Recipe#isSamePerson(Recipe)}. As such, adding and updating of
- * persons uses Recipe#isSamePerson(Recipe) for equality so as to ensure that the recipe being added or updated is
+ * A list of recipes that enforces uniqueness between its elements and does not allow nulls.
+ * A recipe is considered unique by comparing using {@code Recipe#isSameRecipe(Recipe)}. As such, adding and updating of
+ * recipes uses Recipe#isSameRecipe(Recipe) for equality so as to ensure that the recipe being added or updated is
  * unique in terms of identity in the UniqueRecipeList. However, the removal of a recipe uses Recipe#equals(Object) so
  * as to ensure that the recipe with exactly the same fields will be removed.
  *
  * Supports a minimal set of list operations.
  *
- * @see Recipe#isSamePerson(Recipe)
+ * @see Recipe#isSameRecipe(Recipe)
  */
 public class UniqueRecipeList implements Iterable<Recipe> {
 
@@ -33,7 +33,7 @@ public class UniqueRecipeList implements Iterable<Recipe> {
      */
     public boolean contains(Recipe toCheck) {
         requireNonNull(toCheck);
-        return internalList.stream().anyMatch(toCheck::isSamePerson);
+        return internalList.stream().anyMatch(toCheck::isSameRecipe);
     }
 
     /**
@@ -53,15 +53,15 @@ public void add(Recipe toAdd) {
      * {@code target} must exist in the list.
      * The recipe identity of {@code editedRecipe} must not be the same as another existing recipe in the list.
      */
-    public void setPerson(Recipe target, Recipe editedRecipe) {
+    public void setRecipe(Recipe target, Recipe editedRecipe) {
         requireAllNonNull(target, editedRecipe);
 
         int index = internalList.indexOf(target);
         if (index == -1) {
             throw new RecipeNotFoundException();
         }
 
-        if (!target.isSamePerson(editedRecipe) && contains(editedRecipe)) {
+        if (!target.isSameRecipe(editedRecipe) && contains(editedRecipe)) {
             throw new DuplicateRecipeException();
         }
 
@@ -79,7 +79,7 @@ public void remove(Recipe toRemove) {
         }
     }
 
-    public void setPersons(UniqueRecipeList replacement) {
+    public void setRecipes(UniqueRecipeList replacement) {
         requireNonNull(replacement);
         internalList.setAll(replacement.internalList);
     }
@@ -88,9 +88,9 @@ public void setPersons(UniqueRecipeList replacement) {
      * Replaces the contents of this list with {@code recipes}.
      * {@code recipes} must not contain duplicate recipes.
      */
-    public void setPersons(List<Recipe> recipes) {
+    public void setRecipes(List<Recipe> recipes) {
         requireAllNonNull(recipes);
-        if (!personsAreUnique(recipes)) {
+        if (!recipesAreUnique(recipes)) {
             throw new DuplicateRecipeException();
         }
 
@@ -113,7 +113,7 @@ public Iterator<Recipe> iterator() {
     public boolean equals(Object other) {
         return other == this // short circuit if same object
                 || (other instanceof UniqueRecipeList // instanceof handles nulls
-                        && internalList.equals(((UniqueRecipeList) other).internalList));
+                    && internalList.equals(((UniqueRecipeList) other).internalList));
     }
 
     @Override
@@ -124,10 +124,10 @@ public int hashCode() {
     /**
      * Returns true if {@code recipes} contains only unique recipes.
      */
-    private boolean personsAreUnique(List<Recipe> recipes) {
+    private boolean recipesAreUnique(List<Recipe> recipes) {
         for (int i = 0; i < recipes.size() - 1; i++) {
             for (int j = i + 1; j < recipes.size(); j++) {
-                if (recipes.get(i).isSamePerson(recipes.get(j))) {
+                if (recipes.get(i).isSameRecipe(recipes.get(j))) {
                     return false;
                 }
             }