vader_sentiment_ruby 0.1.0

data/lib/vader_sentiment_ruby/emojis_describer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Replaces emoji char with its description
+  class EmojiDescriber
+    def initialize(text, emojis)
+      @text = text
+      @emojis = emojis
+      @text_no_emoji = ''
+      @prev_space = true
+    end
+
+    def call
+      @text.split('').each do |chr|
+        if @emojis.keys.include?(chr)
+          handle_emoji_presence(chr)
+        else
+          handle_emoji_absence(chr)
+        end
+      end
+
+      @text_no_emoji
+    end
+
+    private
+
+    def handle_emoji_presence(emoji)
+      description = @emojis[emoji]
+      @text_no_emoji += ' ' unless @prev_space
+      @text_no_emoji += description
+      @prev_space = false
+    end
+
+    def handle_emoji_absence(character)
+      @text_no_emoji += character
+      @prev_space = character == ' '
+    end
+  end
+end

data/lib/vader_sentiment_ruby/emojis_dictionary_creator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Converts emoji lexicon file to a dictionary
+  class EmojisDictionaryCreator
+    # @return [Hash]
+    def call
+      emoji_file = File.open("#{__dir__}/data/emoji_utf8_lexicon.txt").read
+      emoji_dict = {}
+      lines = emoji_file.strip.split("\n")
+      lines.each do |line|
+        next unless line
+
+        emoji, description = line.strip.split("\t")[0..1]
+        emoji_dict[emoji] = description
+      end
+
+      emoji_dict
+    end
+  end
+end

data/lib/vader_sentiment_ruby/lexicon_dictionary_creator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Converts lexicon file to a dictionary
+  class LexiconDictionaryCreator
+    # @return [Hash]
+    def call
+      lexicon_file = File.open("#{__dir__}/data/vader_lexicon.txt").read
+      lex_dict = {}
+      lines = lexicon_file.strip.split("\n")
+      lines.each do |line|
+        next unless line
+
+        word, measure = line.strip.split("\t")[0..1]
+        lex_dict[word] = measure.to_f
+      end
+
+      lex_dict
+    end
+  end
+end

data/lib/vader_sentiment_ruby/punctuation_emphasis_amplifier.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Adds emphasis from exclamation points and question marks
+  class PunctuationEmphasisAmplifier
+    # @param [String] text
+    def initialize(text)
+      @text = text
+    end
+
+    # @return [Float]
+    def call
+      amplify_exclamation_points + amplify_question_marks
+    end
+
+    def amplify_exclamation_points
+      # check for added emphasis resulting from exclamation points (up to 4 of them)
+      ep_count = @text.split('').count('!')
+      ep_count = 4.0 if ep_count > 4
+
+      # empirically derived mean sentiment intensity rating increase for exclamation points
+      ep_count * 0.292
+    end
+
+    def amplify_question_marks
+      # check for added emphasis resulting from question marks (2 or 3+)
+      qm_count = @text.split('').count('?')
+
+      return 0.0 unless qm_count > 1
+      # empirically derived mean sentiment intensity rating increase for question marks
+      return qm_count * 0.18 if qm_count <= 3
+
+      0.96
+    end
+  end
+end

