web_translate_it 2.0.0.rc2 → 2.0.0.rc3

data/lib/web_translate_it/term.rb

@@ -4,25 +4,23 @@ module WebTranslateIt
     require 'net/https'
     require 'json'
     
-    attr_accessor :api_key, :id, :text, :description, :created_at, :updated_at, :translations, :new_record
+    attr_accessor :id, :text, :description, :created_at, :updated_at, :translations, :new_record
     
     # Initialize a new WebTranslateIt::Term
-    # The only mandatory parameter is `api_key`
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Term.new('secret_api_token', { "text" => "Term Name" })
+    #   WebTranslateIt::Term.new({ "text" => "Term Name" })
     #
     # to instantiate a new Term.
     #
     #   translation_es = WebTranslateIt::TermTranslation.new({ "locale" => "es", "text" => "Hola" })
     #   translation_fr = WebTranslateIt::TermTranslation.new({ "locale" => "fr", "text" => "Bonjour" })
-    #   WebTranslateIt::Term.new('secret_api_token', { "text" => "Hello", "translations" => [translation_es, translation_fr]})
+    #   WebTranslateIt::Term.new({ "text" => "Hello", "translations" => [translation_es, translation_fr]})
     #
     # to instantiate a new Term with a Term Translations in Spanish and French.
     
-    def initialize(api_key, params = {})
-      self.api_key      = api_key
+    def initialize(params = {})
       self.id           = params["id"] || nil
       self.text         = params["text"] || nil
       self.description  = params["description"] || nil
@@ -33,20 +31,19 @@ module WebTranslateIt
     end
     
     # Fetch all terms
-    # Needs a HTTPS Connection
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     terms = WebTranslateIt::Term.find_all(connection, 'secret_api_token')
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     terms = WebTranslateIt::Term.find_all
     #   end
     #
     #  puts terms.inspect #=> An array of WebTranslateIt::Term objects
     #
     # TODO: Implement pagination
     
-    def self.find_all(http_connection, api_key, params = {})
-      url = "/api/projects/#{api_key}/terms.yaml"
+    def self.find_all(params = {})
+      url = "/api/projects/#{Connection.api_key}/terms.yaml"
       url += '?' + HashUtil.to_params(params) unless params.empty?
 
       request = Net::HTTP::Get.new(url)
@@ -54,10 +51,10 @@ module WebTranslateIt
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
 
       begin
-        response = Util.handle_response(http_connection.request(request), true)
+        response = Util.handle_response(Connection.http_connection.request(request), true)
         terms = []
         YAML.load(response).each do |term_response|
-          term = WebTranslateIt::Term.new(api_key, term_response)
+          term = WebTranslateIt::Term.new(term_response)
           term.new_record = false
           terms.push(term)
         end
@@ -71,12 +68,11 @@ module WebTranslateIt
     end
     
     # Find a Term based on its ID
-    # Needs a HTTPS Connection
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     term = WebTranslateIt::Term.find(connection, 'secret_api_token', 1234)
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     term = WebTranslateIt::Term.find(1234)
     #   end
     #
     #   puts term.inspect #=> A Term object
@@ -84,15 +80,15 @@ module WebTranslateIt
     # to find and instantiate the Term which ID is `1234`.
     #
     
-    def self.find(http_connection, api_key, term_id)
-      request = Net::HTTP::Get.new("/api/projects/#{api_key}/terms/#{term_id}.yaml")
+    def self.find(term_id)
+      request = Net::HTTP::Get.new("/api/projects/#{Connection.api_key}/terms/#{term_id}.yaml")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
 
       begin
-        response = http_connection.request(request)
+        response = Connection.http_connection.request(request)
         return nil if response.code.to_i == 404
-        term = WebTranslateIt::Term.new(api_key, YAML.load(response.body))
+        term = WebTranslateIt::Term.new(YAML.load(response.body))
         term.new_record = false
         return term
       rescue Timeout::Error
@@ -103,43 +99,37 @@ module WebTranslateIt
     end
 
     # Update or create a Term to WebTranslateIt.com
