wordnik 0.4.7 → 4.06.00

data/lib/wordnik/resource_modules/word.rb

@@ -3,12 +3,743 @@
 
 module WordMethods
 
+  # Return entries for a word
+  #
+  def get_entries(word, *args)
+    http_method = :get
+    path = '/word/{word}/entries'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns examples for a word
+  #
+  def get_examples(word, *args)
+    http_method = :get
+    path = '/word/{word}/examples'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Fetches examples for a word
+  #
+  def get_examples_post(word, body, *args)
+    http_method = :post
+    path = '/word/{word}/examples'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Adds a Relationship Map to a word
+  #
+  def add_word_form(word, body, *args)
+    http_method = :post
+    path = '/word/{word}/wordForms'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns other forms of a word
+  #
+  def get_word_forms(word, *args)
+    http_method = :get
+    path = '/word/{word}/wordForms'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Deletes a relationship from a word
+  #
+  def delete_word_form(word, *args)
+    http_method = :delete
+    path = '/word/{word}/wordForms'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
   # Given a word as a string, returns the WordObject that represents it
   #
   def get_word(word, *args)
     http_method = :get
-    path = '/word/{word}'
-    path.sub!('{word}', word)
+    path = '/word/{word}'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Return definitions for a word
+  #
+  def get_definitions(word, *args)
+    http_method = :get
+    path = '/word/{word}/definitions'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns word statistics
+  #
+  def get_word_stats(word, *args)
+    http_method = :get
+    path = '/word/{word}/stats'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns information about API parameters
+  #
+  def get_help(*args)
+    http_method = :get
+    path = '/word'
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns a top example for a word
+  #
+  def get_top_example(word, *args)
+    http_method = :get
+    path = '/word/{word}/topExample'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Fetches other forms of a word
+  # Deprecated
+  #
+  def get_punctuation_factor(word, *args)
+    http_method = :get
+    path = '/word/{word}/punctuationFactor'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns definitions for a word based on the sentence in which it is found
+  # Use the offset parameter when the word occurs more than once in the sentence
+  #
+  def contextual_lookup(word, *args)
+    http_method = :get
+    path = '/word/{word}/contextualLookup'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns definitions for a word based on the sentence in which it is found
+  # Use the offset parameter when the word occurs more than once in the sentence
+  #
+  def contextual_lookup_post(word, body, *args)
+    http_method = :post
+    path = '/word/{word}/contextualLookup'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the number of comments on a word
+  #
+  def get_comment_count(word, *args)
+    http_method = :get
+    path = '/word/{word}/commentCount'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Return related words (thesaurus data) for a word
+  #
+  def get_related_words(word, *args)
+    http_method = :get
+    path = '/word/{word}/related'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns WordLists containing a word
+  #
+  def get_listed_in(word, *args)
+    http_method = :get
+    path = '/word/{word}/listedIn'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns a count of lists a word appears in
+  #
+  def get_listed_in_count(word, *args)
+    http_method = :get
+    path = '/word/{word}/listedInCount'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the first WordList a word appeared in
+  #
+  def get_first_listed_in(word, *args)
+    http_method = :get
+    path = '/word/{word}/firstListedIn'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the first User to list a particular word
+  #
+  def get_first_listed_by(word, *args)
+    http_method = :get
+    path = '/word/{word}/firstListedBy'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns text pronunciations for a given word
+  #
+  def get_text_pronunciations(word, *args)
+    http_method = :get
+    path = '/word/{word}/pronunciations'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns Flickr images for a word
+  #
+  def get_flickr_images(word, *args)
+    http_method = :get
+    path = '/word/{word}/images/flickr'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the Scrabble score for a word
+  #
+  def get_scrabble_score(word, *args)
+    http_method = :get
+    path = '/word/{word}/scrabbleScore'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns citations for a word
+  #
+  def get_citations(word, *args)
+    http_method = :get
+    path = '/word/{word}/citations'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns syllable information for a word
+  #
+  def get_hyphenation(word, *args)
+    http_method = :get
+    path = '/word/{word}/hyphenation'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns syllable information for a word
+  #
+  def get_unigram_count_internal(word, *args)
+    http_method = :get
+    path = '/word/{word}/unigramCountInternal'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns Bigrams for the given word
+  #
+  def get_bigrams_internal(word, *args)
+    http_method = :get
+    path = '/word/{word}/phrasesInternal'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the number of times a word has been viewed
+  #
+  def get_lookup_count(word, *args)
+    http_method = :get
+    path = '/word/{word}/lookupCount'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -24,24 +755,18 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
-    end
-
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns examples for a word
+  # Fetches tags for a word
   #
