haiku_gadget 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75568a716d660a54f00260d61cd5b3bc14ba0f6b
+  data.tar.gz: e2d7daf568e3bd89a06d0eccb7c8645d5cd0c72f
+SHA512:
+  metadata.gz: 8cb8195d7034a929b025f3dbb3c6b5e9345129d925173202ff4e00267b6afc4b4509a1a344851fe824219822e96fd46d95d7bfd2a4d0344dbd80341cb6c4ede6
+  data.tar.gz: 07af0a0277613866bfacee4479f5c4775632ce4e8825d23c8e2ac0959a96de4776609dc61c6418b1cc146ff6476fca0e3021c71709e0e535c7fff40438df0313

data/.gitignore

@@ -0,0 +1,19 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp
+
+Gemfile.lock
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Scott Balay
+
+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,61 @@
+# Haiku Gadget
+
+Generate random haikus!
+
+Uses an algorithm, a custom dictionary, some grammar rules, and a team of hamsters running in wheels.
+
+## What is a haiku?
+
+A short poem consisting of three lines:
+
+    five syllables here
+    then seven syllables here
+    then five syllables
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'haiku_gadget'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install haiku_gadget
+
+## Usage
+
+First, turn on the gadget:
+
+    require 'haiku_gadget'
+
+Get a random haiku as an array of three lines:
+
+    HaikuGadget.haiku
+
+Or pass in a delimiter, which will return the haiku as a single string:
+
+    HaikuGadget.haiku ' / '
+
+To get a single random line, try one of these methods:
+
+    HaikuGadget.top_line
+    HaikuGadget.middle_line
+    HaikuGadget.bottom_line
+
+Or specify the line you want by an index:
+
+    HaikuGadget.random_line 0
+    HaikuGadget.random_line 1
+    HaikuGadget.random_line 2
+
+## Contributing
+
+1. Fork it ( http://github.com/zenblender/haiku_gadget/fork )
+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 @@
+require "bundler/gem_tasks"

data/haiku_gadget.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haiku_gadget/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "haiku_gadget"
+  spec.version       = HaikuGadget::VERSION
+  spec.authors       = ["Scott Balay"]
+  spec.email         = ["sbalay@gmail.com"]
+  spec.summary       = %q{Random haiku generator}
+  spec.description   = %q{i know you want it / random poetic nonsense / just click a button}
+  spec.homepage      = "http://github.com/zenblender/haiku_gadget"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec" , "~> 3.1"
+end

data/lib/haiku_gadget.rb

@@ -0,0 +1,2 @@
+require File.expand_path('haiku_gadget/version.rb', File.dirname(__FILE__))
+require File.expand_path('haiku_gadget/haiku_gadget.rb', File.dirname(__FILE__))

data/lib/haiku_gadget/dictionary.rb

@@ -0,0 +1,147 @@
+require 'yaml'
+
+require File.expand_path('word_type.rb', File.dirname(__FILE__))
+
+module HaikuGadget
+
+  module Dictionary
+
+    DEFAULT_DICT_PATH = '../words.yml'
+
+    WORD_TYPES = {
+      determiner:             WordType.new(:determiner, true),
+      to_be:                  WordType.new(:to_be, true),
+      adjective:              WordType.new(:adjective, true),
+      noun:                   WordType.new(:noun, true, :plural),
+      mass_noun:              WordType.new(:mass_noun),
+      mass_noun_determiner:   WordType.new(:mass_noun_determiner),
+      verb:                   WordType.new(:verb, true, :singular),
+      verb_self:              WordType.new(:verb_self, true, :singular),
+      adverb:                 WordType.new(:adverb),
+      transition_join:        WordType.new(:transition_join)
+    }
+
+    def self.suffixed_symbol(base_symbol, suffix_symbol)
+      "#{base_symbol.to_s}_#{suffix_symbol.to_s}".to_sym
+    end
+
+    # copies words from _common into _singular and _plural
+    # modifies dict structure in place, doesn't return anything of consequence
+    def self.complete_plurality(dict, word_type)
+
+      # words that have no plurality considerations don't need to do anything here
+      return unless word_type.can_be_plural
+
+      base_symbol = word_type.base_symbol
+
+      common_symbol = Dictionary.suffixed_symbol base_symbol, :common
+
+      plural_symbols = [:singular, :plural]
+      symbols = [
+        Dictionary.suffixed_symbol(base_symbol, :singular),
+        Dictionary.suffixed_symbol(base_symbol, :plural)
+      ]
+
+      # make sure there is a common list structure
+      dict[common_symbol] ||= []
+
+      # make sure there are singular/plural word list structures
+      symbols.each do |symbol|
+        dict[symbol] ||= []
+      end
+
+      plural_symbols.each do |plural_symbol|
+
+        symbol = Dictionary.suffixed_symbol base_symbol, plural_symbol
+
+        # make sure singular and plural structures exist
+        dict[symbol] ||= []
+
+        # make array lengths equal to the max of the common, singular and plural arrays
+        while dict[symbol].length < [symbols.map { |s| dict[s].length }, dict[common_symbol].length].flatten.max
+          dict[symbol] << []
+        end
+
+        # add common words to current word list, respecting syllables and plurality
+        dict[symbol].each_index do |i|
+          if word_type.add_s_target == plural_symbol
+            # currently building a list in which the words should have an 's' added when copying from _common
+            dict[symbol][i] += Dictionary.add_s_to_all(dict[common_symbol][i]) if dict[common_symbol][i]
+          else
+            # not adding an 's' in this case, or building the singular word list
+            dict[symbol][i] += dict[common_symbol][i] if dict[common_symbol][i]
+          end
+        end
+      end
+
+    end
+
+    def self.add_s_to_all(word_list)
+      out = []
+      word_list.each do |word_or_array|
+        if word_or_array.is_a? Array
+          # recursively call again and add the nested array
+          out << Dictionary.add_s_to_all(word_or_array)
+        else
+          out << "#{word_or_array}s"
+        end
+      end
+      out
+    end
+
+    # force load of dictionary from yaml file now
+    def self.load(path = DEFAULT_DICT_PATH)
+      dict = YAML.load_file(File.expand_path(path, File.dirname(__FILE__)))
+
+      WORD_TYPES.each do |k, wt|
+        Dictionary.complete_plurality(dict, wt)
+      end
+
+      #ap dict
+
+      dict
+    end
+
+    # load dictionary if not yet done, using default dictionary yaml path
+    def self.init
+      @@dict ||= load
+    end
+
+    # force load/reload of dictionary, optionally passing a custom path to a dictionary yaml file
+    def self.init!(path = DEFAULT_DICT_PATH)
+      @@dict = load path
+    end
+
+    # if available, returns a random word of the given type and number of syllables
+    def self.get_word(word_type, syllables, plurality = :none)
+
+      Dictionary.init
+
+      # validate word_type
+      return nil unless word_type
+
+      # validate syllables input
+      return nil unless syllables.is_a?(Fixnum) && syllables > 0
+
+      dict_symbol = word_type.dict_symbol plurality
+      if @@dict[dict_symbol] && @@dict[dict_symbol][syllables - 1]
+        word_or_array = @@dict[dict_symbol][syllables - 1].sample
+        while word_or_array.is_a? Array
+          # this item contains a nested list of items (to limit chances of nested item being selected)
+          # sample from nested array and try again to find a word ("leaf node")
+          word_or_array = word_or_array.sample
+        end
+        # current item is a word and not a nested list, return it
+        word_or_array
+      else
+        nil
+      end
+    end
+
+    def self.words?(word_type, syllables, plurality = :none)
+      !Dictionary.get_word(word_type, syllables, plurality).nil?
+    end
+
+  end
+
+end

data/lib/haiku_gadget/haiku_gadget.rb

@@ -0,0 +1,54 @@
+require File.expand_path('haiku_template.rb', File.dirname(__FILE__))
+
+module HaikuGadget
+
+  # returns a haiku as either a single string or an array of strings, based on whether a delimiter was provided
+  def self.haiku(delim = nil, haiku_template = nil)
+    if delim.nil?
+      # no delimiter, return array
+      haiku_lines haiku_template
+    else
+      # use delimiter and return a single string
+      haiku_string delim, haiku_template
+    end
+  end
+
+  # return a single string where the lines are separated by the provided delimiter
+  def self.haiku_string(delim, haiku_template)
+    haiku_lines(haiku_template).join delim
+  end
+
+  # return haiku as an array of lines (strings)
+  def self.haiku_lines(haiku_template)
+    if haiku_template.nil?
+      HaikuTemplate.new.generate
+    else
+      haiku_template.generate
+    end
+  end
+
+  def self.top_line(word_templates = nil)
+    HaikuGadget.random_line(0, word_templates)
+  end
+
+  def self.middle_line(word_templates = nil)
+    HaikuGadget.random_line(1, word_templates)
+  end
+
+  def self.bottom_line(word_templates = nil)
+    HaikuGadget.random_line(2, word_templates)
+  end
+
+  # return just a single random line
+  def self.random_line(row_index, word_templates = nil)
+    fail "invalid row_index: #{row_index.to_s}" unless (0..2).include?(row_index)
+    if word_templates.nil?
+      # get a random template defined for the current row
+      word_templates = HaikuTemplate.new.template_matrix[row_index]
+    end
+    # generate a HaikuTemplate object that only contains a single line with the desired template
+    haiku_template = HaikuTemplate.new [word_templates]
+    haiku_template.generate[0]
+  end
+
+end

data/lib/haiku_gadget/haiku_template.rb

@@ -0,0 +1,228 @@
+require File.expand_path('word_template.rb', File.dirname(__FILE__))
+require File.expand_path('dictionary.rb', File.dirname(__FILE__))
+
+module HaikuGadget
+
+  class HaikuTemplate
+
+    attr_reader :template_matrix
+
+    COMMON_LINES = [
+      [
+        WordTemplate.new(:determiner, 0, :any, 1),
+        WordTemplate.new(:noun, 1, :any, 1),
+        WordTemplate.new(:verb, 1, :any, 1),
+        WordTemplate.new(:mass_noun_determiner),
+        WordTemplate.new(:mass_noun, 1)
+      ], [
+        WordTemplate.new(:adverb, 2),
+        WordTemplate.new(:verb, 1, :plural),
+        WordTemplate.new(:adjective, 0, :plural),
+        WordTemplate.new(:noun, 1, :plural)
+      ], [
+        WordTemplate.new(:mass_noun_determiner),
+        WordTemplate.new(:adjective, 0, :common),
+        WordTemplate.new(:mass_noun, 1),
+        WordTemplate.new(:to_be, 1, :singular),
+        WordTemplate.new(:adjective, 1, :any)
+      ], [
+        WordTemplate.new(:determiner, 0, :any, 1),
+        WordTemplate.new(:noun, 1, :any, 1),
+        WordTemplate.new(:verb, 1, :any, 1),
+        WordTemplate.new(:determiner, 0, :any, 2),
+        WordTemplate.new(:noun, 1, :any, 2)
+      ], [
+        WordTemplate.new(:determiner, 0, :any, 1),
+        WordTemplate.new(:adjective, 0, :any, 1),
+        WordTemplate.new(:noun, 1, :any, 1),
+        WordTemplate.custom('of', 1),
+        WordTemplate.new(:mass_noun, 1),
+        WordTemplate.new(:verb_self, 1, :any, 1)
+      ], [
+        WordTemplate.custom(%w(i we they), 1),
+        WordTemplate.new(:verb, 1, :plural),
+        WordTemplate.new(:determiner, 0, :any, 2),
+        WordTemplate.new(:adjective, 0, :any, 2),
+        WordTemplate.new(:noun, 1, :any, 2),
+        WordTemplate.new(:adverb)
+      ]
+    ]
+
+    MIDDLE_LINES = [
+      [
+        WordTemplate.new(:transition_join),
+        WordTemplate.new(:determiner, 0, :any, 1),
+        WordTemplate.new(:adjective, 0, :any, 1),
+        WordTemplate.new(:noun, 1, :any, 1),
+        WordTemplate.new(:verb_self, 1, :any, 1),
+        WordTemplate.new(:adverb)
+      ]
+    ]
+
+    BOTTOM_LINES = [
+      [
+        WordTemplate.new(:transition_join),
+        WordTemplate.new(:adjective, 0, :plural, 1),
+        WordTemplate.new(:noun, 1, :plural, 1),
+        WordTemplate.new(:verb_self, 1, :plural, 1)
+      ]
+    ]
+
+    ALL_TOP_LINES = [
+      COMMON_LINES
+    ].flatten(1)
+
+    ALL_MIDDLE_LINES = [
+      COMMON_LINES,
+      MIDDLE_LINES
+    ].flatten(1)
+
+    ALL_BOTTOM_LINES = [
+      COMMON_LINES,
+      BOTTOM_LINES
+    ].flatten(1)
+
+    def initialize(template_matrix = nil)
+      # generate a template_matrix randomly if one was not provided
+      if template_matrix.nil?
+        template_matrix = [
+          HaikuTemplate.random_template(ALL_TOP_LINES),
+          HaikuTemplate.random_template(ALL_MIDDLE_LINES),
+          HaikuTemplate.random_template(ALL_BOTTOM_LINES)
+        ]
+      end
+      # clone the two-dimensional array (so syllable counts can be changed)
+      @template_matrix = template_matrix.map { |tm| tm.map { |wt| wt.clone } }
+      complete_template
+    end
+
+    def generate
+      lines = []
+      @template_matrix.each do |word_templates|
+        words = HaikuTemplate.real_words_from_templates word_templates
+        lines << words.join(' ')
+      end
+      lines
+    end
+
+    private
+
+      def complete_template
+        complete_template_plurality
+        complete_template_syllables
+      end
+
+      def complete_template_plurality
+        @template_matrix.each do |word_templates|
+          obj_pluralities = []
+          word_templates.each do |word_template|
+            if word_template.plurality == :any
+              # need to pick a plurality for this word
+              if word_template.obj_num > 0
+                # this word is referencing an object, and its plurality can be randomized
+                unless obj_pluralities[word_template.obj_num]
+                  # this word's plurality has not already been determined via another word on this line
+                  obj_pluralities[word_template.obj_num] = [:singular, :plural].sample
+                end
+                word_template.plurality = obj_pluralities[word_template.obj_num]
+              else
+                word_template.plurality = [:singular, :plural].sample
+              end
+            end
+          end
+        end
+      end
+
+      def complete_template_syllables
+        syllables = [5, 7, 5]
+        @template_matrix.each_index do |i|
+          while HaikuTemplate.row_syllables(@template_matrix[i]) < syllables[i]
+            increased_syllable_index = HaikuTemplate.increase_row_syllable(@template_matrix[i])
+            break if increased_syllable_index.nil?
+          end
+        end
+      end
+
+      def self.real_words_from_templates(word_templates)
+        words = []
+        word_templates.each do |word_template|
+          if word_template.syllables > 0
+            word = word_template.word_type.get_word(
+              word_template.syllables,
+              word_template.plurality
+            )
+            words << word
+          end
+        end
+        HaikuTemplate.convert_a_to_an words
+        words
+      end
+
+      # where necessary, convert 'a' to 'an'
+      def self.convert_a_to_an(words)
+        words.each_index do |i|
+          if words[i] == 'a' && (i < (words.length - 1)) && %w(a e i o u).include?(words[i + 1].slice(0))
+            # current word is 'a', there are more words after this one, and the next one starts with a, e, i, o or u
+            words[i] = 'an'
+          end
+        end
+      end
+
+      def self.row_syllables(word_templates)
+        word_templates.map { |w| w.syllables }.inject(:+)
+      end
+
+      def self.increase_row_syllable(word_templates)
+        valid_word_indices = HaikuTemplate.get_valid_word_indices word_templates
+
+        increase_syllable_index = nil
+        loop do
+          increase_syllable_index = HaikuTemplate.increased_row_syllable_index(word_templates, valid_word_indices)
+          break if increase_syllable_index || valid_word_indices.length == 0
+        end
+        if increase_syllable_index
+          word_templates[increase_syllable_index].syllables += 1
+          increase_syllable_index
+        else
+          nil
+        end
+      end
+
+      def self.get_valid_word_indices(word_templates)
+        out = []
+        word_templates.each_index do |i|
+          out << i unless word_templates[i].word_type.base_symbol == :custom
+        end
+        out
+      end
+
+      # returns the word index where another syllable can be added (and where dictionary words are available)
+      def self.increased_row_syllable_index(word_templates, valid_word_indices)
+        if valid_word_indices.length > 0
+          word_index = valid_word_indices.sample
+          if word_templates[word_index].word_type.words?(
+            word_templates[word_index].syllables + 1,
+            word_templates[word_index].plurality
+          )
+            word_index
+          else
+            # dictionary has no words of this type, remove this index so it isn't checked in the future
+            valid_word_indices.delete word_index
+            nil
+          end
+        end
+      end
+
+      def self.random_template(templates)
+        template_or_array = templates.sample
+        if template_or_array[0].is_a? Array
+          # if NESTED object is an array, recurse
+          HaikuTemplate.random_template template_or_array
+        else
+          template_or_array
+        end
+      end
+
+  end
+
+end

data/lib/haiku_gadget/version.rb

@@ -0,0 +1,5 @@
+module HaikuGadget
+
+  VERSION = '1.0.0'
+
+end

data/lib/haiku_gadget/word_template.rb

@@ -0,0 +1,44 @@
+require File.expand_path('word_type.rb', File.dirname(__FILE__))
+
+module HaikuGadget
+
+  class WordTemplate
+
+    attr_reader :word_type, :obj_num
+    attr_accessor :syllables, :plurality
+
+    def initialize(base_symbol_or_word_type, syllables = 0, plurality = :none, obj_num = 0)
+
+      if base_symbol_or_word_type.is_a? HaikuGadget::WordType
+        # use provided (custom) WordType
+        word_type = base_symbol_or_word_type
+      else
+        # look up word type based on symbol
+        word_type = Dictionary::WORD_TYPES[base_symbol_or_word_type]
+      end
+
+      fail 'unknown word type' unless word_type
+
+      # check if template plurality needs to be set or changed
+      if word_type.can_be_plural
+        plurality = :any if plurality == :none
+      else
+        plurality = :none
+      end
+
+      @word_type = word_type
+      @syllables = syllables
+      @plurality = plurality
+      @obj_num = obj_num
+
+    end
+
+    def self.custom(word_list, syllables)
+
+      WordTemplate.new WordType.custom(word_list), syllables
+
+    end
+
+  end
+
+end

data/lib/haiku_gadget/word_type.rb

@@ -0,0 +1,55 @@
+module HaikuGadget
+
+  class WordType
+
+    attr_reader :base_symbol, :can_be_plural, :add_s_target
+
+    def initialize(base_symbol, can_be_plural = false, add_s_target = nil, custom_words = [])
+      @base_symbol = base_symbol
+      @can_be_plural = can_be_plural
+      @add_s_target = add_s_target
+
+      # make sure custom_words is an array (allows convenient input of a single string)
+      @custom_words = custom_words.is_a?(Array) ? custom_words : [custom_words]
+    end
+
+    def self.custom(custom_words = [])
+      WordType.new :custom, false, nil, custom_words
+    end
+
+    # translates the base symbol type into a _singular or _plural one if necessary
+    # for doing dictionary lookups
+    def dict_symbol(plurality)
+      # do not allow plurality of :none for a word that has plurality
+      # this is a redundant error check and should not happen
+      plurality = [:singular, :plural].sample if @can_be_plural && plurality == :none
+
+      if @can_be_plural && [:singular, :plural].include?(plurality)
+        # word can be plural
+        "#{@base_symbol.to_s}_#{plurality.to_s}".to_sym
+      else
+        # word type is not relevent to plurality
+        @base_symbol
+      end
+    end
+
+    def get_word(syllables, plurality = :none)
+      if base_symbol == :custom
+        @custom_words.sample
+      else
+        Dictionary.get_word self, syllables, plurality
+      end
+    end
+
+    def words?(syllables, plurality = :none)
+      if base_symbol == :custom
+        !get_word(syllables, plurality).nil?
+      else
+        Dictionary.words? self, syllables, plurality
+      end
+    end
+
+  end
+
+
+end

data/lib/words.yml

@@ -0,0 +1,106 @@
+---
+:transition_join: [
+    [so, and, or, plus, but, yet, while, when, if, then, thus, hence, now]
+  ]
+
+:determiner_common: [
+    [the, [no, some, your, my, his, her, its, their, our]]
+  ]
+:determiner_singular: [
+    [a, [this, that]]
+  ]
+:determiner_plural: [
+    [all, both, few, most, [these, those]]
+  ]
+
+:to_be_singular: [
+    [is, was],
+    [[is not, 'isn''t'], [was not, 'wasn''t'], will be]
+  ]
+:to_be_plural: [
+    [are, were],
+    [[are not, 'aren''t'], [were not, 'weren''t'], will be]
+  ]
+
+:adjective_common: [
+    [red, fresh, weird, burnt, white, flat, round, weak, old, new, young, swell, sweet, dazed, vague, warmed, cool, strong, blue, clear, soft, hard, black, big, small, tight, loose, long, short, wry, young, green, bold, good, bad, kind, mean, wet, dry, free, light, dark, dim, wise, grim, huge, worn, numb, wild, tall, short, hot, cold, sad, gray, green, gold, raw, rich, poor, bored, dull, calm, smart, dumb, grand, keen, bright, bent, foul, close, chrome, low, last, first, next, fun, high, late, quaint, side, top, lost, cute, real, strict, [north, west, south, east]],
+    [orange, mental, tired, gloomy, murky, salty, doomed, ecstatic, balanced, frayed, frosted, confused, opened, tasty, frozen, boiling, slimy, failed, crazed, oblong, broken, silver, faulty, limestone, opaque, silly, spinning, busted, lazy, flying, awesome, folded, rhythmic, floating, smoking, twisted, wispy, uncooked, complex, bubbly, immobile, bankrupt, moving, crispy, laundered, rounded, cleaned, ample, dirty, catered, constrained, cosmic, choking, ballistic, red-faced, bizarre, sanded, roasted, inverted, spastic, dapper, swanky, able, fabled, stable, leaning, correct, staggered, wrong, curved, open, evil, closed, edgy, pricey, costly, fancy, stranded, meager, modest, humble, slimy, simple, unkind, unwound, teenage, heavy, standard, hollow, eager, rotten, unwise, grounded, boring, crazy, major, minor, naive, valid, random, happy, endless, human, splendid, certain, somber, livid, lonely, jealous, dreary, lovely, cheerful, secure, renowned, spicy, drunken, bulky, breaded, better, shorter, smaller, larger, smarter, faster, longer, distant, wealthy, dismayed, vital, colored, abstract, vivid, ancient, bitter, sour, airy, timely, sunny, current, funky, skinny, bloody, girly, boyish, roomy, royal, marine, varied, fuzzy, helpful, crafty, [northern, western, southern, eastern]],
+    [redundant, respected, uncovered, populous, required, unstable, communist, communal, religious, circular, feminine, masculine, incorrect, underwater, embarrassed, misshapen, glorious, hovering, uncaring, expanded, insulted, discovered, commissioned, considered, opulent, casual, ultimate, imminent, exacting, creative, furious, destructive, modulated, digital, analog, essential, albino, nuclear, atomic, chocolate, overweight, invalid, possible, advertised, natural, terrific, pot-bellied, amazing, confident, exacting, finished, primary, lunatic, satisfied, impressive, lunatic, noteworthy, suitable, musical, eternal, skydiving, expected, parallel],
+    [undulating, incredible, unforgiving, acceptable, elaborate, necessary, stimulated, measurable, recommended, mandatory, honorable, identical, overstated, altruistic, generated, extraneous, aluminum, obfuscated, appropriate, symbiotic, calculated, mysterious, unknowable, beautiful, contemplative, incapable, overbearing, high quality, low quality, microbial, questionable, knowledgeable, elemental, hilarious, inferior, meticulous]
+  ]
+:adjective_singular: [
+    [one]
+  ]
+:adjective_plural: [
+    [two, three, four, [five, six, eight, nine, ten, twelve]],
+    [zero, many, seven, twenty, thirty, [thirteen, fourteen, fifteen, sixteen, eighteen, nineteen, forty, fifty]],
+    [one hundred, several, numerous]
+  ]
+
+:noun_common: [
+    [thing, bug, head, toe, eye, phone, web, ball, hand, ear, sheet, bed, car, truck, plane, brain, day, sun, square, bike, lake, creek, stone, moon, shoe, yacht, field, task, thought, sword, wig, boy, girl, prince, kid, pet, fig, moth, dog, bun, cat, bat, oar, lip, grain, soul, ape, duck, ray, beam, leg, rat, bear, boar, boat, door, goon, gob, plank, brick, stake, cube, ant, cord, bowl, chord, crate, wire, wreath, spear, isle, tree, wheel, hut, hat, gnat, spot, pond, cork, star, tribe, wine, beer, drink, film, bum, cup, rock, hook, path, king, queen, jack, mob, skill, job, house, cow, chair, disk, pit, hole, card, face, hill, mound, knob, zoo, light, fool, pill, quark, cloud, glove, sock, boot, slave, shrub, cook, pie, bird, snake, worm, tank, pen, weed, flute, nest, pot, bee, pan, gem, mom, dad, son, jeep, train, nun, pal, month, year, week, poem, shark, yak, joke, owl, skunk, worm, egg, cake, pea, grape, bean, spore, seed, fruit, wing, fire, world, heart, rod, board, nail, end, ring, sea, key, god, word, night, knight, bone, room, toy, side, top, book, name, game, ship, test, park, time, bag, school, clone, shop, store],
+    [zombie, ninja, pirate, monkey, robot, hot dog, space ship, rain drop, circle, tv, flower, typhoon, garden, cookie, taco, gyro, mountain, painting, river, meadow, island, message, morsel, marble, mitten, trombone, nugget, chicken, donkey, llama, hamster, raisin, nation, rocket, bottle, anvil, sunset, muskrat, treasure, coastline, building, lighthouse, concept, forest, python, dinner, hammer, robber, jacket, singer, puppet, valley, comet, scooter, joker, pebble, kayak, gorilla, airplane, table, atom, movie, poster, fountain, missile, pimple, player, shovel, window, rooster, biscuit, raven, eagle, question, vampire, peon, otter, camel, suburb, towel, turkey, pencil, planet, viking, squirrel, snowboard, dweller, lemon, photo, item, skillet, mother, father, brother, sister, elder, aardvark, apple, object, pickle, staple, wizard, raccoon, tadpole, spigot, daughter, mantra, pizza, calzone, vision, haiku, pixel, onion, glacier, penguin, cobra, dolphin, spider, trumpet, donut, ion, aura, geezer, freedom, attempt, pigeon, teacher, [sunday, monday, tuesday, wednesday, thursday, friday, saturday]],
+    [samurai, spatula, tornado, hurricane, restaurant, computer, radio, stereo, commuter, newspaper, hairdryer, photograph, sombrero, burrito, telephone, animal, bicycle, dinosaur, iguana, kangaroo, umbrella, hiking boot, dishwasher, asteroid, meteor, cruise liner, oil tanker, apple pie, gorilla, tricycle, artichoke, musician, visitor, universe, disaster, piano, canteloupe, pyramid, article, location, banana],
+    [fortune cookie, ecosystem, obligation, generator, generation, ambassador, elevator, watermelon, convertible, calculator, harmonica, operation, invitation, kindergarten, helicopter, alligator, caterpillar, constellation, germination, politician, corporation, advertisement, declaration, astronomer, variation, civilization, perimeter, population, denominator, semicircle, operator, aquarium, disappointment, kaleidoscope, television, orangutan, washing machine, environment]
+  ]
+:noun_singular: [
+    [fish, man, child, box, sky, beach, sheep, church, mouse, fox, goose, wish, life],
+    [hobby, woman, baby, country, princess, person, hero, potato],
+    [enemy, remedy, nebula, library, factory, mosquito, buffalo],
+    [bacteria, reality, discovery, super hero, territory, deficiency, activity, calamity, emergency]
+  ]
+:noun_plural: [
+    [fish, men, skies, sheep, mice, geese, lives],
+    [women, children, babies, countries, cities, boxes, cattle, people, grizzlies, heroes, foxes, beaches, churches, wishes],
+    [enemies, hobbies, remedies, libraries, factories, potatoes, mosquitoes, buffaloes],
+    [bacteria, realities, discoveries, super heroes, territories, activities, calamities, emergencies]
+  ]
+
+:mass_noun_determiner: [
+    [the, [all, some, no], [your, my, his, her, our, their]]
+]
+
+:mass_noun: [
+    [fun, love, snow, funk, earth, space, home, dust, pain, life, health, death, loss, thought, beer, wine, dirt, fire, flame, style, lore, wind, force, fog, haze, time, war, peace, doom, food, art, gloom, hope, ice, oil, gold, light, cheese, grass, breath, steel, iron, stone, zen, stuff, hair, soup, sense, air, gas, ground, foam, glass, wealth, slime, cloth, tea, juice, fruit, jazz, heat, speed, glue, noise, wood, milk, cake, rice, work, grief, fish, lust, sleep, heart, night, skin, blood, sand, math, rain, youth, lore, grace, corn, bread, glee, mist, jive, help],
+    [metal, essence, power, magic, evil, peril, disease, vapor, butter, sugar, darkness, fortune, soda, success, failure, water, passion, wonder, beauty, reason, fabric, lava, jello, ketchup, coffee, jelly, ice cream, sadness, goodness, physics, money, ethics, traffic, plastic, dancing, anger, danger, softness, friendship, trouble, culture, virtue, fuel, music, freedom, cornbread, lightning, sorrow, mustard, fluid, liquid, knowledge],
+    [happiness, gravity, desire, misfortune, pestilence, certainty, mystery, energy, chocolate, honesty, poverty, laziness, chemistry, furniture, equipment, violence, liberty, jealousy, gelato, intention, religion],
+    [society, community, contemplation, inconvenience, humanity, morality, information, intelligence, stupidity, geometry]
+  ]
+
+:verb_common: [
+    [bloom, drain, pat, climb, bend, give, take, pour, yank, clip, spread, build, shape, hate, throw, find, hear, see, smell, taste, eat, like, wake, tempt, smack, fold, farm, sip, lure, rip, rock, poke, warm, pull, grab, shove, pet, cut, get, bang, bust, bet, trick, lick, steal, boil, toast, dunk, gulp, meet, dig, form, roll, bathe, trap, treat, feed, hack, kick, heal, blast, lift, draw, cook, shake, bring, see, want, need, feel, love, hug, break, make, shock, paint, gain, kill, fund, hire, read, bake, own, rob, herd, rent, move, pay, jab, stop, start, turn, tear, fire, eye, scare, ask, win, make, ship, test, ride, school, clone, train, drive, know, buy, store, save, help],
+    [consume, destroy, attack, nurture, explore, open, construct, befriend, explain, target, retain, prevent, protest, direct, procure, locate, staple, strangle, topple, avoid, reveal, survey, maintain, fasten, harden, straighten, offer, transform, tickle, question, deceive, mislead, support, become, revive, connect, iron, annoy, forget, handle, answer, inspect, behold, design, acquire, obtain, believe, dazzle, honor, master, gather, savor, adjust, expect, create, instruct, afford, succeed],
+    [imagine, examine, interrupt, activate, agitate, animate, apprehend, calibrate, captivate, celebrate, complicate, decimate, decipher, dishonor, dominate, enliven, generate, jettison, isolate, medicate, nominate, orient, overwhelm, recycle, terminate, violate, discover]
+  ]
+:verb_singular: [
+    [soothes],
+    [eases, nudges, uses, raises, slices, falls on, dreams of, jumps over, looks at, looks for, studies, tosses, touches, coaxes, pushes, reaches, punches, cares for, ties up, sticks to, goes to, swarms on, flails at, cooks for, kisses, smooches, speaks to, quests for, raves about, sits on, waves to, shines on, mixes, watches, copies, marries, senses, closes, sings to, smiles at, asks for, hopes for, toys with, plays with, floats on, lives with, steps on, jives with, hops on],
+    [amazes, cares about, notifies, objects to, condenses, beautifies, glorifies, liquefies, nullifies, occupies, purifies, satisfies, stupefies, wishes for, thinks about, writes about]
+  ]
+:verb_plural: [
+    [ease, nudge, use, raise, slice, study, toss, touch, coax, push, reach, punch, kiss, smooch, mix, watch, copy, sense, sooth, close],
+    [amaze, fall on, dream of, jump over, look at, look for, finish, care for, approach, tie up, stick to, go to, swarm on, flail at, cook for, dance with, dance for, speak to, quest for, rave about, sit on, wave to, shine on, condense, marry, advise, sing to, smile at, ask for, hope for, wish for, toy with, play with, think about, float on, lives on, step on, jive with, hop on],
+    [care about, notify, object to, beautify, glorify, liquefy, nullify, occupy, purify, satisfy, stupefy, vandalize, vaporize, minimize, maximize, encourage, equalize, pulverize, write about]
+  ]
+
+:verb_self_common: [
+    [wake, jump, speed, climb, live, hope, fail, float, fall, slow, creep, sleep, groan, moan, coast, suck, walk, run, wait, think, land, scream, crawl, play, smile, glow, wave, dream, yell, work, feel, nap, quake, whine, trek, learn, weep, sob, speak, hide, pose, laugh, bathe, burn, grow, shrink, feast, warn, stray, peek, creak, flow, come, feed, cope, heal, race, read, dig, dwell, move, pray, gawk, breed, sag, spit, stand, stop, swerve, eat, lust, shine, end, bleed, drop, open, shake, start, fart, tear, turn, sail, sing, ask, sin, point, ail, flail, fold, die, smell, groove, shout, lie, dine, win, write, train, drive, know, jive, hop, shop, paint],
+    [survive, ponder, wonder, travel, transform, falter, wallow, improve, believe, boogie, crumble, giggle, complain, forget, persist, explore, exist, arrive, await, agree, connect, engage, haggle, return, rotate, resist, dabble, murmur, mature, protest, gossip, growl, begin, approve, clamber, attack, perform, abide, achieve, succeed],
+    [concentrate, speculate, hesitate, meditate, calculate, celebrate, co-exist, consider, continue, deviate, disagree, disbelieve, disconnect, elevate, imagine, meander, navigate, overact, postulate, propagate, radiate, recover, replicate, duplicate, surrender, terminate, understand, undulate, hibernate, self-destruct]
+  ]
+:verb_self_singular: [
+    [goes, flies, cries],
+    [sits down, lies down, wakes up, freezes, bounces, replies, responds, gazes, loses, rises, rushes, marches, pauses, crashes, watches, dances, rages, rushes, breaks up],
+    [simplifies, testifies, relaxes, approaches, emerges]
+  ]
+:verb_self_plural: [
+    [go, fly, cry, freeze, gaze, lose, rise, rush, march, pause, crash, watch, dance, rage, rush],
+    [sit down, lie down, wake up, approach, reply, respond, relax, collapse, break up, emerge],
+    [simplify, stabilize, testify]
+  ]
+
+:adverb: [
+    [great, well, good, bad, fast, slow, up, down, soon, now, nice, left, right, wrong, some, near, far, hard, soft],
+    [always, badly, blindly, boldly, bravely, brightly, clearly, deftly, kindly, loosely, madly, never, oddly, often, only, poorly, sadly, promptly, quickly, rarely, really, rudely, safely, seldom, slowly, sometimes, warmly, yearly],
+    [angrily, anxiously, awkwardly, boastfully, cheerfully, crazily, doubtfully, eagerly, evenly, exactly, finally, foolishly, frantically, frequently, gleefully, gracefully, happily, hastily, honestly, hourly, hungrily, jealously, lazily, perfectly, politely, rapidly, tenderly, totally, weekly, wildly, royally]
+  ]

data/spec/haiku_gadget/haiku_gadget_spec.rb

@@ -0,0 +1,152 @@
+module HaikuGadget
+
+  describe 'HaikuGadget' do
+
+    describe 'with default dictionary' do
+
+      dict_path = '../../lib/words.yml'
+
+      before(:each) do
+        Dictionary.init! dict_path
+      end
+
+      it 'should have various types of words' do
+        [:noun, :verb, :adjective].each do |valid_symbol|
+          word_type = Dictionary::WORD_TYPES[valid_symbol]
+
+          # check words? method for true/false
+          expect(word_type.words? 1).to eq(true)
+
+          # check get_words method for actual string response
+          expect(word_type.get_word 1).to be_kind_of(String)
+        end
+      end
+
+      it 'should not have a non-existant word type' do
+        [:doesnt_exist, :also_is_wrong, nil].each do |invalid_symbol|
+          invalid_word_type = Dictionary::WORD_TYPES[invalid_symbol]
+
+          # check words? method for true/false
+          expect(Dictionary.words? invalid_word_type, 1).to eq(false)
+
+          # get_word should return nil
+          expect(Dictionary.get_word invalid_word_type, 1).to be_nil
+        end
+      end
+
+      it 'should fail if asking for an invalid number (or data type) of syllables' do
+        [:noun, :invalid_word_type, nil].each do |symbol|
+          word_type = Dictionary::WORD_TYPES[symbol]
+
+          # check both valid and invalid word type symbols
+          [0, -1, 9, 'abc', nil, 2.5].each do |invalid_syllables|
+            # check words? method for true/false
+            expect(Dictionary.words? word_type, invalid_syllables).to eq(false)
+
+            # get_word should return nil
+            expect(Dictionary.get_word word_type, invalid_syllables).to be_nil
+          end
+        end
+      end
+
+    end
+
+    describe 'with single possibility test dictionary' do
+      # these tests use a yaml file in which the randomness is removed because
+      # there is only one word of each type in the dictionary
+
+      dict_path = '../../spec/test_words_single.yml'
+
+      haiku_template = HaikuTemplate.new [
+        [
+          WordTemplate.new(:adjective, 1, :singular, 1),  # red
+          WordTemplate.new(:noun, 1, :singular, 1),       # thing
+          WordTemplate.new(:verb_self, 3, :singular, 1)   # meditates
+        ], [
+          WordTemplate.new(:determiner, 1, :plural, 1),   # the
+          WordTemplate.new(:noun, 3, :plural, 1),         # samurais
+          WordTemplate.new(:verb, 1, :plural, 1),         # see
+          WordTemplate.new(:noun, 2, :singular, 2)        # zombie
+        ], [
+          WordTemplate.new(:adjective, 2, :any, 1),  # orange
+          WordTemplate.new(:noun, 2, :any, 1),       # zombie(s)
+          WordTemplate.new(:verb_self, 1, :any, 1)   # fight(s)
+        ]
+      ]
+
+      before(:each) do
+        Dictionary.init! dict_path
+      end
+
+      it 'should return a predictable haiku (when generated all at once)' do
+
+        10.times do
+          # do 10 times so the plurality randomization hits multiple possibilities
+          haiku_lines = HaikuGadget.haiku_lines haiku_template
+
+          expect(haiku_lines[0]).to eq('red thing meditates')
+          expect(haiku_lines[1]).to eq('the samurais see zombie')
+
+          # third line can randomly be one of two options
+          last_lines = ['orange zombie fights', 'orange zombies fight']
+          expect(last_lines).to include(haiku_lines[2])
+        end
+
+      end
+
+      it 'should return a predictable haiku (when lines are generated individually)' do
+
+        10.times do
+          # do 10 times so the plurality randomization hits multiple possibilities
+          top_line = HaikuGadget.top_line haiku_template.template_matrix[0]
+          middle_line = HaikuGadget.middle_line haiku_template.template_matrix[1]
+          bottom_line = HaikuGadget.bottom_line haiku_template.template_matrix[2]
+
+          haiku = [top_line, middle_line, bottom_line].join(' | ')
+
+          valid_haikus = [
+            'red thing meditates | the samurais see zombie | orange zombie fights',
+            'red thing meditates | the samurais see zombie | orange zombies fight'
+          ]
+
+          expect(valid_haikus).to include(haiku)
+
+        end
+      end
+
+    end
+
+    describe 'with deeply-nested test dictionary' do
+
+      dict_path = '../../spec/test_words_nested.yml'
+
+      before(:each) do
+        Dictionary.init! dict_path
+      end
+
+      it 'should return a haiku containing expected words' do
+
+        haiku_template = HaikuTemplate.new [
+          [WordTemplate.new(:mass_noun, 5)],
+          [WordTemplate.new(:mass_noun, 7)],
+          [WordTemplate.new(:mass_noun, 5)]
+        ]
+
+        haiku = HaikuGadget.haiku nil, haiku_template
+
+        puts "haiku from deeply-nested words: #{haiku.join(' | ')}"
+
+        five_syl_words = %w(personality california university)
+        seven_syl_words = %w(unconventionality territoriality enthusiastically)
+
+        expect(five_syl_words).to include(haiku[0])
+        expect(seven_syl_words).to include(haiku[1])
+        expect(five_syl_words).to include(haiku[2])
+
+      end
+
+    end
+     
+  end
+
+end

data/spec/rails_helper.rb

@@ -0,0 +1,50 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require 'spec_helper'
+require File.expand_path("../../config/environment", __FILE__)
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+end

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+require 'haiku_gadget'
+
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/test_words_nested.yml

@@ -0,0 +1,14 @@
+---
+:mass_noun: [
+    [],
+    [],
+    [],
+    [],
+    [
+      [[[[[[personality, california, university]]]]]]
+    ],
+    [],
+    [
+      [[[unconventionality, territoriality, enthusiastically]]]
+    ]
+  ]

data/spec/test_words_single.yml

@@ -0,0 +1,23 @@
+---
+:determiner_common: [
+    [the]
+  ]
+:adjective_common: [
+    [red],
+    [orange]
+  ]
+:noun_common: [
+    [thing],
+    [zombie],
+    [samurai]
+  ]
+:verb_common: [
+    [see],
+    [attack],
+    [decipher]
+  ]
+:verb_self_common: [
+    [fight],
+    [travel],
+    [meditate]
+  ]

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: haiku_gadget
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Scott Balay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: i know you want it / random poetic nonsense / just click a button
+email:
+- sbalay@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- haiku_gadget.gemspec
+- lib/assets/.keep
+- lib/haiku_gadget.rb
+- lib/haiku_gadget/dictionary.rb
+- lib/haiku_gadget/haiku_gadget.rb
+- lib/haiku_gadget/haiku_template.rb
+- lib/haiku_gadget/version.rb
+- lib/haiku_gadget/word_template.rb
+- lib/haiku_gadget/word_type.rb
+- lib/tasks/.keep
+- lib/words.yml
+- spec/haiku_gadget/haiku_gadget_spec.rb
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/test_words_nested.yml
+- spec/test_words_single.yml
+homepage: http://github.com/zenblender/haiku_gadget
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Random haiku generator
+test_files:
+- spec/haiku_gadget/haiku_gadget_spec.rb
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/test_words_nested.yml
+- spec/test_words_single.yml