sad_panda 1.0.1 → 1.1.0

data/spec/sad_panda/helpers_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe SadPanda::Helpers do
+  let(:helpers) { Class.new { extend SadPanda::Helpers } }
+
+  describe '#frequencies_for' do
+    it 'returns a hash with the frquency of each word' do
+      expect(helpers.frequencies_for(['foo', 'bar', 'quxx', 'foo'])).to eq({'foo' => 2, 'bar' => 1, 'quxx' => 1})
+    end
+  end
+
+  describe '#stems_for' do
+    it 'returns the stems of words' do
+      expect(helpers.stems_for(%w[programming amazes])).to eq %w[program amaz]
+    end
+  end
+
+  describe '#remove_stopwords_in' do
+    it 'returns the array without stop words in it' do
+      expect(helpers.remove_stopwords_in(%w[this is a cool test])).to eq %w[cool test]
+    end
+  end
+
+  describe '#words_in' do
+    it 'returns an array' do
+      expect(helpers.words_in('output array')).to be_a Array
+    end
+
+    it 'returns an array of words from the text' do
+      expect(helpers.words_in('make this an array')).to eq %w[make this an array]
+    end
+  end
+
+  describe '#emojies_in' do
+    it 'returns sad and happy emojies from the text as an array' do
+      expect(helpers.emojies_in('I am :] :). But :( as well.')).to eq [':(', ':)', ':]']
+    end
+  end
+
+  describe '#sanitize' do
+    it 'returns text with only english alphabets' do
+      expect(helpers.sanitize('I am :] :). But :( as well.')).to eq 'i am but as well'
+    end
+  end
+
+  describe '#happy_emoticon?' do
+    context 'when words has a happy emoji' do
+      it 'returns true' do
+        expect(helpers.happy_emoticon?(['foo', ':)'])).to be true
+      end
+    end
+
+    context 'when words does not have a happy emoji' do
+      it 'returns false' do
+        expect(helpers.happy_emoticon?(['foo', 'bar'])).to be false
+      end
+    end
+  end
+
+  describe '#sad_emoticon?' do
+    context 'when words has a sad emoji' do
+      it 'returns true' do
+        expect(helpers.sad_emoticon?(['foo', ':('])).to be true
+      end
+    end
+
+    context 'when words does not have a sad emoji' do
+      it 'returns false' do
+        expect(helpers.sad_emoticon?(['foo', 'bar'])).to be false
+      end
+    end
+  end
+end

data/spec/sad_panda/polarity_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe SadPanda::Polarity do
+  describe 'initialization' do
+    let(:object) { SadPanda::Polarity.new('Initialize this text in sad panda') }
+
+    it 'initializes polarities as an empty Array' do
+      expect(object.polarities).to eq []
+    end
+
+    it 'initializes words in an Array' do
+      expect(object.words).to eq %w[initialize this text in sad panda]
+    end
+  end
+
+  describe '#call' do
+    context 'when input contains no words with polarities' do
+      let(:object) { SadPanda::Polarity.new(' ') }
+
+      it 'returns 5.0' do
+        expect(object.call).to eq 5.0
+      end
+
+      it 'adds no polarities of words to polarities Array' do
+        object.call
+
+        expect(object.polarities).to eq []
+      end
+    end
+
+    context 'when input contains a word with polarity' do
+      let(:object) { SadPanda::Polarity.new('I love cactuses!') }
+
+      it 'returns 10.0' do
+        expect(object.call).to eq 10.0
+      end
+
+      it 'adds polarities of words to polarities Array' do
+        object.call
+
+        expect(object.polarities).to eq [10.0]
+      end
+    end
+  end
+
+  describe '#score_emoticon_polarity' do
+    context 'when words has a sad emoji' do
+      let(:object) { SadPanda::Polarity.new('I am :(') }
+
+      it 'adds 2.0 to polarities' do
+        object.send(:score_emoticon_polarity)
+
+        expect(object.polarities.include?(2.0)).to be true
+      end
+    end
+
+    context 'when words has a happy emoji' do
+      let(:object) { SadPanda::Polarity.new('I am :)') }
+
+      it 'adds 8.0 to polarities' do
+        object.send(:score_emoticon_polarity)
+
+        expect(object.polarities.include?(8.0)).to be true
+      end
+    end
+
+    context 'when words has sad & happy emoji' do
+      let(:object) { SadPanda::Polarity.new('I am :) and :(') }
+
+      it 'adds 5.0 to polarities' do
+        object.send(:score_emoticon_polarity)
+
+        expect(object.polarities.include?(5.0)).to be true
+      end
+    end
+  end
+
+  describe '#score_polarities_for' do
+    let(:object) { SadPanda::Polarity.new('') }
+
+    it 'appends the right polarities of words to polarities' do
+      object.send(:score_polarities_for, { 'abandoned' => 1, 'educated' => 1 })
+
+      expect(object.polarities).to eq [2.5, 7.5]
+    end
+  end
+end