-  def get_examples(word, *args)
+  def get_tags_on_word(word, *args)
     http_method = :get
-    path = '/word/{word}/examples'
-    path.sub!('{word}', word)
+    path = '/word/{word}/tags'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -57,24 +782,45 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Fetches tag count for a word
+  #
+  def get_tag_count_on_word(word, *args)
+    http_method = :get
+    path = '/word/{word}/tagCount'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Return definitions for a word
+  # Adds a tag to a word
   #
-  def get_definitions(word, *args)
-    http_method = :get
-    path = '/word/{word}/definitions'
-    path.sub!('{word}', word)
+  def add_tag_to_word(word, *args)
+    http_method = :post
+    path = '/word/{word}/tag'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -90,14 +836,35 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Removes a tag from a word
+  #
+  def delete_tag_from_word(word, *args)
+    http_method = :delete
+    path = '/word/{word}/tag'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
@@ -107,7 +874,34 @@ module WordMethods
   def get_word_frequency(word, *args)
     http_method = :get
     path = '/word/{word}/frequency'
-    path.sub!('{word}', word)
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
+    end
+
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns first usage of a word
+  #
+  def get_first_usage_of_word(word, *args)
+    http_method = :get
+    path = '/word/{word}/firstUsed'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -123,24 +917,45 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Records a word view from the website
+  #
+  def add_word_view(word, *args)
+    http_method = :post
+    path = '/word/{word}/wordView'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns a top example for a word
+  # Checks to see if a word is a user's favorite
   #
-  def get_top_example(word, *args)
+  def is_favorite(word, *args)
     http_method = :get
-    path = '/word/{word}/topExample'
-    path.sub!('{word}', word)
+    path = '/word/{word}/isFavorite'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -156,24 +971,45 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the number of times a word has been Favorited
+  #
+  def get_favorite_count(word, *args)
+    http_method = :get
+    path = '/word/{word}/favoriteCount'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Return related words (thesaurus data) for a word
+  # Favorites a Word for a user
   #
-  def get_related_words(word, *args)
-    http_method = :get
-    path = '/word/{word}/related'
-    path.sub!('{word}', word)
+  def add_word_to_favorites(word, *args)
+    http_method = :post
+    path = '/word/{word}/favorite'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -189,14 +1025,35 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Removes a Word from a user's Favorites
+  #
+  def delete_from_favorites(word, *args)
+    http_method = :delete
+    path = '/word/{word}/favorite'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
@@ -206,7 +1063,7 @@ module WordMethods
   def get_phrases(word, *args)
     http_method = :get
     path = '/word/{word}/phrases'
-    path.sub!('{word}', word)
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -222,24 +1079,46 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Fetches etymology data
+  #
+  def get_etymologies(word, *args)
+    http_method = :get
+    path = '/word/{word}/etymologies'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns syllable information for a word
+  # Fetches other forms of a word
+  # Deprecated
   #
-  def get_hyphenation(word, *args)
+  def get_other_forms_internal(word, *args)
     http_method = :get
-    path = '/word/{word}/hyphenation'
-    path.sub!('{word}', word)
+    path = '/word/{word}/otherFormsInternal'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -255,24 +1134,46 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Adds a word relationship
+  # Deprecated
+  #
+  def add_word_relationship_internal(word, body, *args)
+    http_method = :post
+    path = '/word/{word}/wordRelationshipInternal'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns text pronunciations for a given word
+  # Fetches comments on a Word
   #
