marky_markov 0.1.2 → 0.1.3

data/README.md

@@ -33,11 +33,23 @@ of the dictionary name.
     puts markov.generate_n_words 10
     markov.save_dictionary! # Saves the modified dictionary/creates one if it didn't exist.
 
-If you keep look at generate_n_words and wonder why you can't put a
+If you keep looking at generate_n_words and wonder why you can't put a
 number in there, well, you can!
 
     markov.generate_20_words
 
+The default dictionary depth is two words.
+ `{"I hope"     => {"this" => 1},
+  "hope this"  => {"makes" => 1},
+  "this makes" => {"sense" => 1}}`
+but it can be set to a depth between 1 and 9 upon dictionary creation
+
+    markov = MarkyMarkov::Dictionary.new('dictionary', 3)
+
+creates a dictionary with a depth of three words.
+`{"I hope this" => {"makes" => 1},
+  "hope this makes" => {"sense" => 1}`
+
 If you want to delete a dictionary you call it upon the Dictionary class itself while
 passing in the filename/location.
 

data/bin/marky_markov

@@ -4,7 +4,6 @@
 require 'optparse'
 require 'marky_markov'
 
-#if __FILE__ == $0
 options = {}
 opt_parser = OptionParser.new do |opts|
   opts.banner = "Usage: marky-markov COMMAND [OPTIONS]"
@@ -17,7 +16,7 @@ opt_parser = OptionParser.new do |opts|
   opts.separator "Options"
 
   options[:dictionary] = "#{ENV["HOME"]}/.marky_markov_dictionary"
-  opts.on('-d', '--dictionary FILE', 'Use custom dictionary location') do |file|
+  opts.on('-l', '--location DICTIONARY', 'Use custom dictionary location') do |file|
     options[:dictionary] = file
   end
 
@@ -32,6 +31,12 @@ opt_parser = OptionParser.new do |opts|
     options[:source] = file
   end
 
+  options[:depth] = 2
+  opts.on('-d', '--depth 1-9', 'Set dictionary depth. The higher the number
+          , the less random the sentence will be. Must be between 1 and 9.') do |number|
+    options[:depth] = number.to_i
+  end
+
   options[:resetdictionary] = false
   opts.on('--reset', "WARNING: Deletes default dictionary." ) do
     options[:resetdictionary] = true
@@ -53,7 +58,7 @@ end
 case ARGV[0]
 when "speak"
   if options[:source]
-    markov = MarkyMarkov::TemporaryDictionary.new
+    markov = MarkyMarkov::TemporaryDictionary.new(options[:depth])
     markov.parse_file(options[:source])
   else
     unless File.exists?("#{options[:dictionary]}.mmd")
@@ -66,7 +71,7 @@ when "speak"
   STDOUT.puts markov.generate_n_words(options[:wordcount])
 when "read"
   source = ARGV[1] || options[:source]
-  markov = MarkyMarkov::Dictionary.new(options[:dictionary])
+  markov = MarkyMarkov::Dictionary.new(options[:dictionary], options[:depth])
   markov.parse_file(source)
   markov.save_dictionary!
   STDOUT.puts "Added #{source} to dictionary."
@@ -76,7 +81,7 @@ when "listen"
   STDOUT.puts markov.generate_n_words(options[:wordcount])
 else
   unless STDIN.tty?
-    markov = MarkyMarkov::TemporaryDictionary.new
+    markov = MarkyMarkov::TemporaryDictionary.new(options[:depth])
     markov.parse_string(STDIN.read)
     STDOUT.puts markov.generate_n_words(options[:wordcount])
   else

data/lib/marky_markov/{one_word_dictionary.rb → markov_dictionary.rb}

@@ -1,8 +1,9 @@
 # @private
-class OneWordDictionary
-  attr_accessor :dictionary
-  def initialize
+class MarkovDictionary
+  attr_accessor :dictionary, :depth
+  def initialize(depth=2)
     @dictionary = {}
+    @depth = depth
   end
 
   # If File does not exist.
@@ -36,11 +37,10 @@ class OneWordDictionary
   # @example Add a string
   #   parse_source("Hi, how are you doing?", false)
   def parse_source(source, file=true)
-    # Special case for last word in source file as it has no words following it.
     contents = file ? open_source(source) : contents = source.split
-    contents.each_cons(2) do |first, second|
-      self.add_word(first, second)
+    contents.each_cons(@depth+1) do |words|
+       self.add_word(words[0..-2].join(' '), words[-1])
     end
-    @dictionary[(contents.last)] ||= Hash.new(0)
+    @dictionary[contents.last(@depth).join(' ')] ||= Hash.new(0)
   end
 end

data/lib/marky_markov/{one_word_sentence_generator.rb → markov_sentence_generator.rb}

@@ -1,7 +1,8 @@
 # @private
-class OneWordSentenceGenerator
+class MarkovSentenceGenerator
   def initialize(dictionary)
     @dictionary = dictionary
+    @depth = @dictionary.depth
   end
 
   # Returns a random word via picking a random key from the dictionary.
@@ -15,6 +16,20 @@ class OneWordSentenceGenerator
     keys[rand(keys.length)]
   end
 
+  # Generates a random capitalized word via picking a random key from the
+  # dictionary and recurring if the word is lowercase.
+  #
+  # (see #random_word)
+  def random_capitalized_word
+    keys = @dictionary.dictionary.keys
+    x = keys[rand(keys.length)]
+    if /[A-Z]/ =~ x[0]
+      return x
+    else
+      random_capitalized_word
+    end
+  end
+
   # Returns a word based upon the likelyhood of it appearing after the supplied word.
   # 
   def weighted_random(lastword)
@@ -36,10 +51,11 @@ class OneWordSentenceGenerator
   #
   def generate(wordcount)
     sentence = []
-    sentence << random_word
+    sentence.concat(random_capitalized_word.split)
     (wordcount-1).times do
-      sentence << weighted_random(sentence.last)
+      sentence.concat(weighted_random(sentence.last(@depth).join(' ')).split)
     end
+    sentence.pop(sentence.length-wordcount)
     sentence.join(' ')
   end
 end

data/lib/marky_markov/persistent_dictionary.rb

@@ -1,27 +1,36 @@
 require 'yajl'
-require_relative 'two_word_dictionary'
+require_relative 'markov_dictionary'
 
 # @private
-class PersistentDictionary < TwoWordDictionary
+class PersistentDictionary < MarkovDictionary
+
+  class DepthNotInRangeError < Exception
+  end
+
   # Creates a PersistentDictionary object using the supplied dictionary file.
   #
-  # @note Do not include the .mmd file extension in the name of the dictionary.
-  #   It will be automatically appended.
   # @param [File] dictionary Name of dictionary file to create/open.
+  # @param [Int] depth The dictionary depth. 2 word dictionary default.
   # @return [Object] PersistentDictionary object.
-  attr_reader :dictionarylocation
-  def initialize(dictionary)
+  attr_reader :dictionarylocation, :depth
+  def initialize(dictionary, depth=2)
+    @depth = depth
+    unless (1..9).include?(depth)
+      raise DepthNotInRangeError.new("Depth must be between 1 and 9")
+    end
     @dictionarylocation = dictionary
     self.open_dictionary
   end
 
+
   # Opens the dictionary objects dictionary file.
   # If the file exists it assigns the contents to a hash, 
   # otherwise it creates an empty hash.
   def open_dictionary
     if File.exists?(@dictionarylocation)
-      File.open(@dictionarylocation,'r') do |f|
-        @dictionary = Yajl::Parser.parse(f)
+      File.open(@dictionarylocation,'r').each do |f|
+        @depth = f[0].to_i
+        @dictionary = Yajl::Parser.parse(f[1..-1])
       end
     else
       @dictionary = {}
@@ -33,7 +42,7 @@ class PersistentDictionary < TwoWordDictionary
   def save_dictionary!
     json = Yajl::Encoder.encode(@dictionary)
     File.open(@dictionarylocation, 'w') do |f|
-      f.puts json
+      f.puts @depth.to_s + json
     end
     true
   end

data/lib/marky_markov.rb

@@ -2,24 +2,28 @@
 #A Markov Chain generator.
 
 require_relative 'marky_markov/persistent_dictionary'
-require_relative 'marky_markov/two_word_sentence_generator'
+require_relative 'marky_markov/markov_sentence_generator'
 
-# @version = 0.1.2
+# @version = 0.1.3
 # @author Matt Furden
 # Module containing TemporaryDictionary and Dictionary for creation of
 # Markov Chain Dictionaries and generating sentences from those dictionaries.
 module MarkyMarkov
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 
   class TemporaryDictionary
     # Create a new Temporary Markov Chain Dictionary and sentence generator for use.
+    # Depth defaults to two words but can be set to any number between 1 and 9.
     #
     # @example Create a new Temporary Dictionary.
     #   markov = MarkyMarkov::TemporaryDictionary.new
-    # @return [Object] a MarkyMarkov::TemporaryDictionary object.
-    def initialize
-      @dictionary = TwoWordDictionary.new
-      @sentence = TwoWordSentenceGenerator.new(@dictionary)
+    # @example Create a three word Temporary Dictionary.
+    #   markov = MarkyMarkov::TemporaryDictionary.new(3)
+    # @param [Int] depth Optional dictionary depth. Defaults to 2.
+    # @return [Object] a MarkyMarkov::TemporaryDictionary object`.
+    def initialize(depth=2)
+      @dictionary = MarkovDictionary.new(depth)
+      @sentence = MarkovSentenceGenerator.new(@dictionary)
     end
 
     # Parses a given file and adds the sentences it contains to the current dictionary.
@@ -67,6 +71,7 @@ module MarkyMarkov
       end
     end
 
+    # @since 0.1.2
     # Modify respond_to? to include generate_n_words method_missing implementation.
     def respond_to?(method_sym, include_private = false)
       if method_sym.to_s =~ /^generate_(\d*)_word[s]*$/
@@ -89,15 +94,19 @@ module MarkyMarkov
 
   class Dictionary < TemporaryDictionary
     # Open (or create if it doesn't exist) a Persistent Markov Chain Dictionary
-    # and sentence generator for use.
+    # and sentence generator for use. Optional dictionary depth may be supplied.
     #
     # @example Create a new Persistent Dictionary object.
     #   markov = MarkyMarkov::Dictionary.new("#{ENV["HOME"]}/markov_dictionary")
+    # @example Create a new Persistent Dictionary object with a depth of 4.
+    #   markov = MarkyMarkov::Dictionary.new('mmdict.mmd'. 4)
+    # @param [File] location The location the dictionary file is/will be stored.
+    # @param [Int] depth The depth of the dictionary. Defaults to 2.
     attr_reader :dictionarylocation
-    def initialize(location)
+    def initialize(location, depth=2)
       @dictionarylocation = "#{location}.mmd"
-      @dictionary = PersistentDictionary.new(@dictionarylocation)
-      @sentence = TwoWordSentenceGenerator.new(@dictionary)
+      @dictionary = PersistentDictionary.new(@dictionarylocation, depth)
+      @sentence = MarkovSentenceGenerator.new(@dictionary)
     end
 
     # Save the Persistent Dictionary file into JSON format for later use.
@@ -120,7 +129,7 @@ module MarkyMarkov
     #   MarkyMarkov::Dictionary.delete_dictionary!("#{ENV["HOME"]}/markov_dictionary")
     # @example Delete the dictionary of the object 'markov'
     #   MarkyMarkov::Dictionary.delete_dictionary!(markov)
-    # @param [String] location location/name of the dictionary file to be deleted.
+    # @param [String/Object] location location/name of the dictionary file to be deleted.
     def self.delete_dictionary!(location)
       location += ".mmd" if location.class == String
       PersistentDictionary.delete_dictionary!(location)

data/spec/marky_markov/markov_dictionary_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper.rb'
+
+describe MarkovDictionary do
+  context "One Word Depth Dictionary" do
+    before(:each) do
+      @onetextsource = "spec/test.txt"
+      @onedict = MarkovDictionary.new(1)
+      @onedict.parse_source("Hello how are you doing today", false)
+      @onestringdict = {"Hello"   => {"how"        => 1},
+                        "how"     => {"are"        => 1},
+                        "are"     => {"you"        => 1},
+                        "you"     => {"doing"      => 1},
+                        "doing"   => {"today"      => 1},
+                        "today"   => {} }
+      @onetextdict = {"The" => {"cat"=>1},
+                      "and" => {"chainsaws"=>1},
+                      "cat" => {"likes"=>1},
+                      "chainsaws" => {},
+                      "likes" => {"pie"=>1},
+                      "pie" => {"and"=>1} }
+    end
+
+    it "can open a file" do
+      @onedict.open_source(@onetextsource).should_not be_nil
+    end
+
+    it "should give a FileNotFoundError if the file doesn't exist" do
+      expect { @onedict.open_source("thisisntreal") }.to 
+      raise_error(MarkovDictionary::FileNotFoundError,"thisisntreal does not exist!")
+    end
+
+    it "can add a word to the dictionary" do
+      @onedict.add_word("to", "be")
+      @onedict.dictionary.should include("to" => {"be" => 1})
+    end
+
+    it "create a dictionary via parsing a text file" do
+      @onedict.dictionary = {}
+      @onedict.parse_source(@onetextsource)
+      @onedict.dictionary.should eql(@onetextdict)
+    end
+
+    it "builds a one word dictionary properly" do
+      @onedict.dictionary.should eql(@onestringdict)
+    end
+  end
+
+  context "Two Word Dictionary" do
+    before(:each) do
+      @twodict = MarkovDictionary.new
+      @twodict.parse_source("The cat likes pie and chainsaws", false)
+      @twotextsource = "spec/test.txt"
+      @twostringdict = { "The cat"       => { "likes"     => 1},
+                         "cat likes"     => { "pie"       => 1 },
+                         "likes pie"     => {"and"        => 1 },
+                         "pie and"       => { "chainsaws" => 1 },
+                         "and chainsaws" => {} }
+      @twotextdict = {"The cat"          => {"likes"      => 1},
+                      "cat likes"        => {"pie"        => 1},
+                      "likes pie"        => {"and"        => 1},
+                      "pie and"          => {"chainsaws"  => 1},
+                      "and chainsaws"    => {}}
+    end
+
+    it "can add a word to the two-word dictionary" do
+      @twodict.add_word("Zebras like", "kung-fu")
+      @twodict.dictionary.should eql(@twostringdict.merge( {"Zebras like" => {"kung-fu" => 1}} ))
+    end
+
+    it "create a two-word dictionary via parsing a text file" do
+      @twodict.dictionary = {}
+      @twodict.parse_source(@twotextsource)
+      @twodict.dictionary.should eql(@twotextdict)
+    end
+  end
+end

data/spec/marky_markov/{one_word_sentence_spec.rb → markov_sentence_generator_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper.rb'
 
-describe OneWordSentenceGenerator do
+describe MarkovSentenceGenerator do
   before(:each) do
-    @dict = OneWordDictionary.new
+    @dict = MarkovDictionary.new
     @dict.parse_source("Hello man how are you today", false)
-    @sentence = OneWordSentenceGenerator.new(@dict)
+    @sentence = MarkovSentenceGenerator.new(@dict)
   end
 
   it "can pick a random word" do

data/spec/textdictcompare.mmd

@@ -1 +1 @@
-{"The cat":{"likes":1},"cat likes":{"pie":1},"likes pie":{"and":1},"pie and":{"chainsaws":1},"and chainsaws":{}}
+2{"The cat":{"likes":1},"cat likes":{"pie":1},"likes pie":{"and":1},"pie and":{"chainsaws":1},"and chainsaws":{}}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marky_markov
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-07 00:00:00.000000000 Z
+date: 2012-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70118059271520 !ruby/object:Gem::Requirement
+  requirement: &70361383496140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -24,7 +24,7 @@ dependencies:
         version: 2.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70118059271520
+  version_requirements: *70361383496140
 description: ! "MarkyMarkov makes it easy to generate simply Markov Chains based upon
   input from\n  either a source file or a string. While usable as a module in your
   code it can also be called on\n  from the command line and piped into like a standard
@@ -39,16 +39,12 @@ files:
 - README.md
 - bin/marky_markov
 - lib/marky_markov.rb
-- lib/marky_markov/one_word_dictionary.rb
-- lib/marky_markov/one_word_sentence_generator.rb
+- lib/marky_markov/markov_dictionary.rb
+- lib/marky_markov/markov_sentence_generator.rb
 - lib/marky_markov/persistent_dictionary.rb
-- lib/marky_markov/two_word_dictionary.rb
-- lib/marky_markov/two_word_sentence_generator.rb
-- spec/marky_markov/one_word_dictionary_spec.rb
-- spec/marky_markov/one_word_sentence_spec.rb
+- spec/marky_markov/markov_dictionary_spec.rb
+- spec/marky_markov/markov_sentence_generator_spec.rb
 - spec/marky_markov/persistent_dictionary_spec.rb
-- spec/marky_markov/two_word_dict_spec.rb
-- spec/marky_markov/two_word_sentence_spec.rb
 - spec/spec_helper.rb
 - spec/textdictcompare.mmd
 homepage: http://www.thefurd.com

data/lib/marky_markov/two_word_dictionary.rb

@@ -1,19 +0,0 @@
-require_relative 'one_word_dictionary'
-
-# @private
-class TwoWordDictionary < OneWordDictionary
-  # Given a source of text, be it a text file (file=true) or a string (file=false)
-  # it will add all the words within the source to the markov dictionary.
-  #
-  # @example Add a text file
-  #   parse_source("text.txt")
-  # @example Add a string
-  #   parse_source("Hi, how are you doing?", false)
-  def parse_source(source, file=true)
-    contents = file ? open_source(source) : contents = source.split
-    contents.each_cons(3) do |first, second, third|
-       self.add_word("#{first} #{second}", third)
-    end
-    @dictionary[contents.last(2).join(' ')] ||= Hash.new(0)
-  end
-end

data/lib/marky_markov/two_word_sentence_generator.rb

@@ -1,14 +0,0 @@
-require_relative 'one_word_sentence_generator'
-
-# @private
-class TwoWordSentenceGenerator < OneWordSentenceGenerator
-  def generate(wordcount)
-    sentence = []
-    sentence.concat(random_word.split)
-    (wordcount-1).times do
-      sentence.concat(weighted_random(sentence.last(2).join(' ')).split)
-    end
-    sentence.pop(sentence.length-wordcount)
-    sentence.join(' ')
-  end
-end

data/spec/marky_markov/one_word_dictionary_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper.rb'
-
-describe OneWordDictionary do
-  before(:each) do
-    @textsource = "spec/test.txt"
-    @dict = OneWordDictionary.new
-    @dict.parse_source("Hello how are you doing today", false)
-    @stringdict = {"Hello"   => {"how"        => 1},
-                     "how"     => {"are"        => 1},
-                     "are"     => {"you"        => 1},
-                     "you"     => {"doing"      => 1},
-                     "doing"   => {"today"      => 1},
-                     "today"   => {} }
-    @textdict = {"The" => {"cat"=>1},
-                 "and" => {"chainsaws"=>1},
-                 "cat" => {"likes"=>1},
-           "chainsaws" => {},
-               "likes" => {"pie"=>1},
-                 "pie" => {"and"=>1} }
-  end
-
-  it "can open a file" do
-    @dict.open_source(@textsource).should_not be_nil
-  end
-
-  it "should give a FileNotFoundError if the file doesn't exist" do
-    expect { @dict.open_source("thisisntreal") }.to 
-    raise_error(OneWordDictionary::FileNotFoundError,"thisisntreal does not exist!")
-  end
-
-  it "can add a word to the dictionary" do
-    @dict.add_word("to", "be")
-    @dict.dictionary.should include("to" => {"be" => 1})
-  end
-
-  it "create a dictionary via parsing a text file" do
-    @dict.dictionary = {}
-    @dict.parse_source(@textsource)
-    @dict.dictionary.should eql(@textdict)
-  end
-
-  it "builds a one word dictionary properly" do
-    @dict.dictionary.should eql(@stringdict)
-  end
-end

data/spec/marky_markov/two_word_dict_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe TwoWordDictionary do
-  before(:each) do
-    @dict = TwoWordDictionary.new
-    @dict.parse_source("The cat likes pie and chainsaws", false)
-    @textsource = "spec/test.txt"
-    @stringdict = { "The cat"       => { "likes"     => 1},
-                    "cat likes"     => { "pie"       => 1 },
-                    "likes pie"     => {"and"        => 1 },
-                    "pie and"       => { "chainsaws" => 1 },
-                    "and chainsaws" => {} }
-    @textdict = {"The cat"          => {"likes"      => 1},
-                 "cat likes"        => {"pie"        => 1},
-                 "likes pie"        => {"and"        => 1},
-                 "pie and"          => {"chainsaws"  => 1},
-                 "and chainsaws"    => {}}
-  end
-
-  it "can add a word to the two-word dictionary" do
-    @dict.add_word("Zebras like", "kung-fu")
-    @dict.dictionary.should eql(@stringdict.merge( {"Zebras like" => {"kung-fu" => 1}} ))
-  end
-
-  it "create a two-word dictionary via parsing a text file" do
-    @dict.dictionary = {}
-    @dict.parse_source(@textsource)
-    @dict.dictionary.should eql(@textdict)
-  end
-end
-

data/spec/marky_markov/two_word_sentence_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe TwoWordSentenceGenerator do
-  before(:each) do
-    @dict = TwoWordDictionary.new
-    @dict.parse_source("Hello man how are you today", false)
-    @sentence = TwoWordSentenceGenerator.new(@dict)
-  end
-
-  it "generates a sentence of the appropriate length" do
-    @sentence.generate(20).split.count.should eql(20)
-  end
-end