data/lib/vader_sentiment_ruby/sentiment_intensity_analyzer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Returns a sentiment intensity score for sentences.
+  class SentimentIntensityAnalyzer
+    def initialize
+      @lexicon = LexiconDictionaryCreator.new.call
+      @emojis = EmojisDictionaryCreator.new.call
+    end
+
+    # Returns a float for sentiment strength based on the input text.
+    # Positive values are positive valence, negative value are negative valence.
+    # @param [String] text Text to analyze
+    # @return [Hash] Hash of sentiments for analyzed text
+    def polarity_scores(text)
+      text = EmojiDescriber.new(text, @emojis).call
+      senti_text = SentimentPropertiesIdentifier.new(text)
+
+      sentiments = []
+      words_and_emoticons = senti_text.words_and_emoticons
+      words_and_emoticons.each_with_index do |item, index|
+        sentiments << prepare_valence(item, index, words_and_emoticons, senti_text)
+      end
+
+      sentiments = Checker::ButWordNegationChecker.new(words_and_emoticons, sentiments).call
+
+      ValenceScoreCalculator.new(sentiments, text).call
+    end
+
+    private
+
+    def prepare_valence(item, index, words_and_emoticons, senti_text)
+      valence = 0
+
+      # Check for vader_lexicon words that may be used as modifiers or negations
+      return valence if Constants::BOOSTER_DICT.keys.include?(item.downcase)
+
+      if index < words_and_emoticons.size - 1 &&
+         item.downcase == 'kind' &&
+         (words_and_emoticons[index + 1]).downcase == 'of'
+        return valence
+      end
+
+      sentiment_valence(valence, senti_text, item, index)
+    end
+
+    def sentiment_valence(valence, senti_text, item, index)
+      item_lowercase = item.downcase
+
+      if @lexicon.keys.include?(item_lowercase)
+        valence = calculate_valence_for_word_in_lexicon(item, item_lowercase, index, senti_text)
+      end
+
+      valence
+    end
+
+    def calculate_valence_for_word_in_lexicon(item, item_lowercase, index, senti_text)
+      is_cap_diff = senti_text.is_cap_diff
+      words_and_emoticons = senti_text.words_and_emoticons
+
+      valence = @lexicon[item_lowercase] # get the sentiment valence
+      valence = Checker::NoWordChecker.new(valence, item_lowercase, index, words_and_emoticons, @lexicon).call
+      # Check if sentiment laden word is in ALL CAPS (while others aren't)
+      valence = apply_intensity_rating(valence) if WordHelper.word_upcase?(item) && is_cap_diff
+      valence = modify_valence_by_scalar(valence, index, words_and_emoticons, is_cap_diff)
+      Checker::LeastWordNegationChecker.new(valence, words_and_emoticons, index, @lexicon).call
+    end
+
+    def apply_intensity_rating(valence)
+      return valence + Constants::C_INCR if valence.positive?
+
+      valence - Constants::C_INCR
+    end
+
+    # Dampen the scalar modifier of preceding words and emoticons
+    # (excluding the ones that immediately precede the item) based
+    # on their distance from the current item.
+    def modify_valence_by_scalar(valence, index, words_and_emoticons, is_cap_diff)
+      (0..2).each do |start_index|
+        next unless index > start_index
+        next if @lexicon.keys.include?((words_and_emoticons[index - (start_index + 1)]).downcase)
+
+        valence = apply_scalar(valence, words_and_emoticons, index, start_index, is_cap_diff)
+        valence = Checker::NegationChecker.new(valence, words_and_emoticons, start_index, index).call
+        valence = Checker::SpecialIdiomsChecker.new(valence, words_and_emoticons, index).call if start_index == 2
+      end
+
+      valence
+    end
+
+    def apply_scalar(valence, words_and_emoticons, index, start_index, is_cap_diff)
+      previous_word = words_and_emoticons[index - (start_index + 1)]
+      scalar = Checker::PreviousWordsInfluenceChecker.new(previous_word, valence, is_cap_diff).call
+      valence + adjust_scalar(scalar, start_index)
+    end
+
+    def adjust_scalar(scalar, start_index)
+      return scalar if scalar.zero?
+
+      scalar *= 0.95 if start_index == 1
+      scalar *= 0.9 if start_index == 2
+      scalar
+    end
+  end
+end

data/lib/vader_sentiment_ruby/sentiment_properties_identifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Identify sentiment-relevant string-level properties of input text.
+  class SentimentPropertiesIdentifier
+    attr_reader :is_cap_diff, :words_and_emoticons
+
+    # @param [String] text
+    def initialize(text)
+      text = text.to_s.encode('utf-8') unless text.is_a? String
+      @text = text
+      @words_and_emoticons = prepare_words_and_emoticons
+      # Doesn't separate words from adjacent punctuation (keeps emoticons & contractions)
+      @is_cap_diff = all_cap_differential?(@words_and_emoticons)
+    end
+
+    private
+
+    # Removes leading and trailing punctuation
+    # Leaves contractions and most emoticons
+    # Does not preserve punc-plus-letter emoticons (e.g. :D)
+    # @return [Array]
+    def prepare_words_and_emoticons
+      @text
+        .split
+        .map { |word| WordHelper.strip_punctuation(word) }
+    end
+
+    # Check whether just some words in the input are ALL CAPS.
+    # Returns `True` if some but not all items in `words` are ALL CAPS
+    # @param [Array] words
+    # @return [Boolean]
+    def all_cap_differential?(words)
+      all_cap_words = 0
+
+      words.each do |word|
+        all_cap_words += 1 if WordHelper.word_upcase?(word)
+      end
+
+      words_size = words.size
+      cap_differential = words_size - all_cap_words
+
+      return true if cap_differential.positive? && cap_differential < words_size
+
+      false
+    end
+  end
+end

data/lib/vader_sentiment_ruby/sentiment_scores_sifter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Separates positive versus negative sentiment scores
+  class SentimentScoresSifter
+    def initialize(sentiments)
+      @sentiments = sentiments
+      @pos_sum = 0.0
+      @neg_sum = 0.0
+      @neu_count = 0
+    end
+
+    def call
+      @sentiments.each do |sentiment_score|
+        # compensates for neutral words that are counted as 1
+        @pos_sum += sentiment_score.to_f + 1 if sentiment_score.positive?
+
+        # when used with .abs, compensates for neutrals
+        @neg_sum += sentiment_score.to_f - 1 if sentiment_score.negative?
+
+        @neu_count += 1 if sentiment_score.zero?
+      end
+
+      [@pos_sum, @neg_sum, @neu_count]
+    end
+  end
+end