-  def get_text_pronunciations(word, *args)
+  def get_comments_on_word(word, *args)
     http_method = :get
-    path = '/word/{word}/pronunciations'
-    path.sub!('{word}', word)
+    path = '/word/{word}/comments'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -288,24 +1189,19 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
-    end
-
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns other forms of a word
+  # Fetches a Comment by ID
   #
-  def get_word_forms(word, *args)
+  def delete_comment_on_word(word, commentId, *args)
     http_method = :get
-    path = '/word/{word}/wordForms'
-    path.sub!('{word}', word)
+    path = '/word/{word}/comment/{commentId}'
+    path.sub!('{word}', word.to_s)
+    path.sub!('{commentId}', commentId.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -321,25 +1217,46 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Deletes an existing word comment
+  #
+  def delete_comment_by_id_on_word(word, commentId, *args)
+    http_method = :delete
+    path = '/word/{word}/comment/{commentId}'
+    path.sub!('{word}', word.to_s)
+    path.sub!('{commentId}', commentId.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Fetches audio metadata for a word.
-  # The metadata includes a time-expiring fileUrl which allows reading the audio file directly from the API.  Currently only audio pronunciations from the American Heritage Dictionary in mp3 format are supported.
+  # Adds a comment to a word
   #
-  def get_audio(word, *args)
-    http_method = :get
-    path = '/word/{word}/audio'
-    path.sub!('{word}', word)
+  def comment_on_word(word, body, *args)
+    http_method = :post
+    path = '/word/{word}/comment'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -355,25 +1272,46 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Updates an existing word comment
+  #
+  def update_comment_on_word(word, body, *args)
+    http_method = :put
+    path = '/word/{word}/comment'
+    path.sub!('{word}', word.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns definitions for a word based on the sentence in which it is found
-  # Use the offset parameter when the word occurs more than once in the sentence
+  # Fetches audio metadata for a word.
+  # The metadata includes a time-expiring fileUrl which allows reading the audio file directly from the API.  Currently only audio pronunciations from the American Heritage Dictionary in mp3 format are supported.
   #
-  def contextual_lookup(word, *args)
+  def get_audio(word, *args)
     http_method = :get
-    path = '/word/{word}/contextualLookup'
-    path.sub!('{word}', word)
+    path = '/word/{word}/audio'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -389,25 +1327,18 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
-    end
-
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end
 
-  # Returns definitions for a word based on the sentence in which it is found
-  # Use the offset parameter when the word occurs more than once in the sentence
+  # Creates AudioPron metadata
   #
-  def contextual_lookup_post(word, *args)
+  def add_audio(word, body, *args)
     http_method = :post
-    path = '/word/{word}/contextualLookup'
-    path.sub!('{word}', word)
+    path = '/word/{word}/audio'
+    path.sub!('{word}', word.to_s)
 
     # Ruby turns all key-value arguments at the end into a single hash
     # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
@@ -423,14 +1354,36 @@ module WordMethods
       last_arg.delete(:request_only)
     end
 
-    if [:post, :put].include?(http_method)
-      params = nil
-      body = last_arg
-    else
-      params = last_arg
-      body = nil
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Deletes an AudioPron
+  #
+  def delete_audio(word, audio_id, *args)
+    http_method = :delete
+    path = '/word/{word}/audio/{audio_id}'
+    path.sub!('{word}', word.to_s)
+    path.sub!('{audio_id}', audio_id.to_s)
+
+    # Ruby turns all key-value arguments at the end into a single hash
+    # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+    # becomes {:limit => 10, :part_of_speech => 'verb'}
+    last_arg = args.pop if args.last.is_a?(Hash)
+    last_arg = args.pop if args.last.is_a?(Array)
+    last_arg ||= {}
+
+    # Look for a kwarg called :request_only, whose presence indicates
+    # that we want the request itself back, not the response body
+    if last_arg.is_a?(Hash) && last_arg[:request_only].present?
+      request_only = true
+      last_arg.delete(:request_only)
     end
 
+    params = last_arg
+    body ||= {}
     request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
     request_only ? request : request.response.body
   end