-    # Needs a HTTPS Connection
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     term = WebTranslateIt::Term.find(connection, 'secret_api_token', 1234)
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     term = WebTranslateIt::Term.find(1234)
     #     term.text = "Hello"
-    #     term.save(http_connection)
+    #     term.save
     #   end
     #
 
-    def save(http_connection)
-      if self.new_record
-        self.create(http_connection)
-      else
-        self.update(http_connection)
-      end
+    def save
+      self.new_record ? self.create : self.update
     end
     
     # Delete a Term on WebTranslateIt.com
-    # Needs a HTTPS Connection
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     term = WebTranslateIt::Term.find(connection, 'secret_api_token', 1234)
-    #     term.delete(http_connection)
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     term = WebTranslateIt::Term.find(1234)
+    #     term.delete
     #   end
     #
     
-    def delete(http_connection)
-      request = Net::HTTP::Delete.new("/api/projects/#{self.api_key}/terms/#{self.id}")
+    def delete
+      request = Net::HTTP::Delete.new("/api/projects/#{Connection.api_key}/terms/#{self.id}")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
 
       begin
-        Util.handle_response(http_connection.request(request), true)
+        Util.handle_response(Connection.http_connection.request(request), true)
       rescue Timeout::Error
         puts "The request timed out. The service may be overloaded. We will retry in 5 seconds."
         sleep(5)
@@ -148,29 +138,28 @@ module WebTranslateIt
     end
     
     # Gets a Translation for a Term
-    # Needs a HTTPS Connection
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     term = WebTranslateIt::Term.find(connection, 'secret_api_token', 1234)
-    #     puts term.translation_for(connection, "fr") #=> A TermTranslation object
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     term = WebTranslateIt::Term.find(1234)
+    #     puts term.translation_for("fr") #=> A TermTranslation object
     #   end
     #
     
-    def translation_for(http_connection, locale)
+    def translation_for(locale)
       return self.translations unless self.translations == []
-      request = Net::HTTP::Get.new("/api/projects/#{self.api_key}/terms/#{self.id}/locales/#{locale}/translations.yaml")
+      request = Net::HTTP::Get.new("/api/projects/#{Connection.api_key}/terms/#{self.id}/locales/#{locale}/translations.yaml")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
 
       begin
-        response = Util.handle_response(http_connection.request(request), true)
+        response = Util.handle_response(Connection.http_connection.request(request), true)
         array = YAML.load(response)
         return nil if array.empty?
         translations = []
         array.each do |translation|
-          term_translation = WebTranslateIt::TermTranslation.new(api_key, translation)
+          term_translation = WebTranslateIt::TermTranslation.new(translation)
           translations.push(term_translation)
         end
         return translations
@@ -184,8 +173,8 @@ module WebTranslateIt
 
     protected
 
-    def update(http_connection)
-      request = Net::HTTP::Put.new("/api/projects/#{self.api_key}/terms/#{self.id}.yaml")
+    def update
+      request = Net::HTTP::Put.new("/api/projects/#{Connection.api_key}/terms/#{self.id}.yaml")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
       request.add_field("Content-Type", "application/json")
@@ -194,11 +183,11 @@ module WebTranslateIt
 
       self.translations.each do |translation|
         translation.term_id = self.id
-        translation.save(http_connection)
+        translation.save
       end
 
       begin
-        Util.handle_response(http_connection.request(request), true)
+        Util.handle_response(Connection.http_connection.request(request), true)
       rescue Timeout::Error
         puts "The request timed out. The service may be overloaded. We will retry in 5 seconds."
         sleep(5)
@@ -206,8 +195,8 @@ module WebTranslateIt
       end
     end
     
-    def create(http_connection)
-      request = Net::HTTP::Post.new("/api/projects/#{api_key}/terms")
+    def create
+      request = Net::HTTP::Post.new("/api/projects/#{Connection.api_key}/terms")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
       request.add_field("Content-Type", "application/json")
