sad_panda 1.0.1 → 1.1.0

data/lib/sad_panda/bank/stopwords.rb

@@ -0,0 +1,43 @@
+module SadPanda
+  # Holds the hardcoded data
+  module Bank
+    # common english words
+    STOPWORDS = %w{i a a's able about above according accordingly across actually after
+      afterwards again against ain't all allow allows almost alone along already also although
+      always am among amongst an and another any anybody anyhow anyone anything anyway anyways
+      anywhere apart appear appreciate appropriate are aren't around as aside ask asking associated
+      at available away awfully b be became because become becomes becoming been before beforehand
+      behind being believe below beside besides best better between beyond both brief but by c c'mon
+      c's came can can't cannot cant cause causes certain certainly changes clearly co com come comes
+      concerning consequently consider considering contain containing contains corresponding could couldn't
+      course currently d definitely described despite did didn't different do does doesn't doing don't
+      done down downwards during e each edu eg eight either else elsewhere enough entirely especially et
+      etc even ever every everybody everyone everything everywhere ex exactly example except f far few
+      fifth first five followed following follows for former formerly forth four from further furthermore
+      g get gets getting given gives go goes going gone got gotten greetings h had hadn't happens hardly
+      has hasn't have haven't having he he's hello help hence her here here's hereafter hereby herein
+      hereupon hers herself hi him himself his hither hopefully how howbeit however i i'd i'll i'm
+      i've ie if ignored immediate in inasmuch inc indeed indicate indicated indicates inner insofar
+      instead into inward is isn't it it'd it'll it's its itself j just k keep keeps kept know knows known
+      l last lately later latter latterly least less lest let let's like liked likely little look looking
+      looks ltd m mainly many may maybe me mean meanwhile merely might more moreover most mostly much must
+      my myself n name namely nd near nearly necessary need needs neither never nevertheless new next nine
+      no nobody non none noone nor normally not nothing novel now nowhere o obviously of off often oh ok
+      okay old on once one ones only onto or other others otherwise ought our ours ourselves out outside
+      over overall own p particular particularly per perhaps placed please plus possible presumably probably
+      provides q que quite qv r rather rd re really reasonably regarding regardless regards relatively
+      respectively right s said same saw say saying says second secondly see seeing seem seemed seeming
+      seems seen self selves sensible sent serious seriously seven several shall she should shouldn't since
+      six so some somebody somehow someone something sometime sometimes somewhat somewhere soon sorry specified
+      specify specifying still sub such sup sure t t's take taken tell tends th than thank thanks thanx that
+      that's thats the their theirs them themselves then thence there there's thereafter thereby therefore therein
+      theres thereupon these they they'd they'll they're they've think third this thorough thoroughly those
+      though three through throughout thru thus to together too took toward towards tried tries truly try
+      trying twice two u un under unfortunately unless unlikely until unto up upon us use used useful uses using
+      usually uucp v value various very via viz vs w want wants was wasn't way we we'd we'll we're we've welcome
+      well went were weren't what what's whatever when whence whenever where where's whereafter whereas whereby
+      wherein whereupon wherever whether which while whither who who's whoever whole whom whose why will willing wish
+      with within without won't wonder would would wouldn't x y yes yet yo you you'd you'll you're you've your yours
+      yourself yourselves z zero}.freeze
+  end
+end

data/lib/sad_panda/emotion.rb

