textstat 0.1.4 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d18721b77b630a224c0515f9618f9c1cf27192a9723c8b5eaad8f3e84ac4e7b
-  data.tar.gz: 237f4f45b6eb32944bcc91542ec8eb2d16c81165855d6db51c287ccdb93b37fd
+  metadata.gz: 61ef6dcf0e938af4c3c30ad4b45c3241f10ffc01e4d63e566a74d993b57309ac
+  data.tar.gz: 20f6412df8d5a8658d4113ddb48e808697b7e1489ba5acb4fae9d97346393acd
 SHA512:
-  metadata.gz: b8ec1aeb8e50394712caf603f947fff09924cc2beb133c26e3b38530a0b338e14dcf3587136746e8d060502ee8ba01f3ba921222ccfabe99c14dadc5b312e773
-  data.tar.gz: 96e23a027c2fded6b414551ed4d9dabc4411f53bd6e9624770d38e49b30aaaac3ffe1f8e28189781b441cd19cb238455e48e5bb351f2aa34906ae5ee7abbcd4d
+  metadata.gz: ef7dee598e3db4c26e2e305f464fbebf6b3757429a72ae66b887ab7f068a34a0d2b6c2e5c52771b2c342e8c06d2ec9a69fa1d60065eaa37b3ccf76eb232f647d
+  data.tar.gz: 5ca1f7c6dcb11a81457b87339ab153ac95125542378875fd451c9ba58659925fc018d38af4bbc61149cb5f8f53765f67363029d8eb698ad80effa969d7ecbbeb

data/lib/textstat/version.rb

@@ -1,3 +1,3 @@
 class TextStat
-  VERSION = "0.1.4"
+  VERSION = "0.1.8"
 end

data/lib/textstat.rb

@@ -23,7 +23,7 @@ class TextStat
     count = 0
     text.split(' ').each do |word|
       word_hyphenated = dictionary.visualise(word)
-      count += [1, word_hyphenated.count('-') + 1].max
+      count += word_hyphenated.count('-') + 1
     end
     count
   end
@@ -33,109 +33,105 @@ class TextStat
   end
 
   def self.avg_sentence_length(text)
-    asl = lexicon_count(text).to_f / sentence_count(text).to_f
+    asl = lexicon_count(text).to_f / sentence_count(text)
     asl.round(1)
   rescue ZeroDivisionError
     0.0
   end
 
-  def self.avg_syllables_per_word(text)
-    syllable = syllable_count(text)
+  def self.avg_syllables_per_word(text, language = 'en_us')
+    syllable = syllable_count(text, language)
     words    = lexicon_count(text)
     begin
-      syllables_per_word = syllable.to_f / words.to_f
-      return syllables_per_word.round(1)
+      syllables_per_word = syllable.to_f / words
+      syllables_per_word.round(1)
     rescue ZeroDivisionError
-      return 0.0
+      0.0
     end
   end
 
   def self.avg_letter_per_word(text)
-    letters_per_word = char_count(text).to_f / lexicon_count(text).to_f
+    letters_per_word = char_count(text).to_f / lexicon_count(text)
     letters_per_word.round(2)
   rescue ZeroDivisionError
     0.0
   end
 
   def self.avg_sentence_per_word(text)
-    sentence_per_word = sentence_count(text).to_f / lexicon_count(text).to_f
+    sentence_per_word = sentence_count(text).to_f / lexicon_count(text)
     sentence_per_word.round(2)
   rescue ZeroDivisionError
     0.0
   end
 
-  def self.flesch_reading_ease(text)
+  def self.flesch_reading_ease(text, language = 'en_us')
     sentence_length    = avg_sentence_length(text)
-    syllables_per_word = avg_syllables_per_word(text)
-    flesch = (
-    206.835 - (1.015 * sentence_length).to_f - (84.6 * syllables_per_word).to_f
-    )
+    syllables_per_word = avg_syllables_per_word(text, language)
+    flesch = 206.835 - 1.015 * sentence_length - 84.6 * syllables_per_word
     flesch.round(2)
   end
 
-  def self.flesch_kincaid_grade(text)
+  def self.flesch_kincaid_grade(text, language = 'en_us')
     sentence_length = avg_sentence_length(text)
-    syllables_per_word = avg_syllables_per_word(text)
-    flesch = (0.39 * sentence_length.to_f) + (11.8 * syllables_per_word.to_f) - 15.59
+    syllables_per_word = avg_syllables_per_word(text, language)
+    flesch = 0.39 * sentence_length + 11.8 * syllables_per_word - 15.59
     flesch.round(1)
   end
 