@@ -215,7 +204,7 @@ module WebTranslateIt
       request.body = self.to_json(true)
 
       begin
-        response = YAML.load(Util.handle_response(http_connection.request(request), true))
+        response = YAML.load(Util.handle_response(Connection.http_connection.request(request), true))
         self.id = response["id"]
         self.new_record = false
         return true

data/lib/web_translate_it/term_translation.rb

@@ -4,20 +4,18 @@ module WebTranslateIt
     require 'net/https'
     require 'json'
     
-    attr_accessor :api_key, :id, :locale, :text, :description, :status, :new_record, :term_id
+    attr_accessor :id, :locale, :text, :description, :status, :new_record, :term_id
     
     # Initialize a new WebTranslateIt::TermTranslation
-    # Mandatory parameter is `api_key`
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::TermTranslation.new('secret_api_token', { "text" => "Super!" })
+    #   WebTranslateIt::TermTranslation.new({ "text" => "Super!" })
     #
     # to instantiate a new TermTranslation.
     #
     
-    def initialize(api_key, params = {})
-      self.api_key     = api_key
+    def initialize(params = {})
       self.id          = params["id"] || nil
       self.locale      = params["locale"] || nil
       self.text        = params["text"] || nil
@@ -31,19 +29,14 @@ module WebTranslateIt
     #
     # Implementation Example:
     #
-    #   translation = WebTranslateIt::TermTranslation.new('secret_api_token', { "term_id" => "1234", "text" => "Super!" })
-    #   translation.text = "I changed it!"
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     translation.save(connection)
+    #   translation = WebTranslateIt::TermTranslation.new({ "term_id" => "1234", "text" => "Super!" })
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     translation.save
     #   end
     #
     
-    def save(http_connection)
-      if self.new_record
-        self.create(http_connection)
-      else
-        self.update(http_connection)
-      end
+    def save
+      self.new_record ? self.create : self.update
     end
     
     def to_hash
@@ -58,8 +51,8 @@ module WebTranslateIt
     
     protected
     
-    def create(http_connection)
-      request = Net::HTTP::Post.new("/api/projects/#{self.api_key}/terms/#{self.term_id}/locales/#{self.locale}/translations")
+    def create
+      request = Net::HTTP::Post.new("/api/projects/#{Connection.api_key}/terms/#{self.term_id}/locales/#{self.locale}/translations")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
       request.add_field("Content-Type", "application/json")
@@ -67,7 +60,7 @@ module WebTranslateIt
       request.body = self.to_hash.to_json
 
       begin
-        response = Util.handle_response(http_connection.request(request), true)
+        response = Util.handle_response(Connection.http_connection.request(request), true)
         response = YAML.load(response)
         self.id = response["id"]
         self.new_record = false
@@ -80,8 +73,8 @@ module WebTranslateIt
       end
     end
 
-    def update(http_connection)
-      request = Net::HTTP::Put.new("/api/projects/#{self.api_key}/terms/#{self.id}/locales/#{self.locale}/translations/#{self.id}")
+    def update
+      request = Net::HTTP::Put.new("/api/projects/#{Connection.api_key}/terms/#{self.id}/locales/#{self.locale}/translations/#{self.id}")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
       request.add_field("Content-Type", "application/json")
@@ -89,7 +82,7 @@ module WebTranslateIt
       request.body = self.to_hash.to_json
 
       begin
-        Util.handle_response(http_connection.request(request), true)
+        Util.handle_response(Connection.http_connection.request(request), true)
         
       rescue Timeout::Error
         puts "The request timed out. The service may be overloaded. We will retry in 5 seconds."
@@ -97,6 +90,5 @@ module WebTranslateIt
         retry
       end
     end
-
   end
 end

data/lib/web_translate_it/translation.rb

@@ -4,20 +4,18 @@ module WebTranslateIt
     require 'net/https'
     require 'json'
     
-    attr_accessor :api_key, :id, :locale, :text, :status, :created_at, :updated_at, :version, :string_id
+    attr_accessor :id, :locale, :text, :status, :created_at, :updated_at, :version, :string_id
     
     # Initialize a new WebTranslateIt::Translation
