two_chainz 0.0.0 → 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright 2013 Jake Boxer
+http://jakeboxer.com/
+
+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,69 @@
+# Two Chainz
+
+> She got a big booty so I call her Big Booty  
+> Scrr... scrr... wrists moving, cooking, getting to it  
+> I'm in the kitchen, yams everywhere  
+> Just made a jug, I got bands everywhere  
+>   
+– [2 Chainz - Birthday Song](http://rapgenius.com/2-chainz-birthday-song-lyrics) (which was generated entirely with this gem)
+
+**Two Chainz** is a Ruby gem for generating random sentences with [Markov chains](http://en.wikipedia.org/wiki/Markov_chain).
+
+## Quickstart
+
+``` ruby
+require 'two_chainz'
+
+generator = TwoChainz::Generator.new
+
+generator.hear("We just want the credit where it's due")
+generator.hear("Imma worry bout me, give a fuck about you")
+generator.hear("Just as a reminder to myself")
+generator.hear("I wear every single chain even when I'm in the house")
+
+generator.spit(:words => 12) # => "We just as a fuck chain even when I'm in the credit"
+```
+
+## Less important shit
+
+If you instantiate the generator normally, spitting will be random.
+
+``` ruby
+generator = TwoChainz::Generator.new
+
+generator.hear("I love you I love you")
+generator.hear("You are alright I guess")
+
+generator.spit(:words => 2) # => "I guess"
+generator.spit(:words => 2) # => "You I"
+```
+
+You can seed the generator if you want consistency.
+
+``` ruby
+generator = TwoChainz::Generator.new(:seed => 3)
+```
+
+If you want even more consistency, run it in boring mode. This will always continue the chain the same way: the most common next word is picked every time, and the alphabetically-first word is picked if there's a tie.
+
+``` ruby
+generator = TwoChainz::Generator.new(:boring => true)
+
+generator.hear("I love you I love you I love you")
+generator.hear("You are alright I guess")
+
+generator.spit(:words => 2) # => "I love"
+generator.spit(:words => 2) # => "I love"
+```
+
+Instead of specifying how many words you want, you can specify a maximum number of characters. You'll get a sentence that is guaranteed to be that many characters or fewer (and it will usually come pretty close).
+
+``` ruby
+generator = TwoChainz::Generator.new
+
+generator.hear("Once they caught us off-guard")
+generator.hear("The Mac-10 was in the grass and")
+generator.hear("I ran like a cheetah with thoughts of an assassin")
+
+generator.spit(:max_chars => 20) # => "Once they cheetah"
+```

data/lib/two_chainz.rb

@@ -1,5 +1,2 @@
-class TwoChainz
-  def self.hi
-    puts "Hello world!"
-  end
-end
+require 'two_chainz/generator'
+require 'two_chainz/words_table'

data/lib/two_chainz/generator.rb

@@ -0,0 +1,110 @@
+class TwoChainz::Generator
+  # Public: Create a new TwoChainz::Generator instance.
+  #
+  # options - Hash of options.
+  #           :seed -   (Optional integer) Seed to use when spitting. If nothing
+  #                     is provided, Ruby core's Random::new_seed will be used.
+  #           :boring - (Optional boolean) Don't do any randomness. Always pick
+  #                     the most common thing. Mainly for testing. Defaults to
+  #                     false.
+  #
+  # Returns a TwoChainz::Generator
+  def initialize(options={})
+    @words_table = TwoChainz::WordsTable.new
+
+    unless options[:boring]
+      seed    = options[:seed]
+      @random = seed ? Random.new(seed) : Random.new
+    end
+  end
+
+  # Public: Hear some words and remember them for future spitting.
+  #
+  # words - String of words to hear.
+  #
+  # Returns the number of unique new words the generator heard (integer)
+  def hear(words)
+    heard_words   = 0
+    previous_word = nil
+
+    words.scan(/[\w\']+/) do |current_word|
+      # If we haven't heard this word before, increment the newly-heard words
+      # count.
+      heard_words += 1 unless @words_table.include?(current_word)
+
+      # Increment the number of times the current word has been the successor of
+      # the previous word.
+      @words_table.increment(previous_word, current_word)
+
+      previous_word = current_word
+    end
+
+    # Record what the last word was.
+    @words_table.increment(previous_word) if previous_word
+
+    heard_words
+  end
+
+  # Public: Produce a randomized sentence based on the words that have been
+  # heard.
+  #
+  # options - Hash of options. At least one is required.
+  #           :words - (Integer) the number of words to be generated.
+  #           :max_chars - (Integer) the maximum number of characters to be
+  #                        generated.
+  #
+  # Returns a string.
+  def spit(options = {})
+    if @words_table.words.empty?
+      raise StandardError, "The generator hasn't heard anything yet"
+    end
+
+    words     = options[:words] && Integer(options[:words])
+    max_chars = options[:max_chars] && Integer(options[:max_chars])
+
+    sentence = []
+
+    if words
+      words.times do |i|
+        previous_word = sentence.last || :beginning
+        sentence << word_after(previous_word)
+      end
+    elsif max_chars
+      sentence_length = -1 # Start at -1 cuz of the first space
+
+      while sentence_length < max_chars
+        previous_word    = sentence.last || :beginning
+        word             = word_after(previous_word)
+        sentence_length += word.length + 1 # Include space
+
+        sentence << word_after(previous_word) unless sentence_length > max_chars
+      end
+    else
+      raise ArgumentError, "Either :words or :max_chars must be specified"
+    end
+
+    sentence.join(' ')
+  end
+
+  private
+
+  # Internal: Get a word that comes after the specified one.
+  #
+  # previous_word - The word that will be coming before whichever one we pick.
+  #
+  # Returns a string.
+  def word_after(previous_word)
+    choices = @words_table.words_after(previous_word)
+
+    # Pick the most popular next word.
+    # TODO(jakeboxer): Make this random in non-boring situations.
+    next_word = choices.max_by {|word, count| count}.first
+
+    # If the most popular next word is the sentence ending, pick the
+    # alphabetical first word.
+    # TODO(jakeboxer): Make this random in non-boring situations.
+    next_word = heard_words.sort.first if next_word == :ending
+
+    next_word
+  end
+end

data/lib/two_chainz/version.rb

@@ -0,0 +1,3 @@
+module TwoChainz
+  VERSION = '0.0.1'
+end

data/lib/two_chainz/words_table.rb

@@ -0,0 +1,79 @@
+class TwoChainz::WordsTable
+  # Public: Create a new TwoChainz::WordsTable instance.
+  #
+  # Returns a TwoChainz::WordsTable
+  def initialize
+    # The table is a hash. Think of its entries as "rows".
+    # Each row is another hash. Think of its entries as "cells".
+    # Cells default to 0.
+    @table = {}
+  end
+
+  # Public: Increment the value in the table for the specified pair of words.
+  #
+  # first_word  - The word that comes first in the pair. If this is nil, the
+  #               second word in the pair will be recorded as the beginning of
+  #               a sentence.
+  # second_word - The word that comes last in the pair. If this is nil or
+  #               omitted, the first word in the pair will be recorded as the
+  #               ending of a sentence.
+  #
+  # Returns the new count of the entry.
+  def increment(first_word=nil, second_word=nil)
+    # Don't do anything if we didn't get a first or second word
+    return 0 unless first_word || second_word
+
+    # Only one of these will run, since we error if both are nil
+    first_word  ||= :beginning
+    second_word ||= :ending
+
+    add_row(first_word)
+    add_row(second_word) unless second_word == :ending
+
+    @table[first_word][second_word]  += 1
+  end
+
+  # Public: Whether or not the words table has the specified word.
+  #
+  # word - Word to check for inclusion of.
+  #
+  # Returns a boolean
+  def include?(word)
+    @table.keys.include?(word)
+  end
+
+  # Public: Get all the words that have been incremented at least once.
+  #
+  # Returns an array.
+  def words
+    @table.keys - [:beginning]
+  end
+
+  # Public: Get all the words that have come after the specified word. In the
+  # result, the keys are the words and the values are the number of times that
+  # word has appeared after the specified word.
+  #
+  # Can also include the :ending key, which indicates that the sentence ended
+  # after that word.
+  #
+  # word - Word to find all following words for
+  #
+  # Examples
+  #
+  #   increment('your', 'love')
+  #   increment('your', 'time')
+  #   increment('your', 'love')
+  #   words_after('your')
+  #   # => {"love" => 2, "time" => 1}
+  #
+  # Returns a hash.
+  def words_after(word)
+    Hash[@table[word] || {}]
+  end
+
+  private
+
+  def add_row(word)
+    @table[word] ||= Hash.new(0)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: two_chainz
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -18,7 +18,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/two_chainz/generator.rb
+- lib/two_chainz/version.rb
+- lib/two_chainz/words_table.rb
 - lib/two_chainz.rb
+- LICENSE
+- README.md
 homepage: https://github.com/jakeboxer/two_chainz
 licenses: []
 post_install_message: 
@@ -30,13 +35,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.6
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23