-  def self.polysyllab_count(text)
+  def self.polysyllab_count(text, language = 'en_us')
     count = 0
     text.split(' ').each do |word|
-      w = syllable_count(word)
+      w = syllable_count(word, language)
       count += 1 if w >= 3
     end
     count
   end
 
-  def self.smog_index(text)
+  def self.smog_index(text, language = 'en_us')
     sentences = sentence_count(text)
 
     if sentences >= 3
       begin
-        polysyllab = polysyllab_count(text)
-        smog = (
-        (1.043 * (30 * (polysyllab / sentences))**0.5) + 3.1291)
-        return smog.round(1)
+        polysyllab = polysyllab_count(text, language)
+        smog = 1.043 * Math.sqrt(30.0 * polysyllab / sentences) + 3.1291
+        smog.round(1)
       rescue ZeroDivisionError
-        return 0.0
+        0.0
       end
     else
-      return 0.0
+      0.0
     end
   end
 
   def self.coleman_liau_index(text)
-    letters   = (avg_letter_per_word(text) * 100).round(2)
+    letters = (avg_letter_per_word(text) * 100).round(2)
     sentences = (avg_sentence_per_word(text) * 100).round(2)
-    coleman   = ((0.058 * letters) - (0.296 * sentences) - 15.8).to_f
+    coleman = 0.0588 * letters - 0.296 * sentences - 15.8
     coleman.round(2)
   end
 
   def self.automated_readability_index(text)
-    chars     = char_count(text)
-    words     = lexicon_count(text)
+    chars = char_count(text)
+    words = lexicon_count(text)
     sentences = sentence_count(text)
     begin
-      a = chars.to_f / words.to_f
-      b = words.to_f / sentences.to_f
+      a = chars.to_f / words
+      b = words.to_f / sentences
 
-      readability = (
-      (4.71 * a.round(2) + (0.5 * b.round(2))) - 21.43)
-      return readability.round(1)
+      readability = 4.71 * a + 0.5 * b - 21.43
+      readability.round(1)
     rescue ZeroDivisionError
-      return 0.0
+      0.0
     end
   end
 
-  def self.linsear_write_formula(text)
+  def self.linsear_write_formula(text, language = 'en_us')
     easy_word = 0
     difficult_word = 0
     text_list = text.split(' ')[0..100]
 
     text_list.each do |word|
-      if syllable_count(word) < 3
+      if syllable_count(word, language) < 3
         easy_word += 1
       else
         difficult_word += 1
@@ -144,11 +140,9 @@ class TextStat
 
     text = text_list.join(' ')
 
-    number = ((easy_word * 1 + difficult_word * 3) / sentence_count(text)).to_f
-    if number <= 20
-      number -= 2
-    end
-    return number / 2
+    number = (easy_word * 1 + difficult_word * 3).to_f / sentence_count(text)
+    number -= 2 if number <= 20
+    number / 2
   end
 
   def self.difficult_words(text, language = 'en_us')
@@ -161,58 +155,70 @@ class TextStat
     text_list = text.downcase.gsub(/[^0-9a-z ]/i, '').split(' ')
     diff_words_set = Set.new
     text_list.each do |value|
-      unless easy_words.include? value
-        if syllable_count(value) > 1
-          diff_words_set.add(value)
-        end
-      end
+      next if easy_words.include? value
+
+      diff_words_set.add(value) if syllable_count(value, language) > 1
     end
-    return diff_words_set.length
+    diff_words_set.length
   end
 
-  def self.dale_chall_readability_score(text)
+  def self.dale_chall_readability_score(text, language = 'en_us')
     word_count = lexicon_count(text)
-    count = word_count - difficult_words(text)
+    count = word_count - difficult_words(text, language)
 
     begin
-      per = count.to_f / word_count.to_f * 100
+      per = 100.0 * count / word_count
     rescue ZeroDivisionError
       return 0.0
     end
 
     difficult_words = 100 - per
-    score = (
-    (0.1579 * difficult_words)
-    + (0.0496 * avg_sentence_length(text)))
+    score = 0.1579 * difficult_words + 0.0496 * avg_sentence_length(text)
+    score += 3.6365 if difficult_words > 5
 
-    if difficult_words > 5
-      score += 3.6365
-    end
-    return score.round(2)
+    score.round(2)
   end
 
-  def self.gunning_fog(text)
-    begin
-      per_diff_words = (
-      (difficult_words(text) / lexicon_count(text) * 100) + 5)
+  def self.gunning_fog(text, language = 'en_us')
+    per_diff_words = 100.0 * difficult_words(text, language) / lexicon_count(text) + 5
+    grade = 0.4 * (avg_sentence_length(text) + per_diff_words)
 
-      grade = 0.4 * (avg_sentence_length(text) + per_diff_words)
-      return grade.round(2)
-    rescue ZeroDivisionError
-      return 0.0
-    end
+    grade.round(2)
+  rescue ZeroDivisionError
+    0.0
   end
 
   def self.lix(text)
     words = text.split(' ')
     words_length = words.length
-    long_words = words.select { |word| word.length > 6 }.count
+    long_words = words.count { |word| word.length > 6 }
 
-    per_long_words = (long_words * 100).to_f / words_length
+    per_long_words = 100.0 * long_words / words_length
     asl = avg_sentence_length(text)
     lix = asl + per_long_words
 
-    return lix.round(2)
+    lix.round(2)
+  end
+
+  def self.forcast(text, language = 'en_us')
+    words = text.split(' ')[0..149]
+    words_with_one_syllabe = words.count {
+      |word| syllable_count(word, language) == 1
+    }
+    forcast = 20 - (words_with_one_syllabe / 10)
+    forcast
+  end
+
+  def self.powers_sumner_kearl(text, language = 'en_us')
+    grade = 0.0778 * avg_sentence_length(text) + 0.0455 * syllable_count(text, language) - 2.2029
+    grade.round(2)
+  end
+
+  def self.spache(text, language = 'en_us')
+    words = text.split(' ').count
+    unfamiliar_words = difficult_words(text, language) / words
+    grade = (0.141 * avg_sentence_length(text)) + (0.086 * unfamiliar_words) + 0.839
+    grade.round(2)
   end
 
   def self.text_standard(text, float_output=nil)
@@ -287,9 +293,9 @@ class TextStat
     score = final_grade[0][0]
 
     if float_output
-      return score.to_f
+      score.to_f
     else
-      return "#{score.to_i - 1}th and #{score.to_i}th grade"
+      "#{score.to_i - 1}th and #{score.to_i}th grade"
     end
   end
 

data/spec/textstat_spec.rb

@@ -116,22 +116,22 @@ describe TextStat do
 
     it 'should return the correct smog index' do
       index = TextStat.smog_index(@long_test)
-      expect(index).to eql 11.2
+      expect(index).to eql 12.5
     end
 
     it 'should return the correct Coleman–Liau index' do
       index = TextStat.coleman_liau_index(@long_test)
-      expect(index).to eql 10.28
+      expect(index).to eql 10.65
     end
 
     it 'should return the correct automated readability index' do
       index = TextStat.automated_readability_index(@long_test)
-      expect(index).to eql 12.3
+      expect(index).to eql 12.4
     end
 
     it 'should return the correct linsear write formula result' do
       result = TextStat.linsear_write_formula(@long_test)
-      expect(result).to eql 14.5
+      expect(result).to eql 14.875
     end
 
     it 'should return the correct difficult words result' do
@@ -141,12 +141,12 @@ describe TextStat do
 
     it 'should return the correct Dale–Chall readability score' do
       score = TextStat.dale_chall_readability_score(@long_test)
-      expect(score).to eql 4.79
+      expect(score).to eql 7.25
     end
 
     it 'should return the correct Gunning fog score' do
       score = TextStat.gunning_fog(@long_test)
-      expect(score).to eql 11.32
+      expect(score).to eql 17.56
     end
 
     it 'should return the correct Lix readability test score' do
@@ -154,6 +154,21 @@ describe TextStat do
       expect(score).to eql 45.11
     end
 
+    it 'should return the correct FORCAST readability test score' do
+      score = TextStat.forcast(@long_test)
+      expect(score).to eql 10
+    end
+
+    it 'should return the correct Powers Sumner Kearl readability test score' do
+      score = TextStat.powers_sumner_kearl(@long_test)
+      expect(score).to eql 25.04
+    end
+
+    it 'should return the correct SPACHE readability test score' do
+      score = TextStat.spache(@long_test)
+      expect(score).to eql 4.12
+    end
+
     it 'should return the readability consensus score' do
       standard = TextStat.text_standard(@long_test)
       expect(standard).to eql '10th and 11th grade'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: textstat
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.8
 platform: ruby
 authors:
 - Jakub Polak
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-11 00:00:00.000000000 Z
+date: 2022-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: text-hyphen
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.0.pre1
+rubygems_version: 3.2.17
 signing_key: 
 specification_version: 4
 summary: Ruby gem to calculate readability statistics of a text object - paragraphs,