data/spec/sad_panda_spec.rb

@@ -1,423 +1,95 @@
 require 'spec_helper'
 
-
-describe SadPanda  do
-
-  let(:emotions) {EmotionBank.get_term_emotions}
-  let(:polarities) {TermPolarities.get_term_polarities}
-  let(:term_frequencies) {SadPanda.build_term_frequencies("My cactus collection makes me happy.")}
-  let(:emotion_score) { {} }
-  let(:polarity_scores) { [] }
-  let(:polarity_hash) { TermPolarities.get_term_polarities }
-
-  context "methods" do
-    describe "#happy_emoticon" do
-
-      context "when true" do
-        it "returns true" do
-          message = ":)"
-          expect(SadPanda.happy_emoticon(message)).to be_true
-        end
-      end
-
-      context "when false" do
-        it "returns true" do
-          message = "stuff"
-          expect(SadPanda.happy_emoticon(message)).to be_false
-        end
-      end
-
-
+describe SadPanda do
+  describe '#emotion' do
+    it 'returns a Symbol result' do
+      expect(SadPanda.emotion('panda emotion respose')).to be_a Symbol
     end
 
-    describe "#sad_emoticon" do
-
-      context "when true" do
-        it "returns true" do
-          message = ":("
-          expect(SadPanda.sad_emoticon(message)).to be_true
-        end
+    context 'joy' do
+      it 'returns :joy for a happy text' do
+        expect(SadPanda.emotion('my lobster collection makes me happy!')).to eq :joy
       end
 
-      context "when false" do
-        it "returns true" do
-          message = "stuff"
-          expect(SadPanda.sad_emoticon(message)).to be_false
-        end
+      it 'returns :joy for a happy emoji' do
+        expect(SadPanda.emotion('my lobster collection makes me :)')).to eq :joy
       end
-
     end
 
-    describe "#words_from_message_text" do
-
-      it "removes urls and other gross stuff from tweet" do
-        message = "lobster hickory http://www.boston.com/business #Rails"
-
-        words = SadPanda.words_from_message_text(message)
-
-        expect(words).to eql(["lobster", "hickory", "rails"])
+    context 'anger' do
+      it 'returns :anger for an angry text' do
+        expect(SadPanda.emotion('Can the JS devils focus on one framewors than having 100')).to eq :anger
       end
-
     end
 
-    describe "#set_emotions" do
-
-      it "modifies the emotions_score array" do
-
-        term_frequencies.each do |key, value|
-          SadPanda.set_emotions(emotions, emotion_score, key, value)
-        end
-        expect((emotion_score["joy"])).to eql(1)
+    context 'fear' do
+      it 'returns :fear for an fearedful text' do
+        expect(SadPanda.emotion('I am ril afraid of cats, homie')).to eq :fear
       end
-
     end
 
