vader_sentiment_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 57fb7693c238e33224556fb6a2d7d8c479ed88d76cd6576edef5c8befe4ad144
+  data.tar.gz: 8fc4484045923da3ec6986b8dbbf39f41437c635a25dbfdd14c0973baebe271b
+SHA512:
+  metadata.gz: 127836bbe570da1cd60082da181d22e4a3619d32300d8e16dfc9aa9a3fcbbc0b3d51ad0e1b4c8e1143879f4b51f6e70a047590468af7c7de260468ddb7987ab9
+  data.tar.gz: 94d770a25884484554c2dce05607c68bda7742482d883d18c2cf693c979a31085189fec042f78b7303e6b13e0b75f13c0c09ee7e39f5d756787cde27db0a6102

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 N. Bulavin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# VaderSentimentRuby
+
+VADER (Valence Aware Dictionary and sEntiment Reasoner) is a lexicon and rule-based sentiment analysis tool that is specifically attuned to sentiments expressed in social media.
+
+This is a port of [VADER sentiment analysis tool](https://github.com/cjhutto/vaderSentiment) originally written in Python. If you'd like to make a contribution, please checkout the original author's work.
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'vader_sentiment_ruby'
+```
+And then execute:
+```ruby
+bundle install
+```
+Or install it yourself as:
+```ruby
+gem install vader_sentiment_ruby
+```
+## Usage
+```ruby
+require 'vader_sentiment_ruby'
+
+VaderSentimentRuby.polarity_scores('VADER is smart, handsome, and funny.')
+# => {:negative=>0.0, :neutral=>0.254, :positive=>0.746, :compound=>0.8316}
+```
+
+## About the Scoring
+The compound score is computed by summing the valence scores of each word in the lexicon, adjusted according to the rules, and then normalized to be between -1 (most extreme negative) and +1 (most extreme positive). This is the most useful metric if you want a single unidimensional measure of sentiment for a given sentence. Calling it a 'normalized, weighted composite score' is accurate.
+
+It is also useful for researchers who would like to set standardized thresholds for classifying sentences as either positive, neutral, or negative. Typical threshold values (used in the literature cited on this page) are:
+
+    positive sentiment: compound score >= 0.05
+    neutral sentiment: (compound score > -0.05) and (compound score < 0.05)
+    negative sentiment: compound score <= -0.05
+
+The pos, neu, and neg scores are ratios for proportions of text that fall in each category (so these should all add up to be 1... or close to it with float operation). These are the most useful metrics if you want multidimensional measures of sentiment for a given sentence.
+
+## Citation Information
+If you use either the dataset or any of the VADER sentiment analysis tools (VADER sentiment lexicon or Rust code for rule-based sentiment analysis engine) in your research, please cite the above paper. For example:
+
+> Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
+
+For questions, please contact: C.J. Hutto Georgia Institute of Technology, Atlanta, GA 30032
+cjhutto [at] gatech [dot] edu
+
+## License
+The original source code is copyright © 2013 C.J. Hutto
+
+This port gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/vader_sentiment_ruby.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# VaderSentimentRuby namespace
+module VaderSentimentRuby
+  autoload(:Constants, 'vader_sentiment_ruby/constants')
+  autoload(:WordHelper, 'vader_sentiment_ruby/word_helper')
+  autoload(:LexiconDictionaryCreator, 'vader_sentiment_ruby/lexicon_dictionary_creator')
+  autoload(:EmojisDictionaryCreator, 'vader_sentiment_ruby/emojis_dictionary_creator')
+  autoload(:PunctuationEmphasisAmplifier, 'vader_sentiment_ruby/punctuation_emphasis_amplifier')
+  autoload(:SentimentScoresSifter, 'vader_sentiment_ruby/sentiment_scores_sifter')
+  autoload(:SentimentIntensityAnalyzer, 'vader_sentiment_ruby/sentiment_intensity_analyzer')
+  autoload(:ValenceScoreCalculator, 'vader_sentiment_ruby/valence_score_calculator')
+  autoload(:EmojiDescriber, 'vader_sentiment_ruby/emojis_describer')
+  autoload(:SentimentPropertiesIdentifier, 'vader_sentiment_ruby/sentiment_properties_identifier')
+  autoload(:Checker, 'vader_sentiment_ruby/checker')
+
+  def self.polarity_scores(text)
+    VaderSentimentRuby::SentimentIntensityAnalyzer.new.polarity_scores(text)
+  end
+end

data/lib/vader_sentiment_ruby/checker.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  # Used only for checkers autoload
+  module Checker
+    autoload(:ButWordNegationChecker, 'vader_sentiment_ruby/checker/but_word_negation_checker')
+    autoload(:LeastWordNegationChecker, 'vader_sentiment_ruby/checker/least_word_negation_checker')
+    autoload(:NegationChecker, 'vader_sentiment_ruby/checker/negation_checker')
+    autoload(:NoWordChecker, 'vader_sentiment_ruby/checker/no_word_checker')
+    autoload(:PreviousWordsInfluenceChecker, 'vader_sentiment_ruby/checker/previous_words_influence_checker')
+    autoload(:SpecialIdiomsChecker, 'vader_sentiment_ruby/checker/special_idioms_checker')
+  end
+end

data/lib/vader_sentiment_ruby/checker/but_word_negation_checker.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  module Checker
+    # Checks for modification in sentiment due to contrastive conjunction 'but'
+    class ButWordNegationChecker
+      def initialize(words_and_emoticons, sentiments)
+        @words_and_emoticons_lower = words_and_emoticons.map { |w| w.to_s.downcase }
+        @sentiments = sentiments
+      end
+
+      def call
+        return @sentiments unless @words_and_emoticons_lower.include?('but')
+
+        but_index = @words_and_emoticons_lower.index('but')
+        updated_sentiments = []
+        @sentiments.each_with_index do |sentiment, senti_index|
+          updated_sentiments << modified_sentiment(sentiment, senti_index, but_index)
+        end
+
+        updated_sentiments
+      end
+
+      private
+
+      def modified_sentiment(sentiment, senti_index, but_index)
+        return sentiment * 0.5 if senti_index < but_index
+        return sentiment * 1.5 if senti_index > but_index
+
+        sentiment
+      end
+    end
+  end
+end

data/lib/vader_sentiment_ruby/checker/least_word_negation_checker.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  module Checker
+    # Checks for negation case using "least"
+    class LeastWordNegationChecker
+      def initialize(valence, words_and_emoticons, index, lexicon)
+        @valence = valence
+        @words_and_emoticons = words_and_emoticons
+        @index = index
+        @lexicon = lexicon
+      end
+
+      def call
+        valence = @valence
+        return valence unless !word_in_lexicon?(@index - 1) && word_is?(@index - 1, 'least')
+
+        if @index > 1
+          valence *= Constants::N_SCALAR if !word_is?(@index - 2, 'at') && !word_is?(@index - 2, 'very')
+        elsif @index.positive?
+          valence *= Constants::N_SCALAR
+        end
+
+        valence
+      end
+
+      private
+
+      def word_in_lexicon?(index)
+        @lexicon.keys.include?(@words_and_emoticons[index].downcase)
+      end
+
+      def word_is?(index, word)
+        @words_and_emoticons[index].downcase == word
+      end
+    end
+  end
+end

data/lib/vader_sentiment_ruby/checker/negation_checker.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  module Checker
+    # Checks for negation
+    class NegationChecker
+      # @param [Float] valence
+      # @param [Array(String)] words_and_emoticons
+      # @param [Integer] start_index
+      # @param [Integer] index
+      def initialize(valence, words_and_emoticons, start_index, index)
+        @valence = valence
+        @words_and_emoticons_lower = words_and_emoticons.map { |word| word.to_s.downcase }
+        @start_index = start_index
+        @index = index
+      end
+
+      # @return [Float]
+      def call
+        valence = @valence
+        valence = check_zero_index(valence) if @start_index.zero?
+        valence = check_first_index(valence) if @start_index == 1
+        valence = check_second_index(valence) if @start_index == 2
+
+        valence
+      end
+
+      private
+
+      def check_zero_index(valence)
+        # 1 word preceding lexicon word (w/o stopwords)
+        return valence unless negated?([@words_and_emoticons_lower[@index - (@start_index + 1)]])
+
+        valence * Constants::N_SCALAR
+      end
+
+      def check_first_index(valence)
+        return valence * 1.25 if word_is_never?(-2) && (word_is_so?(-1) || word_is_this?(-1))
+        return valence if word_is_without?(-2) && word_is_doubt?(-1)
+
+        if negated?([@words_and_emoticons_lower[@index - (@start_index + 1)]])
+          # 2 words preceding the lexicon word position
+          return valence * Constants::N_SCALAR
+        end
+
+        valence
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def check_second_index(valence)
+        if word_is_never?(-3) &&
+           (word_is_so?(-2) || word_is_this?(-2)) ||
+           (word_is_so?(-1) || word_is_this?(-1))
+          return valence * 1.25
+        elsif word_is_without?(-3) && (word_is_doubt?(-2) || word_is_doubt?(-1))
+          return valence
+        elsif negated?([@words_and_emoticons_lower[@index - (@start_index + 1)]])
+          # 3 words preceding the lexicon word position
+          return valence * Constants::N_SCALAR
+        end
+
+        valence
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # Determine if input contains negation words
+      def negated?(input_words, include_nt: true)
+        input_words = input_words.map { |w| w.to_s.downcase }
+        Constants::NEGATE.each do |word|
+          return true if input_words.include?(word)
+        end
+
+        if include_nt
+          input_words.each do |word|
+            return true if word.include?("n't")
+          end
+        end
+
+        # if input_words.include?('least')
+        #   index = input_words.index('least')
+        #   return true if index.positive? && input_words[index - 1] != 'at'
+        # end
+
+        false
+      end
+
+      def word_is_never?(index_shift)
+        word_is?(index_shift, 'never')
+      end
+
+      def word_is_so?(index_shift)
+        word_is?(index_shift, 'so')
+      end
+
+      def word_is_this?(index_shift)
+        word_is?(index_shift, 'this')
+      end
+
+      def word_is_without?(index_shift)
+        word_is?(index_shift, 'without')
+      end
+
+      def word_is_doubt?(index_shift)
+        word_is?(index_shift, 'doubt')
+      end
+
+      def word_is?(index_shift, word)
+        @words_and_emoticons_lower[@index + index_shift].downcase == word
+      end
+    end
+  end
+end

data/lib/vader_sentiment_ruby/checker/no_word_checker.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  module Checker
+    # Check for "no" as negation for an adjacent lexicon item vs "no" as its own stand-alone lexicon item
+    class NoWordChecker
+      # @param [Float] valence
+      # @param [String] item_lowercase
+      # @param [Integer] index
+      # @param [Array] words_and_emoticons
+      # @param [Hash] lexicon
+      def initialize(valence, item_lowercase, index, words_and_emoticons, lexicon)
+        @valence = valence
+        @item_lowercase = item_lowercase
+        @index = index
+        @words_and_emoticons = words_and_emoticons
+        @lexicon = lexicon
+      end
+
+      # @return [Float]
+      def call
+        valence = @valence
+
+        if @item_lowercase == 'no' &&
+           @index != @words_and_emoticons.size - 1 &&
+           @lexicon.keys.include?(@words_and_emoticons[@index + 1].downcase)
+          # don't use valence of "no" as a lexicon item. Instead set it's valence to 0.0 and negate the next item
+          valence = 0.0
+        end
+
+        valence = @lexicon[@item_lowercase] * Constants::N_SCALAR if one_of_preceding_words_is_no?
+
+        valence
+      end
+
+      private
+
+      def one_of_preceding_words_is_no?
+        preceding_word_is_no?(0) ||
+          preceding_word_is_no?(1) ||
+          (preceding_word_is_no?(2) && %w[or nor].include?(@words_and_emoticons[@index - 1].downcase))
+      end
+
+      def preceding_word_is_no?(distance)
+        @index > distance && @words_and_emoticons[@index - (distance + 1)].downcase == 'no'
+      end
+    end
+  end
+end

data/lib/vader_sentiment_ruby/checker/previous_words_influence_checker.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  module Checker
+    # Checks if the preceding words increase, decrease, or negate/nullify the valence
+    class PreviousWordsInfluenceChecker
+      # @param [String] word
+      # @param [Float] valence
+      # @param [Boolean] is_cap_diff
+      def initialize(word, valence, is_cap_diff)
+        @word = word
+        @word_lower = word.downcase
+        @valence = valence
+        @is_cap_diff = is_cap_diff
+        @scalar = 0.0
+      end
+
+      # @return [Float]
+      def call
+        return @scalar unless word_in_booster_dictionary?
+
+        take_scalar_from_dictionary
+        @scalar *= -1 if @valence.negative?
+        amplify_scalar_by_word_case
+
+        @scalar
+      end
+
+      private
+
+      def word_in_booster_dictionary?
+        Constants::BOOSTER_DICT.keys.include?(@word_lower)
+      end
+
+      def take_scalar_from_dictionary
+        @scalar = Constants::BOOSTER_DICT[@word_lower]
+      end
+
+      def amplify_scalar_by_word_case
+        # Check if booster/dampener word is in ALLCAPS (while others aren't)
+        return unless WordHelper.word_upcase?(@word) && @is_cap_diff
+
+        amplified_scalar
+      end
+
+      def amplified_scalar
+        if @valence.positive?
+          @scalar += Constants::C_INCR
+        else
+          @scalar -= Constants::C_INCR
+        end
+      end
+    end
+  end
+end

data/lib/vader_sentiment_ruby/checker/sentiment_laden_idioms_checker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module VaderSentimentRuby
+  module Checker
+    # Not implemented
+    # check for sentiment laden idioms that don't contain a lexicon word
+    class SentimentLadenIdiomsChecker
+      def initialize(valence, senti_text_lower)
+        @valence = valence
+        @senti_text_lower = senti_text_lower
+      end
+
+      def call
+        idioms_valences = []
+        valence = @valence
+
+        Constants::SENTIMENT_LADEN_IDIOMS.each do |idiom|
+          next unless @senti_text_lower.include?(idiom)
+
+          valence = Constants::SENTIMENT_LADEN_IDIOMS[idiom]
+          idioms_valences.push(valence)
+        end
+
+        valence = idioms_valences.sum / idioms_valences.size.to_f if idioms_valences.size.positive?
+
+        valence
+      end
+    end
+  end
+end