-    # Mandatory parameters are `api_key` and { "string_id" => "1234" }
     #
     # Implementation Example:
     #
-    #   WebTranslateIt::Translation.new('secret_api_token', { "string_id" => "1234", "text" => "Super!" })
+    #   WebTranslateIt::Translation.new({ "string_id" => "1234", "text" => "Super!" })
     #
     # to instantiate a new Translation without any text.
     #
     
-    def initialize(api_key, params = {})
-      self.api_key    = api_key
+    def initialize(params = {})
       self.id         = params["id"] || nil
       self.locale     = params["locale"] || nil
       self.text       = params["text"] || nil
@@ -36,22 +34,21 @@ module WebTranslateIt
     #
     # Implementation Example:
     #
-    #   translation = WebTranslateIt::Translation.new('secret_api_token', { "string_id" => "1234", "text" => "Super!" })
-    #   translation.text = "I changed it!"
-    #   WebTranslateIt::Util.http_connection do |connection|
-    #     translation.save(connection)
+    #   translation = WebTranslateIt::Translation.new({ "string_id" => "1234", "text" => "Super!" })
+    #   WebTranslateIt::Connection.new('secret_api_token') do
+    #     translation.save
     #   end
     #
     
-    def save(http_connection)
-      request = Net::HTTP::Post.new("/api/projects/#{self.api_key}/strings/#{self.string_id}/locales/#{self.locale}/translations")
+    def save
+      request = Net::HTTP::Post.new("/api/projects/#{Connection.api_key}/strings/#{self.string_id}/locales/#{self.locale}/translations")
       request.add_field("X-Client-Name", "web_translate_it")
       request.add_field("X-Client-Version", WebTranslateIt::Util.version)
       request.add_field("Content-Type", "application/json")
       request.body = self.to_hash.to_json
 
       begin
-        Util.handle_response(http_connection.request(request), true)
+        Util.handle_response(Connection.http_connection.request(request), true)
       rescue Timeout::Error
         puts "The request timed out. The service may be overloaded. We will retry in 5 seconds."
         sleep(5)

data/lib/web_translate_it/util.rb

@@ -1,9 +1,5 @@
 # encoding: utf-8
 module WebTranslateIt
-  require 'net/http'
-  require 'net/https'
-  require 'uri'
-  require 'ostruct'
   
   # A few useful functions
   class Util
@@ -13,41 +9,7 @@ module WebTranslateIt
     def self.version
       IO.read(File.expand_path('../../../version', __FILE__))
     end
-    
-    # Yields a HTTP connection over SSL to Web Translate It.
-    # This is used for the connections to the API throughout the library.
-    # Use it like so:
-    # 
-    #   WebTranslateIt::Util.http_connection do |http|
-    #     request = Net::HTTP::Get.new(api_url)
-    #     response = http.request(request)
-    #   end
-    #
-    # This method will try to connect through a proxy if `http_proxy` is set.
-    #
-    def self.http_connection
-      proxy = ENV['http_proxy'] ? URI.parse(ENV['http_proxy']) : OpenStruct.new
-      http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new('webtranslateit.com', 443)
-      http.use_ssl      = true
-      http.open_timeout = http.read_timeout = 30
-      begin
-        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
-        if File.exists?('/etc/ssl/certs') # Ubuntu
-          http.ca_path = '/etc/ssl/certs'
-        else
-          http.ca_file = File.expand_path('cacert.pem', __FILE__)
-        end
-        yield http.start
-      rescue OpenSSL::SSL::SSLError
-        puts "Unable to verify SSL certificate."
-        http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new('webtranslateit.com', 443)
-        http.use_ssl      = true
-        http.open_timeout = http.read_timeout = 30
-        http.verify_mode  = OpenSSL::SSL::VERIFY_NONE
-        yield http.start
-      end
-    end
-        
+            
     def self.calculate_percentage(processed, total)
       return 0 if total == 0
       ((processed*10)/total).to_f.ceil*10