-    describe "#set_polarities" do
-
-      it "modifies the polarity_scores array" do
-        term_frequencies = {'sad' => 1}
-        term_frequencies.each do |key, value|
-          SadPanda.set_polarities(key, value, polarity_hash, polarity_scores)
-        end
-        expect(polarity_scores).to eql([0.0])
+    context 'disgust' do
+      it 'returns :disgust for an text with disgust' do
+        expect(SadPanda.emotion('I am disgusted')).to eq :disgust
       end
-
     end
 
-    describe "#store_emotions" do
-      it "stores emotions in emotion_score hash" do
-
-        emotions = {"joy" => "zorg" }
-        key,value = "zorg", 1
-
-        emotions.keys.each do |k|
-          SadPanda.store_emotions(emotions, emotion_score, k, key, value)
-        end
-        expect(emotion_score["joy"]).to eql(1)
+    context 'surprise' do
+      it 'returns :surprise for an surprising text' do
+        expect(SadPanda.emotion('ActionCable mystifies me')).to eq :surprise
       end
-
     end
 
-    describe "#store_polarities" do
-
-      context "word in polarity_hash" do
-
-        it "adds a polarity to polarity_scores" do
-          term = "sad"
-          word = "sad"
-          SadPanda.store_polarities(term, word, polarity_hash, polarity_scores)
-          expect(polarity_scores).to eql([0.0])
-        end
-
+    context 'ambiguous' do
+      it 'returns :ambiguous for a neutral text' do
+        expect(SadPanda.emotion('Python is ok')).to eq :ambiguous
       end
 
-      context "word not in polarity_hash" do
-
-        it "does not add a polarity to polarity_scores" do
-          term = "sad"
-          word = "cactus"
-          SadPanda.store_polarities(term, word, polarity_hash, polarity_scores)
-          expect(polarity_scores).to eql([])
-        end
-
-      end
-
-    end
-
-    describe "#create_term_frequencies" do
-
-      it "populates a word-stem frequency hash" do
-        words = ["yo", "stuff"]
-        term_frequencies = {}
-        word_stems = SadPanda.get_word_stems(words)
-        term_frequencies = SadPanda.create_term_frequencies(word_stems, term_frequencies)
-
-        expect(term_frequencies).to eql({"yo"=>1, "stuff"=>1})
+      it 'returns :ambiguous for an empty string' do
+        expect(SadPanda.emotion('  ')).to be :ambiguous
       end
-
     end
 
-    describe "#check_emoticon_for_emotion" do
-      context "contains happy emoticon" do
-
-        it "returns 'joy'" do
-          message = ":)"
-          output = SadPanda.check_emoticon_for_emotion(emotion_score, message)
-          expect(output).to eql("joy")
-        end
-
+    context 'sadness' do
+      it 'returns :sadness for a sad text' do
+        expect(SadPanda.emotion('Slow tests make me sad')).to eq :sadness
       end
 
-      context "contains sad emoticon" do
-
-        it "returns 'sadness'" do
-          message = ":("
-          output = SadPanda.check_emoticon_for_emotion(emotion_score, message)
-          expect(output).to eql("sadness")
-        end
-
-      end
-
-      context "contains both a happy and a sad emoticon" do
-
-        it "returns 'ambiguous'" do
-          message = ":( :)"
-          output = SadPanda.check_emoticon_for_emotion(emotion_score, message)
-          expect(output).to eql("ambiguous")
-        end
-
-      end
-
-      context "contains no emoticons and emotion_score is not empty" do
-
-        it "returns joy" do
-          message = "no emoticons in hur"
-          emotion_score = {"joy" => 1}
-          output = SadPanda.check_emoticon_for_emotion(emotion_score, message)
-          expect(output).to eql("joy")
-        end
-
-      end
-
-      context "contains no emoticons and emotion_score is  empty" do
-
-        it "returns joy" do
-          message = "no emoticons in hur"
-          output = SadPanda.check_emoticon_for_emotion(emotion_score, message)
-          expect(output).to eql("ambiguous")
-        end
-
+      it 'returns :anger for an sad emoji' do
+        expect(SadPanda.emotion('Angular, React & Vue. Now what? :(')).to eq :sadness
       end
     end
