text-analysis-utils 0.1

data/bin/cache-document

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/document-cache' )
+
+def get_text
+	if ARGV.empty?
+		STDIN.read
+	else
+		text = ""
+		ARGV.each{|filename| File.open(filename){|file| text += file.read}}
+		text
+	end
+end
+
+DocumentCache.add(get_text)

data/bin/classify-new-words

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby1.9.3
+
+require 'rubygems'
+require 'colorize'
+require File.join(File.dirname(__FILE__), '../lib/vocabulary-chest' )
+require File.join(File.dirname(__FILE__), '../lib/document-cache' )
+
+
+def get_text
+	if !ARGV.empty?
+		text = ""
+		ARGV.each {|filename|
+			text += File.open(filename, 'r'){|file| file.read}
+		}
+		text
+	else
+		STDIN.read
+	end
+end
+
+def ask word, index, words, text
+  location = (text =~ /\b#{Regexp.escape(word)}\b/)
+	puts "!!!!" if word == "notwendig"
+  location = text.index(word) if location.nil?
+	(puts "Skipping word: #{word}"; return 'skip') if location.nil?
+
+	beginning_of_snippet = location - 15 < 0 ? 0 : location - 15
+	snippet = text[beginning_of_snippet, 30 + word.size].gsub(/[\r\n]/," ")
+
+	answer = ''
+	while !['y','n','skip'].include?(answer)
+		puts
+		puts "------------------------------------------------------------"
+		puts "...#{snippet.gsub(word, word.green)}..."
+		puts
+		puts "Do you know this word? [y or n or skip] (#{index + 1} of #{words.size})"
+		STDOUT.write("> ")
+
+		answer = STDIN.gets.gsub(/[\r\n]/, '')
+	end
+	answer
+end
+
+def collect_words_from textual_words
+	textual_words.reject!{|w|VocabularyChest::is_known?(w)}
+	textual_words.reject!{|w|VocabularyChest::contains?(w)} if @@options.include? "-n"
+
+	words_by_stem = textual_words.inject({}){|hash, w| hash[VocabularyChest::stem w] = w; hash}
+	words_by_stem.reject!{|s,w| (s =~ /^[-\d\s,\.]*$/) == 0}
+
+	words_by_stem.values.uniq
+end
+
+@@options = ARGV.select{|arg| ["-n"].include? arg}
+ARGV.reject!{|arg| @@options.include? arg}
+
+text = get_text
+textual_words = text.split(" ").collect{|w| w.chomp}
+puts "Thanks. Please wait..."
+
+words = collect_words_from textual_words
+words.each_with_index {|word, index|
+  match = DocumentCache::extract_matching_words(word, text).first
+  answer = ask match, index, words, text
+  VocabularyChest::add_to_known_words(word) if answer == 'y'
+  VocabularyChest::add_to_unknown_words(word) if answer == 'n'
+}
+
+puts "Done."

data/bin/find-examples-for

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'colorize'
+require File.join(File.dirname(__FILE__), '../lib/document-cache' )
+
+count = 1
+count_param = ARGV.find{|a| (a =~ /--\d*/) == 0}
+if !count_param.nil?
+  count = count_param.sub("--","").to_i
+  ARGV.reject!{|a| a == count_param}
+end
+
+search = ARGV.join(" ")
+matches = DocumentCache.find_examples_for search, count
+exit(1) if matches.empty?
+
+puts matches.map{|sentence, tokens|
+  colored_sentence = sentence.dup
+  tokens.each{|m| colored_sentence.gsub!(m, m.green)  }
+  colored_sentence
+}.join("\n")

data/bin/frequency-list

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/document-cache' )
+require File.join(File.dirname(__FILE__), '../lib/vocabulary-chest' )
+
+text = DocumentCache::documents.inject(""){|text, f| text+= File.open(f){|f|f.read}; text}
+
+frequencies = text.split(" ").inject(Hash.new {|hash,key| hash[key] = []}){|hash, w| hash[VocabularyChest::stem(w)] << w; hash }
+
+frequencies = frequencies.sort{|a,b| a[1].size <=> b[1].size}.reverse
+
+def output frequencies
+  STDOUT.sync = true
+	frequencies.each{|k,v| puts "#{v.size}\t#{k}\t#{v[0,6].join(",")}#{v.size > 6 ? "..." : ""}"}
+end
+
+if ARGV[0] == "--unknown"
+	output frequencies.find_all{|k,v| !VocabularyChest::is_known?(v[0])}
+else
+	output frequencies
+end

data/bin/lookup

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/lookup' )
+
+if !ARGV.empty?
+  puts Lookup::go ARGV
+else
+  puts Lookup::go STDIN.read.split("\n")
+end

data/bin/percentage-known-of

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/vocabulary-chest' )
+require File.join(File.dirname(__FILE__), '../lib/lookup' )
+
+def analyse text
+	words = text.split(" ")
+	known = words.select{|w| VocabularyChest.is_known? w}
+	unknown = (words - known)
+	return [known.map{|w| VocabularyChest::sanitize w}.uniq, unknown.map{|w| VocabularyChest::sanitize w}.uniq]
+end
+
+def output options
+	known, unknown = options
+	size = known.size + unknown.size
+	
+	puts
+	puts "--"
+	puts "UNKNOWN WORDS: #{unknown.join(", ")}"
+	puts 
+	puts "DEFINITIONS"
+	puts Lookup::go(unknown)
+	puts "--"
+	puts
+	puts "Total number of unknown words: #{unknown.size}"
+	puts "Total number of known words: #{known.size}"
+	puts "Total number of words: #{size}"
+	puts "Percentage of words known: #{'%.2f' % (known.size.to_f / size * 100)}%"
+end
+
+if !ARGV.empty?
+  ARGV.each {|filename|
+    text = File.open(filename,'r'){|file| file.read}
+    puts "#{filename}:"
+    output(analyse(text))
+  }
+else
+  text = STDIN.read
+  output(analyse(text))
+end

data/bin/play-with-blanks

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/game' )
+
+def get_input
+  if !ARGV.empty?
+  else
+    STDIN.read
+  end
+end
+
+(puts "Usage: #{$0} <file with words to practice> <file with examples>"; exit(1)) if ARGV.size < 2
+
+input = File.open(ARGV.shift){|f| f.read}
+words = input.split("\n").uniq
+
+example_sentences = []
+ARGV.each{|filename| example_sentences += File.open(filename).readlines}
+example_sentences.map!{|s| s.chomp}
+example_sentences.reject!{|s| words.find{|w| (s =~ /\b#{Regexp.escape(w)}\b/i) != nil} == nil}
+words.reject!{|w| example_sentences.find{|s| (s =~ /\b#{Regexp.escape(w)}\b/i) != nil} == nil}
+
+puts "Playing with #{example_sentences.size} sentences and #{words.size} words."
+
+Game.new(words).play{|word|
+  sentence = example_sentences.shuffle.find{|s| (s =~ /\b#{Regexp.escape(word)}\b/i) != nil}
+  [sentence, $&]
+}

data/bin/play-with-examples

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/document-cache' )
+require File.join(File.dirname(__FILE__), '../lib/vocabulary-chest' )
+require File.join(File.dirname(__FILE__), '../lib/game' )
+
+def get_input
+  if !ARGV.empty?
+    File.open(ARGV[0]){|f| f.read}
+  else
+    STDIN.read
+  end
+end
+
+input = get_input
+words = input.split("\n")
+words.reject!{|w| STDOUT.write("."); STDOUT.flush; DocumentCache.find_examples_for(w).empty?}
+puts
+
+Game.new(words).play{ |word|
+  matches = DocumentCache.find_examples_for(word, 10).keys
+  sentence = matches.sort{|a, b| a.size <=> b.size}.first
+  correct_answer = DocumentCache::extract_matching_words(word, sentence).first
+  [sentence, correct_answer]
+}

data/bin/prepare-text

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+text = STDIN.read
+File.open("/tmp/prepared-text", 'w'){|f| f.write(text)}
+exec("classify-new-words /tmp/prepared-text && \
+	cache-document /tmp/prepared-text && \
+	echo '\nREADABILITY STATISTICS' && \
+	readability-of /tmp/prepared-text && \
+	percentage-known-of /tmp/prepared-text")

data/bin/proximity-of-words

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'amatch'
+
+def distance w1, w2
+	Amatch::Levenshtein.new(w1).match(w2)
+end
+
+def analyse text, known_text
+	words = words_of(text)
+	known_words = words_of(known_text)
+
+	words.map {|w|
+		closest_word, proximity = find_closest_word(w, known_words)
+		puts "#{w}\t#{closest_word}\t#{proximity}"
+		STDOUT.flush
+	}
+end
+
+def find_closest_word word, known_words
+	closest_word = known_words.sort{|w1, w2| distance(w1, word) <=> distance(w2, word)}.first
+
+	[closest_word, distance(closest_word, word)]
+end
+
+def words_of text
+	words = text.split(" ").uniq
+end
+
+if ARGV.size < 2
+  puts "usage: ./script <new text> <known text>"
+  exit 1
+end
+
+filename = ARGV.shift
+text = File.open(filename,'r'){|file| file.read}
+
+known_text ||= ""
+ARGV.each {|filename|
+  known_text += File.open(filename,'r'){|file| file.read}
+}
+
+analyse text, known_text

data/bin/readability-of

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+def analyse text
+	words = text.split(" ").size.to_f
+	sentences = text.split(/\.|\?|!/).reject{|s| s.strip.empty?}.size.to_f
+	syllables = text.split(" ").inject([]){|sum, w| sum + vowels(w)}
+	syllables = syllables.size.to_f * 0.9 # for silent vowels
+	words_with_more_than_three_syllables = text.split(" ").select{|w| vowels(w).size >= 3}
+	ms = words_with_more_than_three_syllables.size.to_f / text.split(" ").size.to_f * 100
+
+  stats = {:words => words, 
+					 :sentences => sentences, 
+					 :syllables => syllables, 
+					 :ms => ms, 
+					 :wiener_sachtextformel => wiener_sachtextformel(sentences, words, ms), 
+					 :grade_level => grade(sentences, words, syllables)}
+end
+
+def wiener_sachtextformel sentences, words, ms
+	0.2656 * (words / sentences) + 0.2744 * ms -1.693
+end
+
+def grade sentences, words, syllables
+	(0.39 * (words / sentences) + 11.8 * (syllables / words) - 15.59)
+end
+
+def vowels w
+	w.split(/b|c|d|f|g|h|j|k|l|m|n|p|q|r|s|t|v|w|z/i).reject{|s|s.empty?}
+end
+
+def output options
+	puts
+	if !options[:source].nil?
+		puts "#{options[:source]}:"
+	end
+	puts "Number of sentences: #{options[:sentences]}"
+	puts "Number of words: #{options[:words]}"
+	puts "Number of syllabes: #{options[:syllables]}"
+	puts "Average number of syllables per word: #{ '%.2f' % (options[:syllables] / options[:words])}"
+	puts "Average number of words per sentence: #{'%.2f' % (options[:words] / options[:sentences])}"
+	puts "Wiener Sachtextformel: #{'%.2f' % options[:wiener_sachtextformel]}"
+	puts "Flesch-Kincaid Grade Level: #{'%.2f' % options[:grade_level]}"
+	puts
+end
+
+if !ARGV.empty?
+  ARGV.each {|filename|
+    text = File.open(filename,'r'){|file| file.read}
+    output(analyse(text).merge(:source => filename))
+  }
+else
+  text = STDIN.read
+  output(analyse(text))
+end

data/bin/vocabulary-coverage

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+command =<<EOF
+
+total_occurrences=`expr $(frequency-list | awk '{print $1}' | xargs | sed 's/ / + /g')`
+unknown_occurrences=`expr $(frequency-list --unknown | awk '{print $1}' | xargs | sed 's/ / + /g')`
+next_500_occurrences=`expr $(frequency-list --unknown | awk '{print $1}' | head -500 | xargs | sed 's/ / + /g')`
+
+echo Total occurrences: $total_occurrences
+echo Unknown occurrences: $unknown_occurrences
+echo Your current vocabulary knowledge covers $(echo "scale=2;($total_occurrences - $unknown_occurrences) / $total_occurrences * 100" | bc -q)% of all occurrences
+echo The next 500 words will bring your cover to $(echo "scale=2;($total_occurrences - $unknown_occurrences + $next_500_occurrences) / $total_occurrences * 100" | bc -q)%
+
+EOF
+
+system command

data/lib/document-cache.rb

@@ -0,0 +1,98 @@
+require 'fileutils.rb'
+require 'rubygems'
+require 'uuid'
+
+require File.join(File.dirname(__FILE__), 'vocabulary-chest' )
+
+CACHE_DIR = "#{ROOT_DIR}/docs"
+
+FileUtils::mkdir_p(ROOT_DIR)
+FileUtils::mkdir_p(CACHE_DIR)
+
+module DocumentCache
+	def self.add search
+		filename = "#{CACHE_DIR}/#{UUID.new.generate}"
+		File.open(filename,'w'){|f| f.write(search)}
+	end
+
+	def self.find_matches_by_stemming search, sentences
+		token = VocabularyChest::stem(search)
+		sentences.inject({}){|hash, s| 
+			words = s.split(" ")
+			found = words.select{|w| VocabularyChest::stem(w) == token}
+			hash[clean(s)] = found.map{|f| VocabularyChest::sanitize(f)} if !found.empty?
+			hash
+		}
+	end
+
+	def self.find_matches_by_grepping search, sentences
+		sentences.inject({}){|hash, s| 
+			hash[clean(s)] = [search] if s.include? search 
+			hash
+		}
+	end
+
+	def self.find_matches_in filenames, search, count
+		matches = {}
+
+		[:find_matches_by_stemming, :find_matches_by_grepping].each{|matcher|
+			filenames.each {|filename|
+				File.open(filename){|file|
+					contents = file.read
+					sentences = contents.split(/[\.?!\n]/)
+					matches.merge!(self.send(matcher, search, sentences))
+
+					matches.shift until matches.size <= count if matches.size > count
+					return matches if matches.size == count
+				}
+			}
+		}
+
+		matches
+	end
+
+	def self.documents
+		Dir["#{CACHE_DIR}/*"]
+	end
+
+	def self.find_examples_for search, count=1
+		find_matches_in documents, search, count
+	end
+
+	def self.clean(sentence)
+		sentence.strip + "."
+	end
+
+	def self.extract_matching_words search, sentence
+		matches = find_matches_by_stemming(search, [sentence])
+		return matches.values.first if !matches.empty?
+		return find_matches_by_grepping(search, [sentence]).values.first
+	end
+
+	def self.frequency_list
+		text = ""
+		documents.each{|f| text += File.open(f).read }
+		counts = text.split(" ").inject(Hash.new(0)) {|h,w| h[w] += 1; h }
+		counts.reject!{|word, count| count < 2}
+		counts.sort_by {|k,v| v}.reverse
+	end
+
+	def self.stemmed_frequency_list
+		text = ""
+		documents.each{|f| text += File.open(f).read }
+		stems = text.split(" ").map{|w| VocabularyChest::stem(w)}
+		counts = stems.inject(Hash.new(0)) {|h,stem| h[stem] += 1; h }
+		counts.reject!{|stem, count| count < 2}
+		counts.sort_by {|k,v| v}.reverse
+	end
+end
+
+if __FILE__ == $0
+	puts "The document cache contains #{DocumentCache.documents.size} documents."
+	puts
+	puts "Here are the 10 most frequent stems:"
+	DocumentCache.stemmed_frequency_list[0,10].each{|stem, count| puts "#{count} #{stem}"}
+	puts
+	puts "Here are the 10 most frequent words:"
+	DocumentCache.frequency_list[0,10].each{|word, count| puts "#{count} #{word}"}
+end

data/lib/game.rb

@@ -0,0 +1,122 @@
+require 'rubygems'
+require 'amatch'
+require 'colorize'
+
+class Game
+	def initialize words
+		@words = words
+		@results = []
+		@turn = 0
+	end
+
+	def pick_choices_for word
+		others = @words.reject{|w| w == word}
+		choices = (others.shuffle[0,4] + [word])
+		choices.shuffle
+	end
+
+	def hit_rate
+		number_of_turns_we_remember = [@words.size, @turn].min
+		recent_results = number_of_turns_we_remember < @results.size ? @results[@results.size - number_of_turns_we_remember, @results.size] : @results
+		hits = recent_results.inject(0){|sum, value| sum+=value; sum}
+		misses = recent_results.size - hits
+
+		rate = 100 - misses / number_of_turns_we_remember.to_f * 100
+		rate >= 0 ? rate : 0
+	end
+
+	def romanize w
+		w.gsub("ä", "ae").gsub("ö", "oe").gsub("ü", "ue").gsub("ß", "ss")
+	end
+
+	def proximity one, other
+		Amatch::Levenshtein.new(romanize(one).downcase).match(romanize(other).downcase)
+	end
+
+	def get_an_answer_for correct_answer
+		STDOUT.write("> ")
+		answer = STDIN.gets.chomp
+
+		while answer != '?' and proximity(answer, correct_answer) > 1
+			@results << 0
+			display_definition(answer)
+			puts
+			puts "Nope. Try again.".red
+			puts
+			STDOUT.write("> ")
+			answer = STDIN.gets.chomp
+		end
+
+		answer
+	end
+
+	def fetch_definition word
+		definitions = `dict "#{word}" 2>/dev/null | grep '     ' | head -2`.chomp.gsub("     ","").split(/[\r\n]/)
+		definitions.uniq.join(" -- ")
+	end
+
+	def display_definition word
+		definition = fetch_definition(word)
+		puts "\n#{word.blue} means: #{definition}" if !definition.empty?
+	end
+
+	def show_question_for word, sentence
+		puts
+		puts
+		puts
+		puts "Turn #{@turn}".blue
+		puts "#{@words.size} words".blue
+		color = hit_rate < 75 ? :red : (hit_rate < 90 ? :yellow : 'green')
+		puts "Hit rate: #{'%i' % hit_rate}%".send(color)
+		puts "------------------------------------------------------------".blue
+		puts
+		puts ((sentence =~ /\b#{Regexp.escape(word)}\b/i) != nil ? sentence.gsub(/\b#{Regexp.escape(word)}\b/i, "______") : sentence.gsub(word, "______")).strip
+		puts 
+		puts "Choices: [" + " #{pick_choices_for(word).join(" - ")} ".blue + "]"
+		puts
+	end
+
+	def end_game
+		puts
+		puts
+		puts "#{"Congratulations!".green} Here is a star for you: #{'*'.yellow}"
+		puts
+	end
+
+	def respond_to_answer answer, correct_answer
+		puts
+		if answer == '?'
+			@results << 0
+			puts "The answer was: #{correct_answer.red}."
+			display_definition(correct_answer)
+			sleep 2
+		elsif proximity(answer, correct_answer) > 0
+			@results << 1
+			puts "Sort of... the answer was: #{correct_answer.yellow}."
+			display_definition(correct_answer)
+			sleep 1
+		else
+			@results << 1
+			puts "Correct! The answer was: #{correct_answer.green}."
+			display_definition(correct_answer)
+		end
+	end
+
+	def play &block
+		@words.shuffle.each{|word|
+			@turn += 1
+
+			sentence, correct_answer = yield word
+			(puts "Could not find anything to play with for word #{word}."; next) if sentence.nil? or correct_answer.nil?
+
+			show_question_for(correct_answer, sentence)
+			answer = get_an_answer_for(correct_answer)
+			respond_to_answer(answer, correct_answer)
+
+			(end_game; return) if @turn >= @words.size and (hit_rate >= 95)
+		}
+
+		play(&block)
+	end
+end
+

data/lib/lookup.rb

@@ -0,0 +1,15 @@
+module Lookup
+
+	def self.fetch_definition word
+		definitions = `dict "#{word}" 2>/dev/null | grep '     ' | head -2`.chomp.gsub("     ","").split(/[\r\n]/)
+		definitions.uniq.join(" -- ")
+	end
+
+	def self.sanitize word
+		word.gsub(/[,\.]/,"")
+	end
+
+	def self.go words
+		words.map{|w| sanitize w}.map{|w| "#{w}\t#{fetch_definition w}"}.join("\n")
+	end
+end

data/lib/text-analysis-utils.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), 'vocabulary-chest' )
+require File.join(File.dirname(__FILE__), 'document-cache' )
+require File.join(File.dirname(__FILE__), 'game' )
+

data/lib/vocabulary-chest.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require 'fileutils.rb'
+require 'rubygems'
+require 'lingua/stemmer'
+
+ROOT_DIR = File.expand_path(ENV['chest_location'] || "~/.vocabulary-chest")
+KNOWN_FILE = "#{ROOT_DIR}/known"
+UNKNOWN_FILE = "#{ROOT_DIR}/unknown"
+
+FileUtils::mkdir_p(ROOT_DIR)
+FileUtils.touch(KNOWN_FILE)
+FileUtils.touch(UNKNOWN_FILE)
+
+module VocabularyChest
+	@known_file = File.open(KNOWN_FILE,'a')
+	@unknown_file = File.open(UNKNOWN_FILE,'a')
+	@known_words = nil
+	@unknown_words = nil
+	@stemmer= Lingua::Stemmer.new(:language => "de")
+
+	at_exit {@known_file.close}
+	at_exit {@unknown_file.close}
+
+	def self.known_words
+		@known_words ||= File.open(KNOWN_FILE,'r'){|f|f.readlines}.collect{|line| line.chomp}
+	end
+
+	def self.unknown_words
+		@unknown_words ||= File.open(UNKNOWN_FILE,'r'){|f|f.readlines}.collect{|line| line.chomp}
+	end
+
+	def self.add_to_known_words word
+		@known_file.puts(stem word)
+		@known_file.flush
+	end
+
+	def self.add_to_unknown_words word
+		@unknown_file.puts(stem word)
+		@unknown_file.flush
+	end
+
+	def self.contains? word
+		stemmed_word = stem word
+		known_words.include?(stemmed_word) or unknown_words.include?(stemmed_word)
+	end
+
+	def self.is_known? word
+		known_words.include?(stem(word)) or sanitize(word).empty? or (sanitize(word) =~ /^[-\d]*$/) != nil
+	end
+
+	def self.stem word
+		@stemmer.stem(sanitize word).downcase
+	end
+
+	def self.sanitize word
+		word.gsub(/[,\"\.:;()?!„“]/,"")
+	end
+end
+
+if __FILE__ == $0
+	known = VocabularyChest::known_words
+	unknown = VocabularyChest::unknown_words
+	puts "The chest contains #{known.size} known words."
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: text-analysis-utils
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Matt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-21 00:00:00 Z
+dependencies: []
+
+description: 
+email: 
+executables: 
+- cache-document
+- classify-new-words
+- find-examples-for
+- frequency-list
+- lookup
+- percentage-known-of
+- play-with-blanks
+- play-with-examples
+- prepare-text
+- proximity-of-words
+- readability-of
+- vocabulary-coverage
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/text-analysis-utils.rb
+- lib/document-cache.rb
+- lib/vocabulary-chest.rb
+- lib/game.rb
+- lib/lookup.rb
+- bin/cache-document
+- bin/classify-new-words
+- bin/find-examples-for
+- bin/frequency-list
+- bin/lookup
+- bin/percentage-known-of
+- bin/play-with-blanks
+- bin/play-with-examples
+- bin/prepare-text
+- bin/proximity-of-words
+- bin/readability-of
+- bin/vocabulary-coverage
+homepage: http://github.com/matstc/text-analysis-utils
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Utilities to help language learners
+test_files: []
+