wordnik 0.4.5 → 0.4.6

data/lib/wordnik/resource_modules/word_lists.rb

@@ -0,0 +1,68 @@
+# 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 WordListsMethods
+
+  # Returns information about API parameters
+  #
+  def get_help(*args)
+    http_method = :get
+    path = '/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
+
+  # Creates a WordList.
+  #
+  def create_word_list(*args)
+    http_method = :post
+    path = '/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/words.rb

@@ -0,0 +1,482 @@
+# 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 WordsMethods
+
+  # Returns a single random WordObject, in the format specified by the URL
+  #
+  def get_random_word(*args)
+    http_method = :get
+    path = '/words/randomWord'
+    # 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 array of random WordObjects, in the format specified by the URL
+  #
+  def get_random_words(*args)
+    http_method = :get
+    path = '/words/randomWords'
+    # 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
+
+  # Searches words.
+  #
+  def search_words(*args)
+    http_method = :get
+    path = '/words/search'
+    # 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 an array of WordOfTheDayList basd on a criteria
+  #
+  def get_word_of_the_day_lists_containing_word(*args)
+    http_method = :get
+    path = '/words/wordOfTheDayLists'
+    # 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 WordOfTheDay objects for a specific date
+  #
+  def get_word_of_the_day_lists_for_date(date, *args)
+    http_method = :get
+    path = '/words/wordOfTheDayLists/{date}'
+    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
+
+  # Subscribes a user to a WordOfTheDayList
+  #
+  def subscribe_to_list(permalink, *args)
+    http_method = :post
+    path = '/words/wordOfTheDayList/{permalink}/subscription'
+    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
+
+  # Searches definitions.
+  #
+  def search_definitions(*args)
+    http_method = :get
+    path = '/words/searchDefinitions'
+    # 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
+
+  # Searches dictionary entries.
+  #
+  def search_entries(*args)
+    http_method = :get
+    path = '/words/searchEntries'
+    # 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 surface forms of a word
+  #
+  def get_surface_forms(*args)
+    http_method = :get
+    path = '/words/surfaceForms'
+    # 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 specific WordOfTheDay
+  #
+  def get_word_of_the_day(*args)
+    http_method = :get
+    path = '/words/wordOfTheDay'
+    # 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 WordOfTheDay range
+  #
+  def get_word_of_the_day_range(*args)
+    http_method = :get
+    path = '/words/wordOfTheDay/range'
+    # 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 a WordOfTheDayList by ID
+  #
+  def get_word_of_the_day_list(permalink, *args)
+    http_method = :get
+    path = '/words/wordOfTheDayList/{permalink}'
+    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
+
+  # Fetches a WordOfTheDayList by ID
+  #
+  def get_word_of_the_day_list_item(permalink, specifier, *args)
+    http_method = :get
+    path = '/words/wordOfTheDayList/{permalink}/{specifier}'
+    path.sub!('{permalink}', permalink)
+
+    path.sub!('{specifier}', specifier)
+
+    # 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 recently created WordOfTheDayLists
+  #
+  def get_recent_word_of_the_day_lists(*args)
+    http_method = :get
+    path = '/words/wordOfTheDayLists/recent'
+    # 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 whether or not a subscription process has been run.
+  # Uses the current server time (day resolution) as the default date to check for, optionally a dateString can be supplied for a specific date to check for.
+  #
+  def get_word_of_the_day_list_subscription_process_status(*args)
+    http_method = :get
+    path = '/words/wordOfTheDayLists/subscriptionProcess'
+    # 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/version.rb

@@ -1,3 +1,3 @@
 module Wordnik
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

data/lib/wordnik.rb

@@ -48,6 +48,13 @@ module Wordnik
       end
     end
 
+    # The names of all the resources (in the production API).
+    # This is used by Wordnik.build_resources and the rake task that fetches remote API docs
+    #
+    def resource_names
+      %w(account corpus document partners system tag user users word words wordList wordLists)
+    end
+
     def authenticated?
       Wordnik.configuration.user_id.present? && Wordnik.configuration.auth_token.present?
     end
@@ -64,7 +71,16 @@ module Wordnik
         raise ConfigurationError, "Username and password are required to authenticate."
       end
       
-      response_body = Wordnik.account.get_authenticate(Wordnik.configuration.username, :password => Wordnik.configuration.password)
+      # response_body = Wordnik.account.get_authenticate(Wordnik.configuration.username, :password => Wordnik.configuration.password)
+      
+      request = Wordnik::Request.new(
+        :get, 
+        "account/authenticate/{username}", 
+        :params => {:username => Wordnik.configuration.username, :password => Wordnik.configuration.password}
+      )
+      
+      response_body = request.response.body
+      
       if response_body.is_a?(Hash) && response_body['userId'].present? && response_body['token'].present?
         Wordnik.configuration.user_id = response_body['userId']
         Wordnik.configuration.auth_token = response_body['token']
@@ -72,14 +88,7 @@ module Wordnik
         raise ApiServerError, response_body.to_s
       end
     end
-    
-    # The names of all the resources (in the production API).
-    # This is used by Wordnik.build_resources and the rake task that fetches remote API docs
-    #
-    def resource_names
-      %w(account corpus document partners system tag user users word words wordList wordLists wordoftheday)
-    end
-    
+            
     # Aliases. For convenience.
     #
     def account; Wordnik.resources[:account]; end
@@ -95,8 +104,7 @@ module Wordnik
     def words; Wordnik.resources[:words]; end
     def word_list; Wordnik.resources[:word_list]; end
     def word_lists; Wordnik.resources[:word_lists]; end
-    def wordoftheday; Wordnik.resources[:wordoftheday]; end
-        
+
   end
   
 end

data/spec/endpoint_spec.rb

@@ -4,7 +4,7 @@ describe Wordnik::Endpoint do
 
   before(:each) do
     VCR.use_cassette('words', :record => :new_episodes) do
-      @response = Typhoeus::Request.get("http://api.wordnik.com/v4/word.json")
+      @response = Typhoeus::Request.get("http://beta.wordnik.com/v4/word.json")
     end
     @resource = Wordnik::Resource.new(:name => "word", :raw_data => JSON.parse(@response.body))
     @endpoint = @resource.endpoints.first

data/spec/operation_parameter_spec.rb

@@ -4,7 +4,7 @@ describe Wordnik::OperationParameter do
 
   before(:each) do
     VCR.use_cassette('words', :record => :new_episodes) do
-      @response = Typhoeus::Request.get("http://api.wordnik.com/v4/word.json")
+      @response = Typhoeus::Request.get("http://beta.wordnik.com/v4/word.json")
     end
 
     @operation_parameter = Wordnik::OperationParameter.new(JSON.parse(@response.body)['endPoints'].first['operations'].first['parameters'].first)

data/spec/operation_spec.rb

@@ -4,7 +4,7 @@ describe Wordnik::Operation do
 
   before(:each) do
     VCR.use_cassette('words', :record => :new_episodes) do
-      @response = Typhoeus::Request.get("http://api.wordnik.com/v4/word.json")
+      @response = Typhoeus::Request.get("http://beta.wordnik.com/v4/word.json")
     end
     @resource = Wordnik::Resource.new(:name => "word", :raw_data => JSON.parse(@response.body))
     @endpoint = @resource.endpoints.first

data/spec/request_spec.rb

@@ -162,7 +162,11 @@ describe Wordnik::Request do
       @request.query_string.should == "?badDog=bud&goodDog=dud"
     end
     
-    it "converts boolean values to their string representation"
+    it "converts boolean values to their string representation" do
+      params = {:stringy => "fish", :truthy => true, :falsey => false}
+      @request = Wordnik::Request.new(:get, 'fakeMethod', :params => params)
+      @request.query_string.should == "?falsey=false&stringy=fish&truthy=true"
+    end
     
   end