@@ -0,0 +1,78 @@
+require 'sad_panda/helpers'
+
+module SadPanda
+  # Emotion determining logic in here
+  class Emotion
+    include Helpers
+
+    attr_reader :words, :scores
+
+    def initialize(text)
+      @words = words_in(text)
+      @scores = { anger: 0, disgust: 0, joy: 0,
+                  surprise: 0, fear: 0, sadness: 0,
+                  ambiguous: 0 }
+    end
+
+    # Main method that initiates scoring emotions
+    def call
+      words = stems_for(remove_stopwords_in(@words))
+      score_words(frequencies_for(words))
+
+      scores.key(scores.values.max)
+    end
+
+    # MethodMissing to implement metods that
+    # are the names of each emotion that will returen
+    # the score of that specific emotion for the text
+    def method_missing(emotion)
+      return scores[emotion] || 0 if scores.keys.include? emotion
+
+      raise NoMethodError, "#{emotion} is not defined"
+    end
+
+    private
+
+    # Last part of the scoring process
+    # If all scores are empty ambiguous is scored as 1
+    def ambiguous_score
+      unq_scores = scores.values.uniq
+      scores[:ambiguous] = 1 if unq_scores.length == 1 && unq_scores.first.zero?
+    end
+
+    # Increments the score of an emotion if the word exist
+    # in that emotion bank
+    def score_emotions(emotion, term, frequency)
+      return unless SadPanda::Bank::EMOTIONS[emotion].include?(term)
+
+      scores[emotion] += frequency
+    end
+
+    # Iterates all emotions for word in text
+    def set_emotions(word, frequency)
+      SadPanda::Bank::EMOTIONS.keys.each do |emotion|
+        score_emotions(emotion, word, frequency)
+      end
+    end
+
+    def score_emoticons
+      happy = happy_emoticon?(words)
+      sad = sad_emoticon?(words)
+
+      scores[:ambiguous] += 1 if happy && sad
+      scores[:joy] += 1 if happy
+      scores[:sadness] += 1 if sad
+    end
+
+    # Logic to score all unique words in the text
+    def score_words(word_frequencies)
+      word_frequencies.each do |word, frequency|
+        set_emotions(word, frequency)
+      end
+
+      score_emoticons
+
+      ambiguous_score
+    end
+  end
+end

data/lib/sad_panda/helpers.rb

@@ -0,0 +1,62 @@
+module SadPanda
+  # Helper methods for SadPanda
+  module Helpers
+    def sad_emojies
+      [':(', ':-(', ':[', ':-[']
+    end
+
+    def happy_emojies
+      [':)', ':-)', ':]', ':-]']
+    end
+
+    # Returns a Hash of frequencies of each uniq word in the text
+    def frequencies_for(words)
+      word_frequencies = {}
+      words.each { |word| word_frequencies[word] = words.count(word) }
+      word_frequencies
+    end
+
+    # Converts all the words to its stem form
+    def stems_for(words)
+      stemmer = Lingua::Stemmer.new(language: 'en')
+      words.map! { |word| stemmer.stem(word) }
+    end
+
+    # Strips the words array of stop words
+    def remove_stopwords_in(words)
+      words - SadPanda::Bank::STOPWORDS
+    end
+
+    # Captures and returns emojies in the text
+    def emojies_in(text)
+      (sad_emojies + happy_emojies).map do |emoji|
+        text.scan(emoji)
+      end.flatten
+    end
+
+    # Removing non ASCII characters from text
+    def sanitize(text)
+      text.gsub!(/[^a-z ]/i, '')
+      text.gsub!(/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)/, '')
+      text.gsub!(/(?=\w*h)(?=\w*t)(?=\w*t)(?=\w*p)\w*/, '')
+      text.gsub!(/\s\s+/, ' ')
+
+      text.downcase    
+    end
+
+    # Removes all the unwated characters from the text
+    def words_in(text)
+      emojies_in(text) + sanitize(text).split
+    end
+
+    # Checks if words has a happy emoji
+    def happy_emoticon?(words)
+      (happy_emojies & words).any?
+    end
+
+    # Checks if words has a sad emoji
+    def sad_emoticon?(words)
+      (sad_emojies & words).any?
+    end
+  end
+end

data/lib/sad_panda/polarity.rb

@@ -0,0 +1,46 @@
+require 'sad_panda/helpers'
+
+module SadPanda
+  # Polarity calculation logic in here
+  class Polarity
+    include Helpers
+
+    attr_reader :words, :polarities
+
+    def initialize(text)
+      @words = words_in(text)
+      @polarities = []
+    end
+
+    # Main method that initiates calculating polarity
+    def call
+      words = stems_for(remove_stopwords_in(@words))
+
+      score_polarities_for(frequencies_for(words))
+
+      polarities.empty? ? 5.0 : (polarities.inject(0){ |sum, polarity| sum + polarity } / polarities.length)
+    end
+
+    private
+
+    # Checks if words has happy or sad emoji and adds polarity for it
+    def score_emoticon_polarity
+      happy = happy_emoticon?(words)
+      sad = sad_emoticon?(words)
+
+      polarities << 5.0 if happy && sad
+      polarities << 8.0 if happy
+      polarities << 2.0 if sad
+    end
+
+    # Appends polarities of words to array polarities
+    def score_polarities_for(word_frequencies)
+      word_frequencies.each do |word, frequency|
+        polarity = SadPanda::Bank::POLARITIES[word.to_sym]
+        polarities << (polarity * frequency.to_f) if polarity
+      end
+
+      score_emoticon_polarity
+    end
+  end
+end

