odyssey 0.1.8

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in odyssey.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Cameron Sutter
+
+MIT License
+
+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,96 @@
+# Odyssey
+
+Odyssey is an extendible text analyzing gem that outputs the readability score of text. It has several of the common readability formulas available, but defaults to the Flesch-Kincaid Reading Ease score.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'odyssey'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install odyssey
+
+## Usage
+
+    require 'odyssey'
+
+    Odyssey.formula_name(text, all_stats)
+
+Example:
+
+    Odyssey.flesch_kincaid_re("See Spot run.", true)
+
+if all_stats is false, this returns a simple score. If it is true, it returns a Hash:
+
+
+    {
+      'name'                       => String,
+      'formula'                    => formula_class,
+      'score'                      => Float,
+      'string_length'              => Fixnum,
+      'letter_count'               => Fixnum,
+      'syllable_count'             => Fixnum,
+      'word_count'                 => Fixnum,
+      'sentence_count'             => Fixnum,
+      'average_words_per_sentence' => Float,
+      'average_syllables_per_word' => Float
+    }
+
+
+##Extending Odyssey
+
+To extend Odyssey, you can create a class that inherits from Formula.
+
+    class Cool_new_formula < Formula
+
+      def score(text, stats)
+
+      end
+
+      def name
+        "Cool new formula"
+      end
+    end
+
+text will be a Hash like so:
+
+    data = {
+      'raw' => String,
+      'words' => Array,
+      'sentences' => Array,
+      'syllables' => Array
+    }
+
+stats will be a Hash like so:
+
+    {
+      'string_length' => Fixnum,
+      'letter_count' => Fixnum,
+      'syllable_count' => Fixnum,
+      'word_count' => Fixnum,
+      'sentence_count' => Fixnum,
+      'average_words_per_sentence' => Float,
+      'average_syllables_per_word' => Float
+    }
+
+That is all you need.
+To call your formula you just use 
+
+    Odyssey.cool_new_formula('See Spot run.', true)
+
+Because you have access to the formula's class (when the 'all_stats' flag is true),
+you have access to any other methods or class variables.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+
+Rake::TestTask.new do |t|
+ t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :spec

data/lib/formulas/ari.rb

@@ -0,0 +1,14 @@
+class Automated_readability < Formula
+
+  def score(text, stats)
+    calc_score(stats['letter_count'], stats['word_count'], stats['sentence_count'])
+  end
+
+  def calc_score(letter_count, word_count, sentence_count)
+    (((4.71 * (letter_count.to_f / word_count.to_f)) + (0.5 * (word_count.to_f / sentence_count.to_f))) - 21.43).round(1)
+  end
+
+  def name
+    'Automated Readability Index'
+  end
+end

data/lib/formulas/coleman_liau.rb

@@ -0,0 +1,14 @@
+class Coleman_liau < Formula
+
+  def score(text, stats)
+    calc_score(stats['letter_count'], stats['word_count'], stats['sentence_count'])
+  end
+
+  def calc_score(letter_count, word_count, sentence_count)
+    ((5.89 * (letter_count.to_f / word_count.to_f)) - (0.3 * (sentence_count.to_f / word_count.to_f)) - 15.8).round(1)
+  end
+
+  def name
+    'Coleman-Liau Index'
+  end
+end

data/lib/formulas/fake_formula.rb

@@ -0,0 +1,10 @@
+class Fake_formula < Formula
+
+  def score(text, stats)
+    text
+  end
+
+  def name
+    "It's fake"
+  end
+end

data/lib/formulas/flesch_kincaid_gl.rb

@@ -0,0 +1,14 @@
+class Flesch_kincaid_GL < Formula
+
+  def score(text, stats)
+    calc_score(stats['average_words_per_sentence'], stats['average_syllables_per_word'])
+  end
+
+  def calc_score(avg_words, avg_syllables)
+    (((0.39 * avg_words) + (11.8 * avg_syllables)) - 15.59).round(1)
+  end
+
+  def name
+    'Flesch-Kincaid Grade Level'
+  end
+end

data/lib/formulas/flesch_kincaid_re.rb

@@ -0,0 +1,14 @@
+class Flesch_kincaid_RE < Formula
+
+  def score(text, stats)
+    calc_score(stats['average_words_per_sentence'], stats['average_syllables_per_word'])
+  end
+
+  def calc_score(avg_words, avg_syllables)
+    ((206.835 - (1.015 * avg_words)) - (84.6 * avg_syllables)).round(1)
+  end
+
+  def name
+    'Flesch-Kincaid Reading Ease'
+  end
+end