data/spec/web_translate_it/string_spec.rb

@@ -6,8 +6,7 @@ describe WebTranslateIt::String do
   
   describe "#initialize" do
     it "should assign api_key and many parameters" do
-      string = WebTranslateIt::String.new(api_key, { "id" => 1234, "key" => "bacon"})
-      string.api_key.should == api_key
+      string = WebTranslateIt::String.new({ "id" => 1234, "key" => "bacon"})
       string.id.should == 1234
       string.key.should == "bacon"
     end
@@ -15,80 +14,80 @@ describe WebTranslateIt::String do
   
   describe "#save" do
     it "should create a new String" do
-      WebTranslateIt::Util.http_connection do |connection|
-        string = WebTranslateIt::String.new(api_key, { "key" => "bacon" })
-        string.save(connection)
+      WebTranslateIt::Connection.new(api_key) do
+        string = WebTranslateIt::String.new({ "key" => "bacon" })
+        string.save
         string.id.should_not be_nil
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
+        string_fetched = WebTranslateIt::String.find(string.id)
         string_fetched.should_not be_nil
         string_fetched.should be_a(WebTranslateIt::String)
         string_fetched.id.should == string.id
-        string.delete(connection)
+        string.delete
       end
     end
     
     it "should update an existing String" do
-      WebTranslateIt::Util.http_connection do |connection|
-        string = WebTranslateIt::String.new(api_key, { "key" => "bacony" })
-        string.save(connection)
+      WebTranslateIt::Connection.new(api_key) do
+        string = WebTranslateIt::String.new({ "key" => "bacony" })
+        string.save
         string.key = "bacon changed"
-        string.save(connection)
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
+        string.save
+        string_fetched = WebTranslateIt::String.find(string.id)
         string_fetched.key.should == "bacon changed"
-        string.delete(connection)
+        string.delete
       end
     end
     
     it "should create a new String with Translation" do
-      translation1 = WebTranslateIt::Translation.new(api_key, { "locale" => "en", "text" => "Hello" })
-      translation2 = WebTranslateIt::Translation.new(api_key, { "locale" => "fr", "text" => "Bonjour" })
+      translation1 = WebTranslateIt::Translation.new({ "locale" => "en", "text" => "Hello" })
+      translation2 = WebTranslateIt::Translation.new({ "locale" => "fr", "text" => "Bonjour" })
       
-      string = WebTranslateIt::String.new(api_key, { "key" => "bacon", "translations" => [translation1, translation2] })
-      WebTranslateIt::Util.http_connection do |connection|
-        string.save(connection)
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
-        string_fetched.translation_for(connection, "en").should_not be_nil
-        string_fetched.translation_for(connection, "en").text.should == "Hello"
-        string_fetched.translation_for(connection, "fr").should_not be_nil
-        string_fetched.translation_for(connection, "fr").text.should == "Bonjour"
-        string_fetched.translation_for(connection, "es").should be_nil
-        string.delete(connection)
+      string = WebTranslateIt::String.new({ "key" => "bacon", "translations" => [translation1, translation2] })
+      WebTranslateIt::Connection.new(api_key) do
+        string.save
+        string_fetched = WebTranslateIt::String.find(string.id)
+        string_fetched.translation_for("en").should_not be_nil
+        string_fetched.translation_for("en").text.should == "Hello"
+        string_fetched.translation_for("fr").should_not be_nil
+        string_fetched.translation_for("fr").text.should == "Bonjour"
+        string_fetched.translation_for("es").should be_nil
+        string.delete
       end
     end
     
     it "should update a String and save its Translation" do
-      translation1 = WebTranslateIt::Translation.new(api_key, { "locale" => "en", "text" => "Hello" })
-      translation2 = WebTranslateIt::Translation.new(api_key, { "locale" => "fr", "text" => "Bonjour" })
+      translation1 = WebTranslateIt::Translation.new({ "locale" => "en", "text" => "Hello" })
+      translation2 = WebTranslateIt::Translation.new({ "locale" => "fr", "text" => "Bonjour" })
       