data/lib/sad_panda/version.rb

@@ -1,3 +1,3 @@
 module SadPanda
-  VERSION = "1.0.1"
+  VERSION = '1.1.0'.freeze
 end

data/sad_panda.gemspec

@@ -1,26 +1,27 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'sad_panda/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "sad_panda"
+  spec.name          = 'sad_panda'
   spec.version       = SadPanda::VERSION
-  spec.authors       = ["Matt Buckley"]
-  spec.email         = ["matt.d.buckley1212@gmail.com"]
+  spec.authors       = ['Matt Buckley', 'Edwin Rozario']
+  spec.email         = ['matt.d.buckley1212@gmail.com']
   spec.description   = %q{sad_panda is a gem featuring tools for sentiment analysis of natural language: positivity/negativity and emotion classification.}
   spec.summary       = %q{sad_panda is a gem featuring tools for sentiment analysis of natural language: positivity/negativity and emotion classification.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/mattThousand/sad_panda'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_runtime_dependency "ruby-stemmer"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_runtime_dependency 'ruby-stemmer'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
 end

data/spec/sad_panda/bank/emotions_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe SadPanda::Bank do
+  let(:emotions) { SadPanda::Bank::EMOTIONS }
+
+  describe 'EMOTIONS constant' do
+    it 'returns a hash' do
+      expect(emotions).to be_a Hash
+    end
+
+    it 'is not empty' do
+      expect(emotions).to_not be_empty
+    end
+
+    it 'has all the emotions as keys' do
+      expect(emotions.keys).to eq [:anger, :disgust, :joy, :surprise, :fear, :sadness]
+    end
+
+    context 'constants' do
+      it 'returns an Array for SADNESS' do
+        expect(SadPanda::Bank::EMOTIONS[:anger]).to be_a Array
+      end
+
+      it 'returns an Array for JOY' do
+        expect(SadPanda::Bank::EMOTIONS[:joy]).to be_a Array
+      end
+
+      it 'returns an Array for ANGER' do
+        expect(SadPanda::Bank::EMOTIONS[:anger]).to be_a Array
+      end
+
+      it 'returns an Array for DISGUST' do
+        expect(SadPanda::Bank::EMOTIONS[:disgust]).to be_a Array
+      end
+
+      it 'returns an Array for FEAR' do
+        expect(SadPanda::Bank::EMOTIONS[:fear]).to be_a Array
+      end
+
+      it 'returns an Array for SURPRISE' do
+        expect(SadPanda::Bank::EMOTIONS[:surprise]).to be_a Array
+      end
+    end
+  end
+end

data/spec/sad_panda/bank/polarities_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe SadPanda::Bank do
+  describe 'when POLARITIES is accessed' do
+    it 'returns a hash' do
+      expect(SadPanda::Bank::POLARITIES).to be_a Hash
+    end
+
+    it 'is not empty' do
+      expect(SadPanda::Bank::POLARITIES).to_not be_empty
+    end
+  end
+end

data/spec/sad_panda/bank/stopwords_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe SadPanda::Bank do
+  describe 'when STOPWORDS is accessed' do
+    it 'returns an Array' do
+      expect(SadPanda::Bank::STOPWORDS).to be_a Array
+    end
+
+    it 'is not empty' do
+      expect(SadPanda::Bank::STOPWORDS).to_not be_empty
+    end
+  end
+end

data/spec/sad_panda/emotion_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe SadPanda::Emotion do
+  describe 'initialization' do
+    let(:object) { SadPanda::Emotion.new('Initialize this text in sad panda') }
+
+    it 'initializes scores as 0 for all emotions' do
+      expect(object.scores).to eq(:anger => 0, :disgust => 0, :joy => 0,
+                                  :surprise => 0, :fear => 0, :sadness => 0,
+                                  :ambiguous => 0)
+    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 words with emotions' do
+      let(:object) { SadPanda::Emotion.new('my lobster collection makes me happy!') }
+
+      it 'returns :joy' do
+        expect(object.call).to eq :joy
+      end
+
+      it 'scores emotions' do
+        object.call
+        expect(object.scores).to eq(:anger => 0, :disgust => 0, :joy => 1,
+                                    :surprise => 0, :fear => 0, :sadness => 0,
+                                    :ambiguous => 0)
+      end
+    end
+
+    context 'when input contains no words with emotions' do
+      let(:object) { SadPanda::Emotion.new(' ') }
+
+      it 'returns :ambiguous' do
+        expect(object.call).to eq :ambiguous
+      end
+
+      it 'does not scores emotions but ambiguous' do
+        object.call
+        expect(object.scores).to eq(:anger => 0, :disgust => 0, :joy => 0,
+                                    :surprise => 0, :fear => 0, :sadness => 0,
+                                    :ambiguous => 1)
+      end
+    end
+  end
+
+  describe 'emotions defined in method_missing' do
+    let(:object) { SadPanda::Emotion.new('This is a test affright message for anxiously sadness :)') }
+
+    before do
+      object.call
+    end
+
+    it 'returns emotion value for fear' do
+      expect(object.fear).to eq 2
+    end
+
+    it 'returns emotion value for anger' do
+      expect(object.anger).to eq 0
+    end
+
+    it 'returns emotion value for joy' do
+      expect(object.joy).to eq 1
+    end
+
+    it 'returns emotion value for disgust' do
+      expect(object.disgust).to eq 0
+    end
+
+    it 'returns emotion value for surprise' do
+      expect(object.surprise).to eq 0
+    end
+
+    it 'returns emotion value for sadness' do
+      expect(object.sadness).to eq 1
+    end
+
+    it 'returns emotion value for ambiguous' do
+      expect(object.ambiguous).to eq 0
+    end
+
+    it 'raises an exception if the method is not an emotion' do
+      expect { object.fake_emotion }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#ambiguous_score' do
+    let(:object) { SadPanda::Emotion.new('') }
+
+    context 'when all emotion scores are 0' do
+      it 'adds ambiguous to scores as 1' do
+        expect(object.scores[:ambiguous]).to eq 0
+
+        object.send(:ambiguous_score)
+
+        expect(object.scores[:ambiguous]).to eq 1
+      end
+    end
+
+    context 'when some emotion scores are greater than 0' do
+      it 'does not adds ambiguous scores' do
+        object.scores[:joy] = 1
+
+        object.send(:ambiguous_score)
+
+        expect(object.scores[:ambiguous]).to eq 0
+      end
+    end
+  end
+
+  describe '#score_emotions' do
+    let(:object) { SadPanda::Emotion.new('') }
+
+    context 'when word dosent not exist in emotion bank' do
+      it 'does nothing and returns nil' do
+        expect(object.send(:score_emotions, :joy, 'notjoy', 1)).to eq nil
+        expect(object.scores[:joy]).to eq 0
+      end
+    end
+
+    context 'when word dose exist in emotion bank' do
+      it 'updates scores with frequency' do
+        expect(object.send(:score_emotions, :joy, 'happy', 1)).to eq 1
+        expect(object.scores[:joy]).to eq 1
+      end
+    end
+  end
+
+  describe '#set_emotions' do
+    let(:object) { SadPanda::Emotion.new('') }
+
+    context 'when word dosent not exist in any emotion bank' do
+      it 'does not add any score' do
+        object.send(:set_emotions, 'notaword', 1)
+        expect(object.scores).to eq(:anger => 0, :disgust => 0,:joy => 0,
+                                    :surprise => 0, :fear => 0, :sadness => 0,
+                                    :ambiguous => 0)
+      end
+    end
+
+    context 'when word dose exist in an emotion bank' do
+      it 'add frequency to score of the emotion' do
+        object.send(:set_emotions, 'happy', 1)
+        expect(object.scores).to eq(:anger => 0, :disgust => 0,:joy => 1,
+                                    :surprise => 0, :fear => 0, :sadness => 0,
+                                    :ambiguous => 0)
+      end
+    end
+  end
+
+  describe '#score_words' do
+    let(:object) { SadPanda::Emotion.new('') }
+
+    context 'when words dosent not exist in any emotion bank' do
+      it 'does not add any score but ambiguous' do
+        object.send(:score_words, { 'notword' => 1, 'foobar' => 2})
+        expect(object.scores).to eq(:anger => 0, :disgust => 0,:joy => 0,
+                                    :surprise => 0, :fear => 0, :sadness => 0,
+                                    :ambiguous => 1)
+      end
+    end
+
+    context 'when word dose exist in an emotion bank' do
+      it 'add frequency to score of the emotion' do
+        object.send(:score_words, { 'happy' => 1, 'sad' => 2})
+        expect(object.scores).to eq(:anger => 0, :disgust => 0,:joy => 1,
+                                    :surprise => 0, :fear => 0, :sadness => 2,
+                                    :ambiguous => 0)
+      end
+    end
+  end  
+end