data/lib/formulas/formula.rb

@@ -0,0 +1,29 @@
+class Formula
+
+  # text will be a Hash like so:
+  # data = {
+  #   'raw' => String,
+  #   'words' => Array,
+  #   'sentences' => Array,
+  #   'syllables' => Array
+  # }
+  # 
+  # stats will be a Hash like so:
+  # {
+  #   'string_length' => Fixnum,
+  #   'letter_count' => Fixnum,
+  #   'syllable_count' => Fixnum,
+  #   'word_count' => Fixnum,
+  #   'sentence_count' => Fixnum,
+  #   'average_words_per_sentence' => Float,
+  #   'average_syllables_per_word' => Float
+  # }
+
+  def score(text, stats)
+    0
+  end
+
+  def name
+    'Generic'
+  end
+end

data/lib/formulas/gunning_fog.rb

@@ -0,0 +1,24 @@
+class Gunning_fog < Formula
+
+  def score(text, stats)
+    percent = three_syllables(stats['word_count'], text['syllables'])
+    calc_score(stats['average_words_per_sentence'], percent)
+  end
+
+  #percentage of words with three syllables
+  def three_syllables(word_count, syllables)
+    with_three = 0
+    syllables.each do |s|
+      with_three += 1 if s > 2
+    end
+    (with_three / word_count) * 100
+  end
+
+  def calc_score(avg_words, percent_with_three)
+    ((avg_words + percent_with_three) * 0.4).round(1)
+  end
+
+  def name
+    'Gunning-Fog Score'
+  end
+end

data/lib/formulas/smog.rb

@@ -0,0 +1,23 @@
+class Smog < Formula
+
+  def score(text, stats)
+    with_three = three_syllables(text['syllables'])
+    calc_score(stats['sentence_count'], with_three)
+  end
+
+  def three_syllables(syllables)
+    with_three = 0
+    syllables.each do |s|
+      with_three += 1 if s > 2
+    end
+    with_three
+  end
+
+  def calc_score(sentence_count, with_three)
+    (1.043 * Math.sqrt(with_three * (30.0 / sentence_count)) + 3.1291).round(1)
+  end
+
+  def name
+    'SMOG Index'
+  end
+end

data/lib/odyssey.rb

@@ -0,0 +1,74 @@
+require "odyssey/version"
+
+module Odyssey
+
+  DEFAULT_FORMULA = 'Flesch_kincaid_RE'
+
+  #main method
+  def self.analyze(text, formula_name = DEFAULT_FORMULA, all_stats = false)
+    #catch nils
+    formula_name = DEFAULT_FORMULA if formula_name == nil
+    
+    @engine = Odyssey::Engine.new(formula_name)
+    score = @engine.score(text)
+    
+    #return all stats?
+    if all_stats
+      output = @engine.get_stats
+    else
+      output = score
+    end
+
+    output
+  end
+
+  #run whatever method was given as if it were a shortcut to a formula
+  def self.method_missing(*args)
+    method_string = args[0].to_s
+
+    #capitalize the first letter
+    first_letter = method_string[0].upcase
+    method_string[0] = first_letter
+
+    #send to the main method
+    analyze(args[1], method_string, args[2] || false)
+  end
+
+  #define this here, so it doesn't get sent to method_missing()
+  def self.to_ary
+    []
+  end
+
+  #######################################################
+  # pre-built methods that act as shortcuts to formulas #
+  #######################################################
+  
+  def self.flesch_kincaid_reading_ease(text, all_stats = false)
+    analyze(text, 'Flesch_kincaid_RE', all_stats)
+  end
+
+  def self.flesch_kincaid_grade_level(text, all_stats = false)
+    analyze(text, 'Flesch_kincaid_GL', all_stats)
+  end
+
+  def self.gunning_fog(text, all_stats = false)
+    analyze(text, 'Gunning_fog', all_stats)
+  end
+
+  def self.coleman_liau(text, all_stats = false)
+    analyze(text, 'Coleman_liau', all_stats)
+  end
+
+  def self.smog(text, all_stats = false)
+    analyze(text, 'Smog', all_stats)
+  end
+
+  def self.ari(text, all_stats = false)
+    analyze(text, 'Automated_readability', all_stats)
+  end
+
+end
+
+require 'require_all'
+require 'odyssey/engine'
+require_rel 'formulas'

