wordnik 0.4.7 → 4.06.00

data/lib/wordnik/resource_modules/system.rb

@@ -3,11 +3,144 @@
 
 module SystemMethods
 
+  # Returns all defined ContentProviders.
+  #
+  def get_providers(*args)
+    http_method = :get
+    path = '/system/providers'
+
+    # 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 = '/system'
+
+    # 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 weighted terms related to the input word
+  #
+  def get_related_words(word, *args)
+    http_method = :get
+    path = '/system/{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 a word with attributes
+  #
+  def get_related_words(word, *args)
+    http_method = :get
+    path = '/system/{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 a graph response for the supplied terms
   #
   def get_word_by_id(*args)
     http_method = :get
     path = '/system/graph'
+
+    # 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
+
+  # Gets an Audio File ID for recording.
+  #
+  def get_audio_record_id(*args)
+    http_method = :get
+    path = '/system/audioRecordId'
+
     # 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'}
@@ -22,14 +155,34 @@ module SystemMethods
       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 system-wide statistics for the platform.
+  #
+  def get_stats(*args)
+    http_method = :get
+    path = '/system/stats'
+
+    # 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

data/lib/wordnik/resource_modules/user.rb

@@ -3,14 +3,12 @@
 
 module UserMethods
 
-  # Returns the WordOfTheDay for a given user on a given date
+  # Returns a user's WordOfTheDayList
   #
-  def get_word_of_the_day_by_date(username, date, *args)
+  def get_word_of_the_day_list(username, *args)
     http_method = :get
-    path = '/user/{username}/wordOfTheDay/{date}'
-    path.sub!('{username}', username)
-
-    path.sub!('{date}', date)
+    path = '/user/{username}/wordOfTheDayList'
+    path.sub!('{username}', username.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')
@@ -26,24 +24,46 @@ module UserMethods
       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
+
+  # Creates a WordOfTheDayList
+  # A user can have only one WordOfTheDayList.
+  #
+  def create_word_of_the_day_list(username, body, *args)
+    http_method = :post
+    path = '/user/{username}/wordOfTheDayList'
+    path.sub!('{username}', username.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 user's WordOfTheDayList
+  # Updates a user's WordOfTheDayList
   #
-  def get_word_of_the_day_list(username, *args)
-    http_method = :get
+  def update_word_of_the_day_list(username, body, *args)
+    http_method = :put
     path = '/user/{username}/wordOfTheDayList'
-    path.sub!('{username}', username)
+    path.sub!('{username}', username.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')
@@ -59,24 +79,47 @@ module UserMethods
       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 a user's WordOfTheDayList
+  #
+  def update_word_of_the_day_list(username, permalink, *args)
+    http_method = :delete
+    path = '/user/{username}/wordOfTheDayList/{permalink}'
+    path.sub!('{username}', username.to_s)
+    path.sub!('{permalink}', permalink.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
 
-  # Updates a user's WordOfTheDayList
+  # Adds a WordOfTheDay to a user's WordOfTheDayList
   #
-  def update_word_of_the_day_list(username, *args)
+  def update_item_in_word_of_the_day_list(username, permalink, body, *args)
     http_method = :put
-    path = '/user/{username}/wordOfTheDayList'
-    path.sub!('{username}', username)
+    path = '/user/{username}/wordOfTheDayList/{permalink}'
+    path.sub!('{username}', username.to_s)
+    path.sub!('{permalink}', permalink.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')
@@ -92,25 +135,45 @@ module UserMethods
       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 a UserProfile
+  #
+  def get_user_profile(username, *args)
+    http_method = :get
+    path = '/user/{username}/profile'
+    path.sub!('{username}', username.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
 
-  # Creates a WordOfTheDayList
-  # A user can have only one WordOfTheDayList.
+  # Updates a UserProfile
   #
-  def create_word_of_the_day_list(username, *args)
-    http_method = :post
-    path = '/user/{username}/wordOfTheDayList'
-    path.sub!('{username}', username)
+  def update_user_profile(username, body, *args)
+    http_method = :put
+    path = '/user/{username}/profile'
+    path.sub!('{username}', username.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')
@@ -126,26 +189,45 @@ module UserMethods
       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 a user's tracking info
+  #
+  def get_user_tracking_info(username, *args)
+    http_method = :get
+    path = '/user/{username}/trackingInfo'
+    path.sub!('{username}', username.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 WordOfTheDay to a user's WordOfTheDayList
+  # Updates a User
   #
-  def update_item_in_word_of_the_day_list(username, permalink, *args)
+  def update_user(username, body, *args)
     http_method = :put
-    path = '/user/{username}/wordOfTheDayList/{permalink}'
-    path.sub!('{username}', username)
-
-    path.sub!('{permalink}', permalink)
+    path = '/user/{username}'
+    path.sub!('{username}', username.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')
@@ -161,26 +243,45 @@ module UserMethods
       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 a User
+  #
+  def get_user(username, *args)
+    http_method = :get
+    path = '/user/{username}'
+    path.sub!('{username}', username.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 user's WordOfTheDayList
+  # Deletes a User
   #
-  def update_word_of_the_day_list(username, permalink, *args)
+  def delete_user(username, *args)
     http_method = :delete
-    path = '/user/{username}/wordOfTheDayList/{permalink}'
-    path.sub!('{username}', username)
-
-    path.sub!('{permalink}', permalink)
+    path = '/user/{username}'
+    path.sub!('{username}', username.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')
@@ -196,14 +297,36 @@ module UserMethods
       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 an item to a user's WordOfTheDayList
+  #
+  def add_word_to_word_of_the_day_list(username, permalink, body, *args)
+    http_method = :put
+    path = '/user/{username}/wordOfTheDayList/{permalink}/add'
+    path.sub!('{username}', username.to_s)
+    path.sub!('{permalink}', permalink.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
@@ -213,11 +336,37 @@ module UserMethods
   def delete_word_from_word_of_the_day_list(username, permalink, wordToDelete, *args)
     http_method = :delete
     path = '/user/{username}/wordOfTheDayList/{permalink}/{wordToDelete}'
-    path.sub!('{username}', username)
+    path.sub!('{username}', username.to_s)
+    path.sub!('{permalink}', permalink.to_s)
+    path.sub!('{wordToDelete}', wordToDelete.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
 
-    path.sub!('{permalink}', permalink)
+    params = last_arg
+    body ||= {}
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
 
-    path.sub!('{wordToDelete}', wordToDelete)
+  # Returns the WordOfTheDay for a given user on a given date
+  #
+  def get_word_of_the_day_by_date(username, date, *args)
+    http_method = :get
+    path = '/user/{username}/wordOfTheDay/{date}'
+    path.sub!('{username}', username.to_s)
+    path.sub!('{date}', date.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')
@@ -233,26 +382,127 @@ module UserMethods
       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
+
+  # Gets WordLists for a User.
+  #
+  def get_user_word_lists(username, *args)
+    http_method = :get
+    path = '/user/{username}/wordLists'
+    path.sub!('{username}', username.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 an item to a user's WordOfTheDayList
+  # Gets the count of WordLists for a User.
   #
-  def add_word_to_word_of_the_day_list(username, permalink, *args)
+  def get_user_word_list_count(username, *args)
+    http_method = :get
+    path = '/user/{username}/wordListsCount'
+    path.sub!('{username}', username.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 user's settings
+  #
+  def get_user_settings(username, *args)
+    http_method = :get
+    path = '/user/{username}/settings'
+    path.sub!('{username}', username.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
+
+  # Updates a user's settings
+  #
+  def update_user_settings(username, body, *args)
     http_method = :put
-    path = '/user/{username}/wordOfTheDayList/{permalink}/add'
-    path.sub!('{username}', username)
+    path = '/user/{username}/settings'
+    path.sub!('{username}', username.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
 
-    path.sub!('{permalink}', permalink)
+  # Returns the API key for the specified user
+  # Use the super user API key for getting this information or auth token of the user who is requesting the API key
+  #
+  def get_api_key_for_user(username, *args)
+    http_method = :get
+    path = '/user/{username}/apiKey'
+    path.sub!('{username}', username.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')
@@ -268,14 +518,688 @@ module UserMethods
       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 Comment on a User
+  #
+  def comment_on_user(username, body, *args)
+    http_method = :post
+    path = '/user/{username}/comment'
+    path.sub!('{username}', username.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
+
+  # Updates a Comment on a User
+  #
+  def update_comment_on_user(username, body, *args)
+    http_method = :put
+    path = '/user/{username}/comment'
+    path.sub!('{username}', username.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 Comment on a User
+  #
+  def delete_comment_on_user(username, commentId, *args)
+    http_method = :delete
+    path = '/user/{username}/comment/{commentId}'
+    path.sub!('{username}', username.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 a comment by ID
+  #
+  def get_comment_on_user_by_id(username, commentId, *args)
+    http_method = :get
+    path = '/user/{username}/comment/{commentId}'
+    path.sub!('{username}', username.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
+
+  # Returns a count of Comments on a user
+  #
+  def get_comments_on_user_count(username, *args)
+    http_method = :get
+    path = '/user/{username}/commentsOnCount'
+    path.sub!('{username}', username.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 Comments by a user
+  #
+  def get_comments_by_user_count(username, *args)
+    http_method = :get
+    path = '/user/{username}/commentsByCount'
+    path.sub!('{username}', username.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 Comments by a user
+  #
+  def get_comments_by_user(username, *args)
+    http_method = :get
+    path = '/user/{username}/commentsBy'
+    path.sub!('{username}', username.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 Comments on a user
+  #
+  def get_comments_on_user(username, *args)
+    http_method = :get
+    path = '/user/{username}/commentsOnUser'
+    path.sub!('{username}', username.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 UgcSummary info a user
+  #
+  def get_ugc_summary_for_user(username, *args)
+    http_method = :get
+    path = '/user/{username}/ugcSummary'
+    path.sub!('{username}', username.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 TagHistory for a User.
+  #
+  def get_user_tag_history(user, *args)
+    http_method = :get
+    path = '/user/{user}/tagHistory'
+    path.sub!('{user}', user.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 Tags by a User.
+  #
+  def get_user_tags(user, *args)
+    http_method = :get
+    path = '/user/{user}/tags'
+    path.sub!('{user}', user.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 the count of Tags created by a User.
+  #
+  def get_user_tag_count(user, *args)
+    http_method = :get
+    path = '/user/{user}/tagCount'
+    path.sub!('{user}', user.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 all subscriptions for a User.
+  #
+  def get_subscriptions(user, *args)
+    http_method = :get
+    path = '/user/{user}/subscriptions'
+    path.sub!('{user}', user.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
+
+  # Subscribes to an object.
+  #
+  def add_subscription(user, objectType, objectIdentifier, *args)
+    http_method = :post
+    path = '/user/{user}/subscriptions/{objectType}/{objectIdentifier}'
+    path.sub!('{user}', user.to_s)
+    path.sub!('{objectType}', objectType.to_s)
+    path.sub!('{objectIdentifier}', objectIdentifier.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 subscription to an object.
+  #
+  def remove_subscription(user, objectType, objectIdentifier, *args)
+    http_method = :delete
+    path = '/user/{user}/subscriptions/{objectType}/{objectIdentifier}'
+    path.sub!('{user}', user.to_s)
+    path.sub!('{objectType}', objectType.to_s)
+    path.sub!('{objectIdentifier}', objectIdentifier.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 Favorite Words for a user.
+  #
+  def get_user_favorite_words(user, *args)
+    http_method = :get
+    path = '/user/{user}/favorites/words'
+    path.sub!('{user}', user.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 favorite word count for a user.
+  #
+  def get_user_favorite_count(user, *args)
+    http_method = :get
+    path = '/user/{user}/favorites/wordCount'
+    path.sub!('{user}', user.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 Favorite WordLists for a user.
+  #
+  def get_user_favorite_word_lists(user, *args)
+    http_method = :get
+    path = '/user/{user}/favorites/wordLists'
+    path.sub!('{user}', user.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 Favorite WordList count for a user.
+  #
+  def get_user_favorite_word_lists_count(user, *args)
+    http_method = :get
+    path = '/user/{user}/favorites/wordListCount'
+    path.sub!('{user}', user.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 SearchHistory for a User.
+  #
+  def get_user_search_history(user, *args)
+    http_method = :get
+    path = '/user/{user}/searches'
+    path.sub!('{user}', user.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 SearchHistory for a User.
+  #
+  def remove_user_search_history_item(user, *args)
+    http_method = :delete
+    path = '/user/{user}/searches'
+    path.sub!('{user}', user.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 the total search count for a User.
+  #
+  def get_user_search_history_count(user, *args)
+    http_method = :get
+    path = '/user/{user}/totalSearches'
+    path.sub!('{user}', user.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 the total search count for a User.
+  #
+  def get_user_pronunciations(user, *args)
+    http_method = :get
+    path = '/user/{user}/pronunciations'
+    path.sub!('{user}', user.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 the total search count for a User.
+  #
+  def get_user_activity_stream(user, *args)
+    http_method = :get
+    path = '/user/{user}/activitystream'
+    path.sub!('{user}', user.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 = '/user'
+
+    # 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