marky_markov 0.1.3 → 0.2.0

data/README.md

@@ -4,6 +4,11 @@ Marky Markov and the Funky Sentences
 Marky Markov is a naïve experiment in Markov Chain generation implemented
 in Ruby. It can be used both from the command-line and as a library within your code.
 
+NOTE: In the transition between 0.1.3 to 0.2.0 MarkyMarkov has added the
+ability to generate proper sentences (generate_n_sentences) instead of simply a
+maximum number of words. The command-line app has changed to sentences as its default
+behavior.
+
 # Installation
 
     gem install marky_markov
@@ -17,8 +22,8 @@ temporary dictionary that will not be saved to disk.
     markov = MarkyMarkov::TemporaryDictionary.new
     markov.parse_string "These words will be added to the temporary dictionary."
     markov.parse_file "filename.txt"
-    puts markov.generate_n_words 50
-    puts markov.generate_n_words 3000
+    puts markov.generate_n_sentences 5
+    puts markov.generate_n_words 200
     markov.clear!
     
 Dictionary creates or opens a persistent dictionary at a location defined by its 
@@ -31,18 +36,22 @@ of the dictionary name.
     markov.parse_file "ENV["HOME"]/Documents/largefileindocs.txt"
     markov.parse_file "anotherfileyay.txt"
     puts markov.generate_n_words 10
+    puts markov.generate_n_sentences 2
     markov.save_dictionary! # Saves the modified dictionary/creates one if it didn't exist.
 
-If you keep looking at generate_n_words and wonder why you can't put a
+If you keep looking at generate_n_words or generate_n_sentences and wonder why you can't put a
 number in there, well, you can!
 
+    markov.generate_7_sentences
     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
+but it can be set to a depth between 1 and 5 upon dictionary creation,
+though really any higher than 3 and it starts to simply print passages
+from the source text.
 
     markov = MarkyMarkov::Dictionary.new('dictionary', 3)
 
@@ -72,18 +81,18 @@ on different files to continue adding to your dictionary file.
 
 ## Say Some Words
 
-    marky_markov speak -w 30
+    marky_markov speak -c 3
 
-Will use the dictionary to create a 30 word long sentence. If no number
-is passed it will default to 200 words.
+Will use the dictionary to create three sentences. If no number
+is passed it will default to five sentences..
 
 ## Temporary Dictionaries 
 
-    marky_markov speak -s other-file.txt -w 20
+    marky_markov speak -s other-file.txt -c 8
 
 Generates a temporary dictionary based on the source file passed to it
 and uses that to speak. Here we're loading other-file.txt and
-restricting the generated sentence to 20 words.
+restricting the generated text to 8 sentences.
 
 ## STDIN, Pipe Away!
 
@@ -99,12 +108,15 @@ though the results are nonsense without a substantial text base to work
 from.
 
     Usage: marky_markov COMMAND [OPTIONS]
-        Commands:
-            speak: Generate Markov Chain sentence (default wordcount of 200)
-            listen [sentence]: Generate Markov Chain sentence from supplied string.
-            read [file]: Add words to dictionary from supplied text file
-        Options
-            -d, --dictionary FILE            Use custom dictionary location
-            -w, --wordcount NUMBER           Set number of words generated
-            -s, --source FILE                Generate and use temporary dictionary from source text
-            -h, --help                       Display this screen
+
+    Commands:
+        speak: Generate Markov Chain sentence (5 sentences by default)
+        listen [sentence]: Generate Markov Chain sentence from supplied string.
+        read [file]: Add words to dictionary from supplied text file
+
+    Options
+        -d, --dictionary LOCATION        Use custom dictionary location
+        -c, --sentencecount NUMBER       Set number of sentences generated
+        -s, --source FILE                Generate and use temporary dictionary from source text
+            --reset                      WARNING: Deletes default dictionary.
+        -h, --help                       Display this screen

data/bin/marky_markov

@@ -6,23 +6,23 @@ require 'marky_markov'
 
 options = {}
 opt_parser = OptionParser.new do |opts|
-  opts.banner = "Usage: marky-markov COMMAND [OPTIONS]"
+  opts.banner = "Usage: marky_markov COMMAND [OPTIONS]"
   opts.separator ""
   opts.separator "Commands:"
-  opts.separator "    speak: Generate Markov Chain sentence (default wordcount of 200)"
+  opts.separator "    speak: Generate Markov Chain sentence (5 sentences by default)"
   opts.separator "    listen [sentence]: Generate Markov Chain sentence from supplied string."
   opts.separator "    read [file]: Add words to dictionary from supplied text file"
   opts.separator ""
   opts.separator "Options"
 
   options[:dictionary] = "#{ENV["HOME"]}/.marky_markov_dictionary"