data/lib/odyssey/engine.rb

@@ -0,0 +1,146 @@
+module Odyssey
+  class Engine
+
+    #class variables
+    @formula
+    @score
+    @stats
+    @words
+    @sentences
+    @syllables
+
+    #regex
+    LETTER_REGEX = /[A-z]/
+    WORD_REGEX = /[^\W][A-z\-']*/
+    SENTENCE_REGEX = /[^\.!?\s][^\.!?]*(?:[\.!?](?!['"]?\s|$)[^\.!?]*)*[\.!?]?['"]?(?=\s|$)/
+
+    #words that cause the syllable analyzer to fail
+    # word => syllables
+    PROBLEM_WORDS = {
+      'ion'    => 2
+    }
+
+    def initialize(formula_name)
+      reset
+      klass = Module.const_get formula_name
+      @formula = klass.new
+    rescue
+      @formula = Formula.new
+    end
+
+    def score(_text)
+      #sanitize the text
+      text = sanitize(_text)
+
+      #first get all the statistics
+      @stats = {
+        'string_length' => string_length(text),
+        'letter_count' => letter_count(text),
+        'word_count' => word_count(text),
+        'syllable_count' => syllable_count(text),
+        'sentence_count' => sentence_count(text),
+      }
+      
+      @stats['average_words_per_sentence'] = average_words_per_sentence(text)
+      @stats['average_syllables_per_word'] = average_syllables_per_word(text)
+
+      #prepare the parameter to the score method
+      data = {
+        'raw' => text,
+        'words' => @words,
+        'sentences' => @sentences,
+        'syllables' => @syllables
+      }
+
+      #now run all that through the formula
+      @score = @formula.score(data, @stats)
+    end
+
+    def string_length(text)
+      text.length
+    end
+
+    def letter_count(text)
+      matches = text.scan LETTER_REGEX
+      matches.size
+    end
+
+    def syllable_count(text)
+      count = 0
+      @words.each do |w|
+        num = analyze_syllables(w)
+        count += num
+        @syllables << num
+      end
+      count
+    end
+
+    def word_count(text)
+      @words = text.scan WORD_REGEX
+      @words.size
+    end
+
+    def sentence_count(text)
+      @sentences = text.scan SENTENCE_REGEX
+      @sentences.size
+    end
+
+    def average_words_per_sentence(text)
+      @stats['word_count'].to_f / @stats['sentence_count'].to_f
+    end
+
+    def average_syllables_per_word(text)
+      @stats['syllable_count'].to_f / @stats['word_count'].to_f
+    end
+
+    # for now this just removes html tags
+    # but it could do more in the future
+    def sanitize(text)
+      output = text.gsub(/<\/?[^>]+>/, '')
+    end
+
+    def analyze_syllables(_word)
+      #remove non-alpha characters
+      word = _word.gsub(/[^A-z]/, '')
+      count = 0
+
+      if PROBLEM_WORDS.has_key?(word)
+        count = PROBLEM_WORDS[word]
+      else
+        #this is an approximation, but it is fairly close
+        word.downcase!
+        return 1 if word.length <= 3
+        word.sub!(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, '')
+        word.sub!(/^y/, '')
+        count = word.scan(/[aeiouy]{1,2}/).size
+      end
+
+      count
+    end
+
+    def get_stats
+      { 
+        'name'           => @formula.name,
+        'formula'        => @formula,
+        'score'          => @score,
+        'string_length'  => @stats['string_length'],
+        'letter_count'   => @stats['letter_count'],
+        'syllable_count' => @stats['syllable_count'],
+        'word_count'     => @stats['word_count'],
+        'sentence_count' => @stats['sentence_count'],
+        'average_words_per_sentence' => @stats['average_words_per_sentence'],
+        'average_syllables_per_word' => @stats['average_syllables_per_word']
+      }
+    end
+
+    def reset
+      @formula = nil
+      @score = 0
+      @stats = {}
+      @words = nil
+      @sentences = nil
+      @syllables = []
+    end
+
+  end
+end

data/lib/odyssey/version.rb

@@ -0,0 +1,3 @@
+module Odyssey
+  VERSION = "0.1.8"
+end

data/odyssey.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'odyssey/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "odyssey"
+  spec.version       = Odyssey::VERSION
+  spec.authors       = ["Cameron Sutter"]
+  spec.email         = ["cameronsutter0@gmail.com"]
+  spec.description   = %q{Odyssey is an extendible text analyzing gem that outputs the readability score of text. It has several of the common readability formulas available, but defaults to the Flesch-Kincaid Reading Ease score.}
+  spec.summary       = %q{Text readability analyzer using Flesch-Kincaid and others}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.add_dependency "require_all"
+
+  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.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/odyssey_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe Odyssey do
+
+  context 'default formula' do
+    it 'should return something' do
+      result = Odyssey.analyze one_simple_sentence
+      result.should_not be_nil
+    end
+
+    describe 'get all stats' do
+      before :all do
+        @simple = Odyssey.analyze one_simple_sentence, nil, true
+        @double = Odyssey.analyze two_simple_sentences, nil, true
+      end
+
+      it 'should return formula name' do
+        @simple['name'].should == 'Flesch-Kincaid Reading Ease'
+      end
+
+      it 'should return score' do
+        @simple['score'].should == 119.2
+      end
+
+      it 'should return the formula' do
+        @simple['formula'].class.to_s.should == 'Flesch_kincaid_RE'
+      end
+
+      it 'should return string length' do
+        @simple['string_length'].should == 13
+      end
+
+      it 'should return letter count' do
+        @simple['letter_count'].should == 10
+      end
+
+      it 'should return syllable count' do
+        @simple['syllable_count'].should == 3
+      end
+
+      it 'should return word count' do
+        @simple['word_count'].should == 3
+
+        @double['word_count'].should == 6
+      end
+
+      it 'should return sentence count' do
+        @simple['sentence_count'].should == 1
+
+        @double['sentence_count'].should == 2
+      end
+
+      it 'should return average words per sentence' do
+        @simple['average_words_per_sentence'].should == 3
+
+        @double['average_words_per_sentence'].should == 3
+      end
+
+      it 'should return average syllables per word' do
+        @simple['average_syllables_per_word'].should == 1
+
+        @double['average_syllables_per_word'].should == 1
+      end
+
+    end
+  end
+
+  context 'Flesch-Kincaid Reading Ease' do
+
+    describe 'get score' do
+      before :all do
+        @simple = Odyssey.flesch_kincaid_reading_ease one_simple_sentence
+        @double = Odyssey.flesch_kincaid_reading_ease two_simple_sentences
+        @complex = Odyssey.flesch_kincaid_reading_ease one_complex_sentence
+        @complex_double = Odyssey.flesch_kincaid_reading_ease two_complex_sentences
+      end
+
+      it 'should return something' do
+        @simple.should_not be_nil
+      end
+
+      it 'should return the score' do
+        @simple.should == 119.2
+        @double.should == 119.2
+        @complex.should == 94.3
+        @complex_double.should == 88.7
+      end
+    end
+
+  end
+
+  context 'Flesch-Kincaid Grade Level' do
+
+    describe 'get score' do
+      before :all do
+        @simple = Odyssey.flesch_kincaid_grade_level one_simple_sentence
+        @double = Odyssey.flesch_kincaid_grade_level two_simple_sentences
+        @complex = Odyssey.flesch_kincaid_grade_level one_complex_sentence
+        @complex_double = Odyssey.flesch_kincaid_grade_level two_complex_sentences
+      end
+
+      it 'should return something' do
+        @simple.should_not be_nil
+      end
+
+      it 'should return the score' do
+        @simple.should == -2.6
+        @double.should == -2.6
+        @complex.should == 2.3
+        @complex_double.should == 3
+      end
+    end
+
+  end
+
+  context 'Gunning-Fog Score' do
+
+    describe 'get score' do
+      before :all do
+        @simple = Odyssey.gunning_fog one_simple_sentence
+        @double = Odyssey.gunning_fog two_simple_sentences
+        @complex = Odyssey.gunning_fog one_complex_sentence
+        @complex_double = Odyssey.gunning_fog two_complex_sentences
+      end
+
+      it 'should return something' do
+        @simple.should_not be_nil
+      end
+
+      it 'should return the score' do
+        @simple.should == 1.2
+        @double.should == 1.2
+        @complex.should == 3.6
+        @complex_double.should == 3.4
+      end
+    end
+
+  end
+
+  context 'Coleman-Liau Index' do
+
+    describe 'get score' do
+      before :all do
+        @simple = Odyssey.coleman_liau one_simple_sentence
+        @double = Odyssey.coleman_liau two_simple_sentences
+        @complex = Odyssey.coleman_liau one_complex_sentence
+        @complex_double = Odyssey.coleman_liau two_complex_sentences
+        @very_complex = Odyssey.coleman_liau very_complex
+      end
+
+      it 'should return something' do
+        @simple.should_not be_nil
+      end
+
+      it 'should return the score' do
+        @simple.should == 3.7
+        @double.should == 4.7
+        @complex.should == 7.1
+        @complex_double.should == 9.1
+        @very_complex.should == 10.7
+      end
+    end
+
+  end
+
+  context 'SMOG Index' do
+
+    describe 'get score' do
+      before :all do
+        @simple = Odyssey.smog one_simple_sentence
+        @double = Odyssey.smog two_simple_sentences
+        @complex = Odyssey.smog one_complex_sentence
+        @complex_double = Odyssey.smog two_complex_sentences
+        @very_complex = Odyssey.smog very_complex
+      end
+
+      it 'should return something' do
+        @simple.should_not be_nil
+      end
+
+      it 'should return the score' do
+        @simple.should == 1.8
+        @double.should == 1.8
+        @complex.should == 1.8
+        @complex_double.should == 1.8
+        @very_complex.should == 10.1
+      end
+    end
+
+  end
+
+  context 'Automated Readability Index' do
+
+    describe 'get score' do
+      before :all do
+        @simple = Odyssey.ari one_simple_sentence
+        @double = Odyssey.ari two_simple_sentences
+        @complex = Odyssey.ari one_complex_sentence
+        @complex_double = Odyssey.ari two_complex_sentences
+        @very_complex = Odyssey.ari very_complex
+      end
+
+      it 'should return something' do
+        @simple.should_not be_nil
+      end
+
+      it 'should return the score' do
+        @simple.should == -4.2
+        @double.should == -3.4
+        @complex.should == 1.4
+        @complex_double.should == 2.8
+        @very_complex.should == 12.1
+      end
+    end
+
+  end
+
+  describe 'plugin formulas' do
+    it 'should run any formula using a shortcut method' do
+      result = Odyssey.fake_formula one_simple_sentence, true
+      result['name'].should == "It's fake"
+    end
+
+    it 'should default to Formula for a formula that does not exist' do
+      result = Odyssey.no_existe one_simple_sentence, true
+      result['name'].should == "Generic"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rspec'
+require 'odyssey'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end
+
+def one_simple_sentence
+  "See Spot run."
+end
+
+def two_simple_sentences
+  "See Spot run. See Spot jump."
+end
+
+def one_complex_sentence
+  "The quick brown fox jumps over the lazy dog."
+end
+
+def two_complex_sentences
+  "The quick brown fox jumps over the lazy dog. Peter Piper picked a peck of pickled peppers."
+end
+
+def very_complex
+  "The best things in an artist's work are so much a matter of intuition, that there is much to be said for the point of view that would altogether discourage intellectual inquiry into artistic phenomena on the part of the artist. Intuitions are shy things and apt to disappear if looked into too closely. And there is undoubtedly a danger that too much knowledge and training may supplant the natural intuitive feeling of a student, leaving only a cold knowledge of the means of expression in its place. For the artist, if he has the right stuff in him"
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: odyssey
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+  prerelease: 
+platform: ruby
+authors:
+- Cameron Sutter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Odyssey is an extendible text analyzing gem that outputs the readability
+  score of text. It has several of the common readability formulas available, but
+  defaults to the Flesch-Kincaid Reading Ease score.
+email:
+- cameronsutter0@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/formulas/ari.rb
+- lib/formulas/coleman_liau.rb
+- lib/formulas/fake_formula.rb
+- lib/formulas/flesch_kincaid_gl.rb
+- lib/formulas/flesch_kincaid_re.rb
+- lib/formulas/formula.rb
+- lib/formulas/gunning_fog.rb
+- lib/formulas/smog.rb
+- lib/odyssey.rb
+- lib/odyssey/engine.rb
+- lib/odyssey/version.rb
+- odyssey.gemspec
+- spec/odyssey_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Text readability analyzer using Flesch-Kincaid and others
+test_files:
+- spec/odyssey_spec.rb
+- spec/spec_helper.rb
+has_rdoc: