wordnik 0.4.5 → 0.4.6

data/lib/wordnik/resource_modules/account.rb

@@ -0,0 +1,230 @@
+# HEY HACKER! THIS IS AN AUTO-GENERATED FILE.
+# So don't bother editing it. To see how it's built, take a look at the Rakefile
+
+module AccountMethods
+
+  # Authenticates a User
+  #
+  def authenticate(username, *args)
+    http_method = :get
+    path = '/account/authenticate/{username}'
+    path.sub!('{username}', username)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns usage statistics for the API account.
+  #
+  def get_api_token_status(*args)
+    http_method = :get
+    path = '/account/apiTokenStatus'
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns an ApiResponse indicating whether or not a username is available
+  #
+  def get_username_available(username, *args)
+    http_method = :get
+    path = '/account/usernameAvailable/{username}'
+    path.sub!('{username}', username)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Regenerates an API Token.  Currently not supported or tested.
+  #
+  def create_api_account(*args)
+    http_method = :get
+    path = '/account/regenerateApiToken'
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Authenticates a user
+  #
+  def authenticate_post(username, *args)
+    http_method = :post
+    path = '/account/authenticate/{username}'
+    path.sub!('{username}', username)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns the logged-in User
+  # Requires a valid auth_token to be set.
+  #
+  def get_logged_in_user(*args)
+    http_method = :get
+    path = '/account/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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Fetches WordList objects for the logged-in user.
+  #
+  def get_word_lists_for_current_user(*args)
+    http_method = :get
+    path = '/account/wordLists'
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+end

data/lib/wordnik/resource_modules/system.rb

@@ -0,0 +1,37 @@
+# HEY HACKER! THIS IS AN AUTO-GENERATED FILE.
+# So don't bother editing it. To see how it's built, take a look at the Rakefile
+
+module SystemMethods
+
+  # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+end

data/lib/wordnik/resource_modules/user.rb

@@ -0,0 +1,283 @@
+# HEY HACKER! THIS IS AN AUTO-GENERATED FILE.
+# So don't bother editing it. To see how it's built, take a look at the Rakefile
+
+module UserMethods
+
+  # 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)
+
+    path.sub!('{date}', date)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Returns a user's WordOfTheDayList
+  #
+  def get_word_of_the_day_list(username, *args)
+    http_method = :get
+    path = '/user/{username}/wordOfTheDayList'
+    path.sub!('{username}', username)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Updates a user's WordOfTheDayList
+  #
+  def update_word_of_the_day_list(username, *args)
+    http_method = :put
+    path = '/user/{username}/wordOfTheDayList'
+    path.sub!('{username}', username)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    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, *args)
+    http_method = :post
+    path = '/user/{username}/wordOfTheDayList'
+    path.sub!('{username}', username)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    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
+  #
+  def update_item_in_word_of_the_day_list(username, permalink, *args)
+    http_method = :put
+    path = '/user/{username}/wordOfTheDayList/{permalink}'
+    path.sub!('{username}', username)
+
+    path.sub!('{permalink}', permalink)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    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)
+
+    path.sub!('{permalink}', permalink)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+  # Deletes a specific word from a user's WordOfTheDayList
+  #
+  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!('{permalink}', permalink)
+
+    path.sub!('{wordToDelete}', wordToDelete)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    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, *args)
+    http_method = :put
+    path = '/user/{username}/wordOfTheDayList/{permalink}/add'
+    path.sub!('{username}', username)
+
+    path.sub!('{permalink}', permalink)
+
+    # 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
+
+    if [:post, :put].include?(http_method)
+      params = nil
+      body = last_arg
+    else
+      params = last_arg
+      body = nil
+    end
+
+    request = Wordnik::Request.new(http_method, path, :params => params, :body => body)
+    request_only ? request : request.response.body
+  end
+
+end