-
-    describe "#check_emoticon_for_polarity" do
-      context "contains happy emoticon" do
-
-        it "returns 8" do
-          message = ":)"
-          polarity_scores = [2.0,3.0]
-          output = SadPanda.check_emoticon_for_polarity(polarity_scores, message)
-          expect(output).to eql(8)
-        end
-
-      end
-
-      context "contains sad emoticon" do
-
-        it "returns 2" do
-          message = ":("
-          polarity_scores = [2.0,3.0]
-          output = SadPanda.check_emoticon_for_polarity(polarity_scores, message)
-          expect(output).to eql(2)
-        end
-
-      end
-
-      context "contains both a happy and a sad emoticon" do
-
-        it "returns 5" do
-          message = ":( :)"
-          polarity_scores = [2.0,3.0]
-          output = SadPanda.check_emoticon_for_polarity(polarity_scores, message)
-          expect(output).to eql(5)
-        end
-
-      end
-
-
-      context "contains no emoticons and polarity_scores is empty" do
-
-        it "returns joy" do
-          message = "no emoticons in hur"
-          polarity_scores = []
-          output = SadPanda.check_emoticon_for_polarity(polarity_scores, message)
-          expect(output).to eql(5)
-        end
-
-      end
-
-      context "contains no emoticons and emotion_score is not empty" do
-
-        it "returns joy" do
-          message = "no emoticons in hur"
-          polarity_scores = [8.0]
-          output = SadPanda.check_emoticon_for_polarity(polarity_scores, message)
-          expect(output).to eql(8.0)
-        end
-
-      end
-    end
-
-  end
-
-  describe "when 'build_term_frequencies' method is called" do
-
-    context "when status_message is an empty string" do
-      it "returns an empty hash" do
-        empty_message = "   "
-        expect(SadPanda.build_term_frequencies(empty_message)).to be_empty
-      end
-    end
-
-    context "when input is a non-recogizable word" do
-      it "returns a empty hash with key == zorg and and value == 1" do
-        word = "zorg"
-        expect(SadPanda.build_term_frequencies(word)).to eql({"zorg" => 1})
-      end
-    end
-
-    context "when input includes recognizable words" do
-      it "returns a non-empty hash" do
-        hash = SadPanda.build_term_frequencies("I am happy")
-        expect(hash).to_not be_empty
-      end
-    end
-
   end
 
-  describe "when 'get_emotion_score' method is called" do
-    it 'returns a string' do
-      message = "this is a message!"
-      output = SadPanda.get_emotion_score(message, emotions,term_frequencies)
-      expect(output.class).to eql(String)
-    end
-  end
+  describe '#polarity' do
+    let(:polarity) { SadPanda.polarity('I love cactuses!') }
 
-  describe "when 'get_polarity_score' method is called" do
-    it 'returns a string' do
-      message = "this is another message!"
-      output = SadPanda.get_polarity_score(message, polarities, term_frequencies)
-      expect(output.class).to eql(Fixnum)
+    it 'returns a Float value polarity' do
+      expect(polarity).to be_a Float
     end
-  end
-
 
-  describe "when polarity method is called" do
-
-    it "returns a fixnum" do
-      expect(SadPanda.polarity("My cactus collection makes me happy.").class).to eql(Fixnum)
+    it 'returns 10.0' do
+      expect(polarity).to eq 10.0
     end
 
-    context "when status_message == 'my lobster collection makes me happy' " do
-      it "emotion == 'joy' " do
-        status_message = "my lobster collection makes me happy"
-        expect(SadPanda.emotion(status_message)).to eql("joy")
-      end
+    it 'returns 8.0 for happy emoji' do
+      expect(SadPanda.polarity(':)')).to eq 8.0
     end
 