-  opts.on('-l', '--location DICTIONARY', 'Use custom dictionary location') do |file|
+  opts.on('-d', '--dictionary LOCATION', 'Use custom dictionary location') do |file|
     options[:dictionary] = file
   end
 
-  options[:wordcount] = 200
-  opts.on('-w', '--wordcount NUMBER', 'Set number of words generated') do |number|
-    options[:wordcount] = number.to_i
+  options[:sentencecount] = 5
+  opts.on('-c', '--sentencecount NUMBER', 'Set number of sentences generated') do |number|
+    options[:sentencecount] = number.to_i
   end
 
   options[:source] = nil
@@ -31,12 +31,6 @@ 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
@@ -58,7 +52,7 @@ end
 case ARGV[0]
 when "speak"
   if options[:source]
-    markov = MarkyMarkov::TemporaryDictionary.new(options[:depth])
+    markov = MarkyMarkov::TemporaryDictionary.new
     markov.parse_file(options[:source])
   else
     unless File.exists?("#{options[:dictionary]}.mmd")
@@ -68,22 +62,22 @@ when "speak"
     end
     markov = MarkyMarkov::Dictionary.new(options[:dictionary])
   end
-  STDOUT.puts markov.generate_n_words(options[:wordcount])
+  STDOUT.puts markov.generate_n_sentences(options[:sentencecount])
 when "read"
   source = ARGV[1] || options[:source]
-  markov = MarkyMarkov::Dictionary.new(options[:dictionary], options[:depth])
+  markov = MarkyMarkov::Dictionary.new(options[:dictionary])
   markov.parse_file(source)
   markov.save_dictionary!
   STDOUT.puts "Added #{source} to dictionary."
 when "listen"
   markov = MarkyMarkov::TemporaryDictionary.new
   markov.parse_string(STDIN.tty? ? ARGV[1] : STDIN.read)
-  STDOUT.puts markov.generate_n_words(options[:wordcount])
+  STDOUT.puts markov.generate_n_sentences(options[:sentencecount])
 else
   unless STDIN.tty?
-    markov = MarkyMarkov::TemporaryDictionary.new(options[:depth])
+    markov = MarkyMarkov::TemporaryDictionary.new
     markov.parse_string(STDIN.read)
-    STDOUT.puts markov.generate_n_words(options[:wordcount])
+    STDOUT.puts markov.generate_n_sentences(options[:sentencecount])
   else
     STDOUT.puts opt_parser
   end

data/lib/marky_markov.rb

@@ -4,12 +4,12 @@
 require_relative 'marky_markov/persistent_dictionary'
 require_relative 'marky_markov/markov_sentence_generator'
 
-# @version = 0.1.3
+# @version = 0.2.0
 # @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.3'
+  VERSION = '0.2.0'
 
   class TemporaryDictionary
     # Create a new Temporary Markov Chain Dictionary and sentence generator for use.
@@ -49,39 +49,62 @@ module MarkyMarkov
     #
     # @example Generate a 40 word long string of words.
     #   markov.generate_n_words(40)
+    # @example Generate a 10 word long string of words with method_missing.
+    #   markov.generate_10_words
     # @param [Int] wordcount the number of words you want generated.
     # @return [String] the sentence generated by the dictionary.
     def generate_n_words(wordcount)
       @sentence.generate(wordcount)
     end
 
-    # Dynamically call generate_n_words if an Int is substituted for
-    # the n in the method call.
+    # Generates n sentences using the dictionary generated via
+    # parse_string or parse_file. A sentence is defined as beginning with a
+    # capitalized word and ending with either a . ! or ?
     #
-    # @since 0.1.2
+    # @since 0.2.0
+    # @example Generate three sentences.
+    #   markov.generate_n_sentences(3)
+    # @example Generate six sentences with method_missing.
+    #   markov.generate_6_sentences
+    # @param [Int] wordcount the number of sentences you want generated.
+    # @return [String] the sentences generated by the dictionary.
+    def generate_n_sentences(sentencecount)
+      @sentence.generate_sentence(sentencecount)
+    end
+
+    # Dynamically call generate_n_words or generate_n_sentences
+    # if an Int is substituted for the n in the method call.
+    #
+    # @since 0.1.4
     # @example Generate a 40 and a 1 word long string of words.
     #   markov.generate_40_words
     #   markov.generate_1_word
+    # @example Generate 2 sentences
+    #   markov.generate_2_sentences
     # @return [String] the sentence generated by the dictionary.
     def method_missing(method_sym, *args, &block)
       if method_sym.to_s =~ /^generate_(\d*)_word[s]*$/
         generate_n_words($1.to_i)
+      elsif method_sym.to_s =~ /^generate_(\d*)_sentence[s]*$/
+        generate_n_sentences($1.to_i)
       else
         super
       end
     end
 
-    # @since 0.1.2
-    # Modify respond_to? to include generate_n_words method_missing implementation.
+    # @since 0.1.4
+    # Modify respond_to? to include generate_n_words and generate_n_sentences
+    # method_missing implementation.
     def respond_to?(method_sym, include_private = false)
       if method_sym.to_s =~ /^generate_(\d*)_word[s]*$/
-        true
+        generate_n_words($1.to_i)
+      elsif method_sym.to_s =~ /^generate_(\d*)_sentence[s]*$/
+        generate_n_sentences($1.to_i)
       else
         super
       end
     end
 
-
     # Clears the temporary dictionary's hash, useful for keeping
     # the same dictionary object but removing the words it has learned.
     #

data/lib/marky_markov/markov_sentence_generator.rb

@@ -20,13 +20,17 @@ class MarkovSentenceGenerator
   # dictionary and recurring if the word is lowercase.
   #
   # (see #random_word)
-  def random_capitalized_word
+  def random_capitalized_word(attempts=0)
     keys = @dictionary.dictionary.keys
     x = keys[rand(keys.length)]
     if /[A-Z]/ =~ x[0]
       return x
+    elsif attempts < 30
+      # If you don't find a capitalized word after 30 attempts, just use
+      # a lowercase word as there may be no capitals in the dicationary.
+      random_capitalized_word(attempts+1)
     else
-      random_capitalized_word
+      random_word
     end
   end
 
@@ -49,6 +53,8 @@ class MarkovSentenceGenerator
 
   # Generates a sentence of (wordcount) length using the weighted_random function.
   #
+  # @param [Int] wordcount The number of words you want the generated string to contain.
+  # @return [String] the words, hopefully forming sentences generated.
   def generate(wordcount)
     sentence = []
     sentence.concat(random_capitalized_word.split)
@@ -58,4 +64,27 @@ class MarkovSentenceGenerator
     sentence.pop(sentence.length-wordcount)
     sentence.join(' ')
   end
+
+  # Generates a (sentencecount) sentences using the weighted_random function.
+  #
+  # @param [Int] sentencecount The number of sentences you want the generated string to contain.
+  # @return [String] the sentence(s) generated.
+  def generate_sentence(sentencecount) 
+    sentence = []
+    sentencecount.times do
+      # Find out how many actual keys are in the dictionary.
+      key_count = @dictionary.dictionary.keys.length
+      # If less than 30 keys, use that plus five as your maximum sentence length.
+      maximum_length = key_count < 30 ? key_count + 5 : 30
+      stop_at_index = sentence.count + maximum_length
+      sentence.concat(random_capitalized_word.split)
+      until (/[.!?]/ =~ sentence.last[-1])
+        sentence.concat(weighted_random(sentence.last(@depth).join(' ')).split)
+        # If a word ending with a . ! or ?  isn't found after 30 words,
+        # just add a period as there may be none in the dictionary.
+        sentence[-1] << "." if sentence.count > stop_at_index
+      end
+    end
+    sentence.join(' ')
+  end
 end

data/lib/marky_markov/persistent_dictionary.rb

@@ -15,8 +15,8 @@ class PersistentDictionary < MarkovDictionary
   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")
+    unless (1..5).include?(depth)
+      raise DepthNotInRangeError.new("Depth must be between 1 and 5")
     end
     @dictionarylocation = dictionary
     self.open_dictionary

data/spec/test.txt

@@ -0,0 +1 @@
+The cat likes pie and chainsaws

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marky_markov
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70361383496140 !ruby/object:Gem::Requirement
+  requirement: &70254574670860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -24,7 +24,7 @@ dependencies:
         version: 2.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70361383496140
+  version_requirements: *70254574670860
 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
@@ -46,6 +46,7 @@ files:
 - spec/marky_markov/markov_sentence_generator_spec.rb
 - spec/marky_markov/persistent_dictionary_spec.rb
 - spec/spec_helper.rb
+- spec/test.txt
 - spec/textdictcompare.mmd
 homepage: http://www.thefurd.com
 licenses: []