data/lib/vader_sentiment_ruby/valence_score_calculator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Prepares response with semantic score
+  class ValenceScoreCalculator
+    DEFAULT_RESPONSE = {
+      negative: 0.0,
+      neutral: 0.0,
+      positive: 0.0,
+      compound: 0.0
+    }.freeze
+
+    def initialize(sentiments, text)
+      @sentiments = sentiments
+      @text = text
+    end
+
+    def call
+      return DEFAULT_RESPONSE unless @sentiments
+
+      sum_s = @sentiments.map(&:to_f).sum
+      # compute and add emphasis from punctuation in text
+      punct_emph_amplifier = PunctuationEmphasisAmplifier.new(@text).call
+      compound = normalize(sum_s, punct_emph_amplifier)
+
+      prepare_response(compound, punct_emph_amplifier)
+    end
+
+    private
+
+    # Normalize the score to be between -1 and 1 using an alpha that
+    # approximates the max expected value
+    # Move to Sentiment analyzer
+    def normalize(score, punct_emph_amplifier, alpha = 15)
+      score = add_punctuation_emphasis(score, punct_emph_amplifier)
+      norm_score = score / Math.sqrt((score * score) + alpha).to_f
+
+      return -1.0 if norm_score < -1.0
+      return 1.0 if norm_score > 1.0
+
+      norm_score
+    end
+
+    def add_punctuation_emphasis(sum_s, punct_emph_amplifier)
+      if sum_s.positive?
+        sum_s += punct_emph_amplifier
+      elsif sum_s.negative?
+        sum_s -= punct_emph_amplifier
+      end
+
+      sum_s
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def prepare_response(compound, punct_emph_amplifier)
+      pos_sum, neg_sum, neu_count = scores(punct_emph_amplifier)
+      total = (pos_sum + neg_sum.to_f.abs) + neu_count
+
+      {
+        negative: (neg_sum / total.to_f).abs.round(3),
+        neutral: (neu_count / total.to_f).abs.round(3),
+        positive: (pos_sum / total.to_f).abs.round(3),
+        compound: compound.round(4)
+      }
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Prepare scores sum for result calculation
+    def scores(punct_emph_amplifier)
+      # discriminate between positive, negative and neutral sentiment scores
+      pos_sum, neg_sum, neu_count = SentimentScoresSifter.new(@sentiments).call
+
+      if pos_sum > neg_sum.to_f.abs
+        pos_sum += punct_emph_amplifier
+      elsif pos_sum < neg_sum.to_f.abs
+        neg_sum -= punct_emph_amplifier
+      end
+
+      [pos_sum, neg_sum, neu_count]
+    end
+  end
+end

data/lib/vader_sentiment_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  VERSION = '0.1.0'
+end

data/lib/vader_sentiment_ruby/word_helper.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Helper module for word manipulations to simulate pythons methods behavior
+  # word_upcase?(word) is similar to Python's word.isupper()
+  # strip_punctuation(word) is similar to Python's word.strip(string.punctuation)
+  module WordHelper
+    PUNCTUATIONS = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
+
+    class << self
+      # Checks that string contains at least one letter and all letters are in upcase
+      # @param [String] word
+      # @return [Boolean]
+      #
+      # Example
+      #   word_upcase?(':D') # => true
+      #   word_upcase?(':)') # => false
+      def word_upcase?(word)
+        word == word.upcase && word.count('A-Za-z').positive?
+      end
+
+      # Removes all trailing and leading punctuation
+      # If the resulting string has two or fewer characters,
+      # then it was likely an emoticon, so return original string
+      # (ie ':)' stripped would be '', so just return ':)'
+      # @param [String] token
+      # @return [String]
+      #
+      # Example
+      #   strip_punctuation("'test'") # => "test"
+      #   strip_punctuation("'don't'") # => "don't"
+      #   strip_punctuation(":)") # => ":)"
+      def strip_punctuation(token)
+        token_without_punctuation = replace_punctuations(token)
+
+        original_set = token.split('')
+        updated_set = token_without_punctuation.split('')
+
+        pair_array = prepare_match_array(original_set, updated_set)
+        pair_array = clean_leading_punctuations(pair_array)
+        pair_array = clean_trailing_punctuations(pair_array)
+
+        stripped = pair_array.map { |item| item[:old_ch] }.join
+
+        return token if stripped.size <= 2
+
+        stripped
+      end
+
+      private
+
+      def replace_punctuations(token)
+        punctuation_array = PUNCTUATIONS.split('')
+
+        punctuation_array.each do |punctuation|
+          token = token.gsub(punctuation, ' ')
+        end
+
+        token
+      end
+
+      def prepare_match_array(original_set, updated_set)
+        pair_array = []
+        original_set.each_with_index do |item, index|
+          pair_array << { index: index, old_ch: item, new_ch: updated_set[index] }
+        end
+
+        pair_array
+      end
+
+      def clean_leading_punctuations(pair_array)
+        pair_array.map do |pair|
+          break if pair[:new_ch] != ' '
+
+          pair_array.delete_at(pair[:index])
+        end
+
+        pair_array
+      end
+
+      def clean_trailing_punctuations(pair_array)
+        reversed_array = pair_array.reverse
+        reversed_array.map do |pair|
+          break if pair[:new_ch] != ' '
+
+          pair_array.delete_at(pair[:index])
+        end
+
+        pair_array
+      end
+    end
+  end
+end