-      string = WebTranslateIt::String.new(api_key, { "key" => "bacon" })
-      WebTranslateIt::Util.http_connection do |connection|
-        string.save(connection)
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
-        string_fetched.translation_for(connection, "fr").should be_nil
+      string = WebTranslateIt::String.new({ "key" => "bacon" })
+      WebTranslateIt::Connection.new(api_key) do
+        string.save
+        string_fetched = WebTranslateIt::String.find(string.id)
+        string_fetched.translation_for("fr").should be_nil
         
         string_fetched.translations = [translation1, translation2]
-        string_fetched.save(connection)
+        string_fetched.save
         
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
-        string_fetched.translation_for(connection, "en").should_not be_nil
-        string_fetched.translation_for(connection, "en").text.should == "Hello"
-        string_fetched.translation_for(connection, "fr").should_not be_nil
-        string_fetched.translation_for(connection, "fr").text.should == "Bonjour"
-        string.delete(connection)
+        string_fetched = WebTranslateIt::String.find(string.id)
+        string_fetched.translation_for("en").should_not be_nil
+        string_fetched.translation_for("en").text.should == "Hello"
+        string_fetched.translation_for("fr").should_not be_nil
+        string_fetched.translation_for("fr").text.should == "Bonjour"
+        string.delete
       end
     end
   end
   
   describe "#delete" do
     it "should delete a String" do
-      string = WebTranslateIt::String.new(api_key, { "key" => "bacon" })
-      WebTranslateIt::Util.http_connection do |connection|
-        string.save(connection)
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
+      string = WebTranslateIt::String.new({ "key" => "bacon" })
+      WebTranslateIt::Connection.new(api_key) do
+        string.save
+        string_fetched = WebTranslateIt::String.find(string.id)
         string_fetched.should_not be_nil
         
-        string_fetched.delete(connection)
-        string_fetched = WebTranslateIt::String.find(connection, api_key, string.id)
+        string_fetched.delete
+        string_fetched = WebTranslateIt::String.find(string.id)
         string_fetched.should be_nil
       end
     end
@@ -96,31 +95,31 @@ describe WebTranslateIt::String do
   
   describe "#find_all" do
     it "should find many strings" do
-      WebTranslateIt::Util.http_connection do |connection|
-        string1 = WebTranslateIt::String.new(api_key, { "key" => "bacon" })
-        string1.save(connection)
-        string2 = WebTranslateIt::String.new(api_key, { "key" => "tart" })
-        string2.save(connection)
-        string3 = WebTranslateIt::String.new(api_key, { "key" => "bacon tart" })
-        string3.save(connection)
+      WebTranslateIt::Connection.new(api_key) do
+        string1 = WebTranslateIt::String.new({ "key" => "bacon" })
+        string1.save
+        string2 = WebTranslateIt::String.new({ "key" => "tart" })
+        string2.save
+        string3 = WebTranslateIt::String.new({ "key" => "bacon tart" })
+        string3.save
       
-        strings = WebTranslateIt::String.find_all(connection, api_key, { "key" => "bacon" })
+        strings = WebTranslateIt::String.find_all({ "key" => "bacon" })
         strings.count.should == 2
         strings[0].key.should == "bacon"
         strings[1].key.should == "bacon tart"
         
-        strings = WebTranslateIt::String.find_all(connection, api_key, { "key" => "tart" })
+        strings = WebTranslateIt::String.find_all({ "key" => "tart" })
         strings.count.should == 2
         strings[0].key.should == "tart"
         strings[1].key.should == "bacon tart"
         
-        strings = WebTranslateIt::String.find_all(connection, api_key, { "key" => "bacon tart" })
+        strings = WebTranslateIt::String.find_all({ "key" => "bacon tart" })
         strings.count.should == 1
         strings[0].key.should == "bacon tart"
         
-        string1.delete(connection)
-        string2.delete(connection)
-        string3.delete(connection)
+        string1.delete
+        string2.delete
+        string3.delete
       end
     end
   end