java8 compatibility

and several minor things

This closes issue #1

Author: Chaiavi

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>org.chaiware</groupId>
     <artifactId>TextToEmotion</artifactId>
-    <version>0.7</version>
+    <version>0.8</version>
     <name>TextToEmotion</name>
 
     <properties>

src/main/java/org/chaiware/app/TextToEmotion.java

@@ -5,10 +5,11 @@
 import org.chaiware.emotion.EmotionalState;
 import org.chaiware.emotion.Empathyscope;
 
+/** This class is the class you should use in order to parse your text for emotions, it contains static methods */
 public class TextToEmotion {
 
 	/** For internal use, in order to try the app and see that it is working while developing it */
-	public static void main(String[] args ) {
+	public static void main(String[] args ) throws Exception {
 		if (args.length < 1) {
 			System.out.println("Please send an argument with the string you want to sense for emotion");
 			System.exit(0);
@@ -19,13 +20,14 @@ public static void main(String[] args ) {
 	}
 
 	/** Use this method in order to analyze any text for emotions */
-	public static EmotionalState textToEmotion(String text) {
+	public static EmotionalState textToEmotion(String text) throws Exception {
 
 		EmotionalState sentenceState = new EmotionalState();
 		try {
 			sentenceState = Empathyscope.getInstance().feel(text);
 		} catch (IOException e) {
 			e.printStackTrace();
+			throw new Exception("TextToEmotion failed to start (probably due to failure of loading its internal files)");
 		}
 
 		return sentenceState;

src/main/java/org/chaiware/emotion/AffectWord.java

@@ -1,8 +1,10 @@
 package org.chaiware.emotion;
 
+import java.util.StringJoiner;
+
 /**
  * Represents one unit from the Lexicon: a word associated with
- * emotional meaning, and it's emotional weights and valence.
+ * emotional meaning, and its emotional weights and valence.
  * <p>
  * The Lexicon, which consists of several thousand words (with emoticons),
  * associates these attributes to a word:
@@ -152,12 +154,12 @@ public void flipValence() {
 	 * 
 	 * @return {@link AffectWord}, new duplicated object
 	 */
+	@Override
 	public AffectWord clone() {
 		AffectWord value = new AffectWord(word, generalWeight, happinessWeight,
-				sadnessWeight, angerWeight, fearWeight, disgustWeight,
-				surpriseWeight);
-		value.setStartsWithEmoticon(startsWithEmoticon);
+				sadnessWeight, angerWeight, fearWeight, disgustWeight, surpriseWeight);
 
+		value.setStartsWithEmoticon(startsWithEmoticon);
 		return value;
 	}
 
@@ -334,7 +336,7 @@ public void setGeneralValence(int generalValence) {
 	}
 
 	/**
-	 * Sets the boolean value which determines does a word have specific
+	 * Gets the boolean value which determines if a word has specific
 	 * emotional weight for emotion types defined by Ekman: happiness, sadness,
 	 * fear, anger, disgust, and surprise.
 	 * 
@@ -345,20 +347,24 @@ public boolean isZeroEkman() {
 		return getWeightSum() == 0;
 	}
 
-	/**
-	 * @return a string representation of the different weights of the emotions
-	 */
-	public String toString() {
-		return word + " " + generalWeight + " " + happinessWeight + " "
-				+ sadnessWeight + " " + angerWeight + " " + fearWeight + " "
-				+ disgustWeight + " " + surpriseWeight;
-	}
-
 	private double getValenceSum() {
 		return happinessWeight - sadnessWeight - angerWeight - fearWeight - disgustWeight;
 	}
 
 	private double getWeightSum() {
 		return happinessWeight + sadnessWeight + angerWeight + fearWeight + disgustWeight + surpriseWeight;
 	}
+
+  /**
+   * @return a string representation of the different weights of the emotions
+   */
+  @Override
+  public String toString() {
+    StringJoiner sj = new StringJoiner(" ");
+    sj.add(word).add(Double.toString(generalWeight)).add(Double.toString(happinessWeight));
+    sj.add(Double.toString(sadnessWeight)).add(Double.toString(angerWeight)).add(Double.toString(fearWeight));
+    sj.add(Double.toString(disgustWeight)).add(Double.toString(surpriseWeight));
+
+    return sj.toString();
+  }
 }

src/main/java/org/chaiware/emotion/Emotion.java

@@ -35,11 +35,12 @@ public Emotion(double weight, int type) {
 	/**
 	 * Compares weights of current object and the one from the argument.
 	 * 
-	 * @param arg0 {@link Emotion} which is to compared to the current one
+	 * @param emotion {@link Emotion} which is to compared to the current one
 	 * @return integer representing the result
 	 */
-	public int compareTo(Emotion arg0) {
-		int value = (int) (100 * (arg0.getWeight() - weight));
+	@Override
+	public int compareTo(Emotion emotion) {
+		int value = (int) (100 * (emotion.getWeight() - weight));
 		// make sure each emotion will be considered, even if it is weight-even with another one
 		if (value == 0)
 			return 1;

src/main/java/org/chaiware/emotion/EmotionalState.java

@@ -1,9 +1,6 @@
 package org.chaiware.emotion;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.SortedSet;
-import java.util.TreeSet;
+import java.util.*;
 
 
 /**
@@ -33,9 +30,7 @@ public class EmotionalState {
 	private EmotionalState previous;
 	private SortedSet<Emotion> emotions;
 
-	/**
-	 * Empty class constructor
-	 */
+
 	public EmotionalState() {
 		this("");
 	}
@@ -57,7 +52,7 @@ public EmotionalState(String text) {
 	 * valence, and all of the emotional weights (in a form of a SortedSet).
 	 * 
 	 * @param text {@link String} representing the text
-	 * @param emotions {@link SortedSet} containing all of the specific Ekman emotinal
+	 * @param emotions {@link SortedSet} containing all of the specific Ekman emotional
 	 *            weights, defined by the {@link Emotion} class
 	 * @param generalWeight double representing the general emotional weight
 	 * @param valence int representing the emotinal valence
@@ -87,7 +82,7 @@ public Emotion getStrongestEmotion() {
 	 * @return list of emotions ({@link Emotion} instances) with the highest weight
 	 */
 	public List<Emotion> getFirstStrongestEmotions(int stop) {
-		List<Emotion> value = new ArrayList<Emotion>();
+		List<Emotion> value = new ArrayList();
 		for (Emotion e : emotions) {
 			if (stop <= 0) {
 				break;
@@ -297,18 +292,23 @@ public String getText() {
 	}
 
 	/**
-	 * Transforms emotional data into a descriptional sentence ('toString' method)
+	 * Transforms emotional data into a descriptive sentence ('toString' method)
 	 * 
 	 * @return String description of a emotinal data
 	 */
 	@Override
 	public String toString() {
-		return "Text: " + text + "\nGeneral weight: " + generalWeight
-		+ "\nValence: " + valence + "\nHappiness weight: "
-		+ getHappinessWeight() + "\nSadness weight: "
-		+ getSadnessWeight() + "\nAnger weight: " + getAngerWeight()
-		+ "\nFear weight: " + getFearWeight() + "\nDisgust weight: "
-		+ getDisgustWeight() + "\nSurprise weight: "
-		+ getSurpriseWeight() + "\n";
+		StringJoiner sj = new StringJoiner("\n");
+		sj.add("Text: " + text);
+		sj.add("General weight: " + generalWeight);
+		sj.add("Valence: " + valence);
+		sj.add("Happiness weight: " + getHappinessWeight());
+		sj.add("Sadness weight: " + getSadnessWeight());
+		sj.add("Anger weight: " + getAngerWeight());
+		sj.add("Fear weight: " + getFearWeight());
+		sj.add("Disgust weight: " + getDisgustWeight());
+		sj.add("Surprise weight: " + getSurpriseWeight());
+
+		return sj.toString();
 	}
 }

src/main/java/org/chaiware/emotion/Empathyscope.java

@@ -11,7 +11,8 @@
 
 /**
  * Defines logic for transferring textual affect information, emotional
- * manifestations recognised in text into visual output.
+ * manifestations recognised in text into visual output.<br/>
+ * This class is a singleton.
  */
 public class Empathyscope {
 
@@ -37,8 +38,8 @@ public static Empathyscope getInstance() throws IOException {
 	}
 
 	/**
-	 * Textual affect sensing behavior, the main NLP alghoritm which uses
-	 * Synesketch Lexicon and several heuristic rules.
+	 * Textual affect sensing behavior, the main NLP algorithm which uses
+	 * the Lexicon and several heuristic rules.
 	 * 
 	 * @param text String representing the text to be analysed
 	 * @return {@link EmotionalState} which represents data recognised from the text
@@ -47,48 +48,48 @@ public static Empathyscope getInstance() throws IOException {
 	public EmotionalState feel(String text) throws IOException {
 
 		text = text.replace('\n', ' ');
-		List<AffectWord> affectWords = new ArrayList<AffectWord>();
+		List<AffectWord> affectWords = new ArrayList();
 		List<String> sentences = ParsingUtility.parseSentences(text);
 
 		for (String sentence : sentences) {
 
 			System.out.println("- " + sentence);
 
-			// we imploy 6 heuristic rules to adjust emotive weights of the words:
+			// we imply 6 heuristic rules to adjust emotive weights of the words:
 			// (1) more exclamation signs in a sentence => more intensive emotive weights
-			double exclamationQoef = HeuristicsUtility.computeExclaminationQoef(sentence.toLowerCase());
+			double exclamationQoef = HeuristicsUtility.computeExclamationQoef(sentence.toLowerCase());
 
 			// (2) an exclamation mark next to a question mark => emotion of surprise
-			if (HeuristicsUtility.hasExclaminationQuestionMarks(sentence)) {
+			if (HeuristicsUtility.hasExclamationQuestionMarks(sentence)) {
 				AffectWord emoWordSurprise = new AffectWord("?!");
 				emoWordSurprise.setSurpriseWeight(1.0);
 				affectWords.add(emoWordSurprise);
 			}
 
 			boolean hasNegation = false;
 
-			List<String> splittedWords = ParsingUtility.splitWords(sentence," ");
+			List<String> splitWords = ParsingUtility.splitWords(sentence," ");
 			String previousWord = "";
 			String negation = "";
 
-			for (String splittedWord : splittedWords) {
+			for (String splitWord : splitWords) {
 
-				AffectWord emoWord = lexUtil.getEmoticonAffectWord(splittedWord);
+				AffectWord emoWord = lexUtil.getEmoticonAffectWord(splitWord);
 				if (emoWord == null)
-					emoWord = lexUtil.getEmoticonAffectWord(splittedWord.toLowerCase());
+					emoWord = lexUtil.getEmoticonAffectWord(splitWord.toLowerCase());
 
 				if (emoWord != null) {
 					// (3) more emoticons with more 'emotive' signs (e.g. :DDDD)
 					// => more intensive emotive weights
 
-					double emoticonCoef = HeuristicsUtility.computeEmoticonQoef(splittedWord, emoWord);
+					double emoticonCoef = HeuristicsUtility.computeEmoticonQoef(splitWord, emoWord);
 					if (emoticonCoef == 1.0)
-						emoticonCoef = HeuristicsUtility.computeEmoticonQoef(splittedWord.toLowerCase(), emoWord);
+						emoticonCoef = HeuristicsUtility.computeEmoticonQoef(splitWord.toLowerCase(), emoWord);
 					emoWord.adjustWeights(exclamationQoef * emoticonCoef);
 					affectWords.add(emoWord);
 				} else {
 
-					List<String> words = ParsingUtility.parseWords(splittedWord);
+					List<String> words = ParsingUtility.parseWords(splitWord);
 
 					for (String word : words) {
 
@@ -105,10 +106,10 @@ public EmotionalState feel(String text) throws IOException {
 						if (emoWord != null) {
 
 							// (5) word is upper case => more intensive emotive weights
-							double capsLockCoef = HeuristicsUtility.computeCapsLockQoef(word);
+							double capsLockCoef = HeuristicsUtility.computeUpperCasedQoef(word);
 
 							// (6) previous word is a intensity modifier (e.g.
-							// "extremly") => more intensive emotive weights
+							// "extremely") => more intensive emotive weights
 							double modifierCoef = HeuristicsUtility.computeModifier(previousWord);
 
 							// change the affect word!
@@ -130,18 +131,17 @@ public EmotionalState feel(String text) throws IOException {
 	}
 
 	private EmotionalState createEmotionalState(String text, List<AffectWord> affectWords) {
-		TreeSet<Emotion> emotions = new TreeSet<Emotion>();
+		TreeSet<Emotion> emotions = new TreeSet();
 		int generalValence = 0;
-		double valence, generalWeight, happinessWeight, sadnessWeight, angerWeight, fearWeight, disgustWeight, surpriseWeight;
-
-		valence = 0.0;
-		generalWeight = 0.0;
-		happinessWeight = 0.0;
-		sadnessWeight = 0.0;
-		angerWeight = 0.0;
-		fearWeight = 0.0;
-		disgustWeight = 0.0;
-		surpriseWeight = 0.0;
+
+        double valence = 0.0;
+        double generalWeight = 0.0;
+        double happinessWeight = 0.0;
+        double sadnessWeight = 0.0;
+        double angerWeight = 0.0;
+        double fearWeight = 0.0;
+        double disgustWeight = 0.0;
+        double surpriseWeight = 0.0;
 
 		// compute weights. maximum weights for the particular emotion are taken.
 		for (AffectWord affectWord : affectWords) {

src/main/java/org/chaiware/emotion/util/HeuristicsUtility.java

@@ -11,7 +11,7 @@
 public class HeuristicsUtility {
 
 	/**
-	 * Computes emoticon qoef for the sentence. Qoef is based on number of
+	 * Computes emoticon qoef for the sentence. Qoef is based on the number of
 	 * important chars in an emotion (e.g. ')' in ':)))))' ).
 	 * 
 	 * @param sentence {@link String} representing the sentence
@@ -31,7 +31,7 @@ public static double computeEmoticonCoefForSentence(String sentence) throws IOEx
 	}
 
 	/**
-	 * Computes emoticon qoef for the word. Qoef is based on number of important
+	 * Computes emoticon qoef for the word. Qoef is based on number the of important
 	 * chars in an emotion (e.g. ')' in ':)))))' ).
 	 * 
 	 * @param word {@link String} representing the word
@@ -41,8 +41,7 @@ public static double computeEmoticonCoefForSentence(String sentence) throws IOEx
 	public static double computeEmoticonQoef(String word, AffectWord emoticon) {
 		if (emoticon.startsWithEmoticon()) {
 			String emotiveWord = emoticon.getWord();
-			return 1.0 + (0.2 * countChars(word, emotiveWord.charAt(emotiveWord
-					.length() - 1)));
+			return 1.0 + (0.2 * countChars(word, emotiveWord.charAt(emotiveWord.length() - 1)));
 		} else {
 			return 1.0;
 		}
@@ -79,35 +78,36 @@ public static double computeModifier(String word) throws IOException {
 	 * @param word {@link String} representing the word
 	 * @return double representing the upper case qoeficient
 	 */
-	public static double computeCapsLockQoef(String word) {
-		if (isCapsLock(word))
+	public static double computeUpperCasedQoef(String word) {
+		if (isUpperCasedWord(word))
 			return 1.5;
 		else
 			return 1.0;
 	}
 
 	/**
-	 * Computes the exclamination qoef -- function of a number of '!' chars in a sentence.
+	 * Computes the exclamation qoef -- function of a number of '!' chars in a sentence.
 	 * 
 	 * @param text {@link String} representing the sentence 
-	 * @return double representing the exclamination qoef
+	 * @return double representing the exclamation qoef
 	 */
-	public static double computeExclaminationQoef(String text) {
+	public static double computeExclamationQoef(String text) {
 		return 1.0 + (0.2 * countChars(text, '!'));
 	}
 
 	/**
-	 * Returns is there a "!?" or a "?!" in a sentece.
+	 * Returns is there a "!?" or a "?!" in a sentence.
 	 * 
 	 * @param text {@link String} representing the sentence 
-	 * @return boolean representing the existance of a "!?" or a "?!" 
+	 * @return boolean representing the existence of a "!?" or a "?!"
 	 */
-	public static boolean hasExclaminationQuestionMarks(String text) {
+	public static boolean hasExclamationQuestionMarks(String text) {
 
 		return text.contains("?!") || text.contains("!?");
 	}
 
-	private static boolean isCapsLock(String word) {
+	/** Returns true when all of the word is upper cased */
+	private static boolean isUpperCasedWord(String word) {
 		for (int i = 0; i < word.length(); i++) {
 			if (Character.isLowerCase(word.charAt(i)))
 				return false;