-    context "when status_message == 'sad' " do
-      it "emotion == 'sadness' " do
-        status_message = "sad"
-        expect(SadPanda.emotion(status_message)).to eql("sadness")
-      end
+    it 'returns 8.0 for sad emoji' do
+      expect(SadPanda.polarity(':(')).to eq 2.0
     end
 
-    context "when status_message == 'angry' "  do
-      it "emotion == 'anger' " do
-        status_message = "angry"
-        expect(SadPanda.emotion(status_message)).to eql('anger')
-      end
+    it 'returns 5.0 for happy & sademoji' do
+      expect(SadPanda.polarity(':) :(')).to eq 5.0
     end
 
-    context "when status_message == 'I am ril afraid of cats, homie' " do
-      it "emotion == 'fear' " do
-        status_message = "I am ril afraid of cats, homie"
-        expect(SadPanda.emotion(status_message)).to eql("fear")
-      end
-    end
-
-    context "when status == 'I am disgusted' " do
-      it "emotion == 'disgust'" do
-        status_message =  "I am disgusted"
-        expect(SadPanda.emotion(status_message)).to eql('disgust')
-      end
+    it 'returns 5.0 for empty string' do
+      expect(SadPanda.polarity(' ')).to eq 5.0
     end
 
-    context "when status == 'I am so surprised'" do
-      it "emotion == 'surprise'" do
-        status_message =  "I am so surprised"
-        expect(SadPanda.emotion(status_message)).to eql('surprise')
-      end
-    end
-
-    context "when status_message == 'blarg' " do
-      it "emotion == 'ambiguous' " do
-        status_message =  "blarg"
-        expect(SadPanda.emotion(status_message)).to eql('ambiguous')
-      end
-    end
-
-    context "when status_message == '  ' " do
-      it "emotion is 'ambiguous'" do
-        status_message =  "  "
-        expect(SadPanda.emotion(status_message)).to eql('ambiguous')
-      end
-    end
-
-  end
-
-  describe "when emotion method is called" do
-
-    it "returns a string" do
-      status_message="joy"
-      expect(SadPanda.emotion(status_message).class).to eql(String)
-    end
-
-    context "when status_message == 'I am happy' " do
-      it "polarity is greater than zero" do
-        status_message = "I am happy"
-        expect(SadPanda.polarity(status_message)).to be > 0
-      end
-    end
-
-
-    context "when status_message == 'sad' " do
-      it "polarity is less than zero" do
-        status_message =  "sad"
-        expect(SadPanda.polarity(status_message)).to be < 5
-      end
-    end
-
-    context "when status_message == 'anger' " do
-      it "polarity is zero" do
-        status_message = "anger"
-        expect(SadPanda.polarity(status_message)).to be < 5
-      end
-    end
-
-    context "when status_message == 'I am terrified' " do
-      it "polarity is zero" do
-        status_message = "I am fearful"
-        expect(SadPanda.polarity(status_message)).to be < 5
-      end
-    end
-
-    context "when status == 'I am disgusted' " do
-      it "has a non-zero polarity value" do
-        status_message = "I am disgusted"
-        expect(SadPanda.polarity(status_message)).to be < 5
-      end
-    end
-
-    context "when status == 'This is surprising'" do
-      it "has a neutral polarity value" do
-        status_message = "This is surprising"
-        expect(SadPanda.polarity(status_message)).to eql(5)
-      end
-    end
-
-    context "when status_message == 'blarg' " do
-      it "polarity is zero" do
-        status_message = "blarg"
-        expect(SadPanda.polarity(status_message)).to eql(5)
-      end
-    end
-
-    context "when status_message == '  ' " do
-      it "polarity is zero" do
-        status_message =  "  "
-        expect(SadPanda.polarity(status_message)).to eql(5)
-      end
+    it 'returns 5.0 for a neutral' do
+      expect(SadPanda.polarity('This is surprising')).to eq 5.0
     end
   end
 end