thebigdb 1.1.0 → 1.2.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    thebigdb (1.1.0)
+    thebigdb (1.2.0)
       rack (~> 1.4)
 
 GEM
@@ -29,6 +29,7 @@ GEM
       method_source (~> 0.8)
       slop (~> 3.4)
     rack (1.5.2)
+    rake (10.0.3)
     rb-fchange (0.0.6)
       ffi
     rb-fsevent (0.9.3)
@@ -54,6 +55,7 @@ PLATFORMS
 
 DEPENDENCIES
   guard-rspec (~> 2.3)
+  rake (~> 10.0.3)
   rb-fchange
   rb-fsevent
   rb-inotify

data/README.md

@@ -1,49 +1,41 @@
 # TheBigDB Ruby Wrapper
 
-A simple ruby wrapper for making requests to the API of [TheBigDB.com][0].
+[![Build Status](https://secure.travis-ci.org/thebigdb/thebigdb-ruby.png)](http://travis-ci.org/thebigdb/thebigdb-ruby)
+
+A simple ruby wrapper for making requests to the API of [TheBigDB.com](http://thebigdb.com). [Full API documentation](http://developers.thebigdb.com/api).
 
 ## Install
 
     gem install thebigdb
 
-## Usage
-
-Make your requests using this structure:
-    
+## Simple usage
 
-    TheBigDB::Statement(action, parameters)
+The following actions return a TheBigDB::StatementRequest object, on which you can add params using ``.with(hash_of_params)``.
+The request will be executed once you call regular methods of Hash on it (``each_pair``, ``[key]``, etc.), or force it with ``execute``.
+The Hash returned represents the server's JSON response.
 
+### Search \([api doc](http://developers.thebigdb.com/api#statements-search)\)
 
-**[action]** => String of the action as described in the API (e.g. "search", "show", ...)  
-**[parameters]** => Hash. Request parameters as described in the API. Tip: Arrays like ``["abc", "def"]`` will automatically be converted to ``{"0" => "abc", "1" => "def"}``
+    TheBigDB.search("iPhone").with(page: 2)
+    TheBigDB.search({match: "James"}, "job", "President of the United States")
+    TheBigDB.search({match: "Facebook"}, "job", {match: "Executive"})
 
+### Create \([api doc](http://developers.thebigdb.com/api#statements-create)\)
 
-Examples:
-    
-    request = TheBigDB::Statement(:search,
-      {
-        nodes: [{search: ""}, "job", "President of the United States"],
-        period: {from: "2000-01-01 00:00:00", to: "2002-01-01 00:00:00"}
-      }
-    )
-
-    puts request.response
+    TheBigDB.create("iPhone 5", "weight", "112 grams")
+    TheBigDB.create("Bill Clinton", "job", "President of the United States").with(period: {from: "1993-01-20 12:00:00", to: "2001-01-20 11:59:59"})
 
-Will print something like:
+### Show \([api doc](http://developers.thebigdb.com/api#statements-show)\), Upvote \([api doc](http://developers.thebigdb.com/api#statements-upvote)\) and Downvote \([api doc](http://developers.thebigdb.com/api#statements-downvote)\)
 
-    {
-      "status" => "success",
-      "statements" => [
-        {"nodes" => ["Bill Clinton", "job", "President of the United States"], "id" => "8e6aec890c942b6f7854d2d7a9f0d002f5ddd0c0", "period"=>{"from" => "1993-01-20 00:00:00", "to" => "2001-01-20 00:00:00"}},
-        {"nodes" => ["George W. Bush", "job", "President of the United States"], "id" => "3f27673816455054032bd46e65bbe4db8ccf9076", "period"=>{"from" => "2001-01-20 00:00:00", "to" => "2009-01-20 00:00:00"}}
-      ]
-    }
+    TheBigDB.show("id-of-the-sentence")
+    TheBigDB.upvote("id-of-the-sentence")
+    TheBigDB.downvote("id-of-the-sentence")
 
 That's it!
 
-## The TheBigDB::Request object
+## TheBigDB::Request object
 
-Every request you make will return a ``TheBigDB::Request`` object.
+If you want more details on what is sent and what is received, you can use the generic TheBigDB::Statement method. It returns a TheBigDB::Request object.
 It has several readable attributes:
     
     request = TheBigDB::Statement(:search, {nodes: ["iPhone", "weight"]})
@@ -59,20 +51,26 @@ It has several readable attributes:
 You can access other parts of the API in the same way as statements:
     
     TheBigDB::User(action, parameters)
-    TheBigDB::Toolbox::Unit(action, parameters)
 
     # Examples
     TheBigDB::User(:show, {login: "christophe"}).response["user"]["karma"]
-    TheBigDB::Toolbox::Unit(:compare, {values: ["100 g", "1.2 kg"]}).response["result"]
 
 You can modify the TheBigDB module with several configuration options:
 
     TheBigDB.api_key = "your-private-api-key"           # default: nil
     TheBigDB.use_ssl = true                             # default: false
 
+    # If true, and a request response has {"status" => "error"}, it will raise a TheBigDB::Request::ApiStatusError exception with the API error code
+    TheBigDB.raise_on_api_status_error = true           # default: false
+
     # Both of them take a Proc or a Lambda, the TheBigDB::Request instance is passed as argument
-    TheBigDB.before_request_execution = ->(request){ Logger.foo(request) }   # default: Proc.new{}
-    TheBigDB.after_request_execution = ->(request){ Logger.foo(request) }    # default: Proc.new{}
+    TheBigDB.before_request_execution = ->(request){ logger.info(request.data_sent) }     # default: Proc.new{}
+    TheBigDB.after_request_execution = ->(request){ logger.info(request.data_received) }  # default: Proc.new{}
+
+    # You can also modify the configuration temporarily
+    TheBigDB.with_configuration(use_ssl: true) do
+      # your code here
+    end
 
 
 ## Contributing
@@ -86,6 +84,3 @@ Don't hesitate to send a pull request !
 ## License
 
 This software is distributed under the MIT License. Copyright (c) 2013, Christophe Maximin <christophe@thebigdb.com>
-
-
-[0]: http://thebigdb.com

data/lib/thebigdb/helpers.rb

@@ -0,0 +1,49 @@
+module TheBigDB
+  module Helpers
+
+    # serialize_query_params({house: "bricks", animals: ["cat", "dog"], computers: {cool: true, drives: ["hard", "flash"]}})
+    # => house=bricks&animals%5B%5D=cat&animals%5B%5D=dog&computers%5Bcool%5D=true&computers%5Bdrives%5D%5B%5D=hard&computers%5Bdrives%5D%5B%5D=flash
+    # which will be read by the server as:
+    # => house=bricks&animals[]=cat&animals[]=dog&computers[cool]=true&computers[drives][]=hard&computers[drives][]=flash
+    def self.serialize_query_params(params, prefix = nil)
+      ret = []
+      params.each_pair do |key, value|
+        param_key = prefix ? "#{prefix}[#{key}]" : key
+
+        if value.is_a?(Hash)
+          ret << self.serialize_query_params(value, param_key.to_s)
+        elsif value.is_a?(Array)
+          sub_hash = {}
+          value.each_with_index do |value_item, i|
+            sub_hash[i.to_s] = value_item
+          end
+          ret << self.serialize_query_params(sub_hash, param_key.to_s)
+        else
+          ret << URI.encode_www_form_component(param_key.to_s) + "=" + URI.encode_www_form_component(value.to_s)
+        end
+      end
+      ret.join("&")
+    end
+
+    # flatten_params_keys({house: "bricks", animals: ["cat", "dog"], computers: {cool: true, drives: ["hard", "flash"]}})
+    # => {"house" => "bricks", "animals[0]" => "cat", "animals[1]" => "dog", "computers[cool]" => "true", "computers[drives][0]" => "hard", "computers[drives][1]" => "flash"}
+    def self.flatten_params_keys(params)
+      serialized_params = self.serialize_query_params(params)
+      new_params = {}
+      serialized_params.split("&").each do |assign|
+        key, value = assign.split("=")
+        new_params[URI.decode(key)] = URI.decode(value)
+      end
+      new_params
+    end
+
+    # Inspired by on ActiveSupport's stringify_keys
+    def self.stringify_keys(hash)
+      hash.inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
+      end
+    end
+
+  end
+end

data/lib/thebigdb/request.rb

@@ -1,5 +1,7 @@
 module TheBigDB
   class Request
+    class ApiStatusError < StandardError; end
+
     attr_reader :http, :http_request, :http_response, :data_sent, :data_received, :response
 
     # Prepares the basic @http object with the current values of the module (host, port, ...)
@@ -24,11 +26,11 @@ module TheBigDB
       request_uri = "/v#{TheBigDB.api_version}" + (request_uri.start_with?("/") ? request_uri : "/#{request_uri}")
 
       if method == "get"
-        encoded_params = TheBigDB::Request::serialize_query_params(params)
+        encoded_params = TheBigDB::Helpers::serialize_query_params(params)
         @http_request = Net::HTTP::Get.new(request_uri + "?" + encoded_params)
       elsif method == "post"
         @http_request = Net::HTTP::Post.new(request_uri)
-        @http_request.set_form_data(TheBigDB::Request::flatten_params_keys(params))
+        @http_request.set_form_data(TheBigDB::Helpers::flatten_params_keys(params))
       else
         raise ArgumentError, "The request method must be 'get' or 'post'"
       end
@@ -50,28 +52,14 @@ module TheBigDB
     # Actually makes the request prepared in @http_request, and sets @http_response
     def execute
       # Here is the order of operations:
+      # -> setting @data_sent
       # -> executing before_request_execution callback
       # -> executing the HTTP request
       # -> setting @response
-      # -> setting @data_sent
       # -> setting @data_received
       # -> executing after_request_execution callback
 
-      # Executing callback
-      TheBigDB.before_request_execution.call(self)
-
-      # Here is where the request is actually executed
-      @http_response = @http.request(@http_request)
-
-      # Setting @response
-      begin
-        # We parse the JSON answer and return it.
-        @response = JSON(@http_response.body)
-      rescue JSON::ParserError => e
-        @response = {"error" => {"code" => "0000", "description" => "The server gave an invalid JSON body:\n#{@http_response.body}"}}
-      end
-
-      # Setting @data_sent and @data_received
+      # Setting @data_sent
       params = Rack::Utils.parse_nested_query(URI.parse(@http_request.path).query)
       # Since that's how it will be interpreted anyway on the server, we merge the POST params to the GET params,
       # but it's not supposed to happen: either every params is prepared for GET/query params, or as POST body
@@ -92,54 +80,36 @@ module TheBigDB
         "params" => params
       }
 
+      # Executing callback
+      TheBigDB.before_request_execution.call(self)
+
+      # Here is where the request is actually executed
+      @http_response = @http.request(@http_request)
+
+      # Setting @response
+      begin
+        # We parse the JSON answer and return it.
+        @response = JSON(@http_response.body)
+      rescue JSON::ParserError => e
+        @response = {"status" => "error", "error" => {"code" => "0000", "description" => "The server gave an invalid JSON body:\n#{@http_response.body}"}}
+      end
+
+      # Setting @data_received
       @data_received = {
         "headers" => Hash[@http_response.to_hash.map{|k,v| [k, v.join] }],
         "content" => @response
       }
 
+      # Executing callback
       TheBigDB.after_request_execution.call(self)
 
-      self
-    end
-
-    ##############
-    ## Engine Helpers
-    ##############
-
-    # serialize_query_params({house: "bricks", animals: ["cat", "dog"], computers: {cool: true, drives: ["hard", "flash"]}})
-    # => house=bricks&animals%5B%5D=cat&animals%5B%5D=dog&computers%5Bcool%5D=true&computers%5Bdrives%5D%5B%5D=hard&computers%5Bdrives%5D%5B%5D=flash
-    # which will be read by the server as:
-    # => house=bricks&animals[]=cat&animals[]=dog&computers[cool]=true&computers[drives][]=hard&computers[drives][]=flash
-    def self.serialize_query_params(params, prefix = nil)
-      ret = []
-      params.each_pair do |key, value|
-        param_key = prefix ? "#{prefix}[#{key}]" : key
-
-        if value.is_a?(Hash)
-          ret << self.serialize_query_params(value, param_key.to_s)
-        elsif value.is_a?(Array)
-          sub_hash = {}
-          value.each_with_index do |value_item, i|
-            sub_hash[i.to_s] = value_item
-          end
-          ret << self.serialize_query_params(sub_hash, param_key.to_s)
-        else
-          ret << URI.encode_www_form_component(param_key.to_s) + "=" + URI.encode_www_form_component(value.to_s)
-        end
+      # Raising exception if asked
+      if TheBigDB.raise_on_api_status_error and @response["status"] == "error"
+        raise ApiStatusError.new(@response["error"]["code"])
       end
-      ret.join("&")
-    end
 
-    # flatten_params_keys({house: "bricks", animals: ["cat", "dog"], computers: {cool: true, drives: ["hard", "flash"]}})
-    # => {"house" => "bricks", "animals[0]" => "cat", "animals[1]" => "dog", "computers[cool]" => "true", "computers[drives][0]" => "hard", "computers[drives][1]" => "flash"}
-    def self.flatten_params_keys(params)
-      serialized_params = self.serialize_query_params(params)
-      new_params = {}
-      serialized_params.split("&").each do |assign|
-        key, value = assign.split("=")
-        new_params[URI.decode(key)] = URI.decode(value)
-      end
-      new_params
+      self
     end
+
   end
 end

data/lib/thebigdb/resources/statement.rb

@@ -1,4 +1,5 @@
 module TheBigDB
+  # Generic request to statements executor
   def self.Statement(action, params)
     method = ["get", "show", "search"].include?(action.to_s) ? "GET" : "POST"
     path = "/statements/#{action}"
@@ -7,4 +8,57 @@ module TheBigDB
     request.prepare(method, path, params)
     request.execute
   end
+
+  # Beautified builder
+  class StatementRequest
+    attr_reader :action, :params
+
+    def initialize(action)
+      @action = action
+      @params = {}
+      @response = nil
+    end
+
+    def with(params = {})
+      @response = nil
+      @params.merge!(TheBigDB::Helpers::stringify_keys(params))
+      self
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      @response ||= TheBigDB::Statement(@action, @params).response
+      @response.send(method_name, *arguments, &block)
+    end
+
+    def execute
+      to_hash # goes through method_missing
+    end
+    alias_method :response, :execute
+
+    def execute! # forces the request to be re-executed
+      @response = nil
+      to_hash
+    end
+  end
+
+  # Shortcuts to actions
+  def self.search(*nodes)
+    StatementRequest.new("search").with(nodes: nodes)
+  end
+
+  def self.create(*nodes)
+    StatementRequest.new("create").with(nodes: nodes)
+  end
+
+  def self.show(id = "")
+    StatementRequest.new("show").with(id: id)
+  end
+
+  def self.upvote(id = "")
+    StatementRequest.new("upvote").with(id: id)
+  end
+
+  def self.downvote(id = "")
+    StatementRequest.new("downvote").with(id: id)
+  end
 end

data/lib/thebigdb/version.rb

@@ -1,7 +1,7 @@
 module TheBigDB
   module VERSION
     MAJOR = 1
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].compact.join('.')

data/lib/thebigdb.rb

@@ -7,9 +7,9 @@ require "rack"
   aliases
   request
   version
+  helpers
   resources/statement
   resources/user
-  resources/toolbox
 ).each do |file_name|
   require File.join(File.dirname(__FILE__), 'thebigdb', file_name)
 end
@@ -23,7 +23,8 @@ module TheBigDB
     "use_ssl" => false,
     "verify_ssl_certificates" => false,
     "before_request_execution" => Proc.new{},
-    "after_request_execution" => Proc.new{}
+    "after_request_execution" => Proc.new{},
+    "raise_on_api_status_error" => false
   }
 
   DEFAULT_CONFIGURATION.each_key do |configuration_key|
@@ -66,8 +67,11 @@ module TheBigDB
   def self.with_configuration(new_configuration, &block)
     current_configuration = Hash[DEFAULT_CONFIGURATION.keys.map{|k| [k, send(k)] }]
     new_configuration.each_pair{|k,v| send(k.to_s + "=", v) }
-    yield
-    current_configuration.each_pair{|k,v| send(k.to_s + "=", v) }
+    begin
+      yield
+    ensure
+      current_configuration.each_pair{|k,v| send(k.to_s + "=", v) }
+    end
   end
 
 

data/spec/helpers_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+describe "Helpers" do
+  describe "serialize_query_params" do
+    it "works with simple a=b&c=d params" do
+      TheBigDB::Helpers::serialize_query_params(a: "b", c: "d").should == "a=b&c=d"
+    end
+
+    it "works with more complex imbricated params" do
+      TheBigDB::Helpers::serialize_query_params({
+        house: "bricks",
+        animals: ["cat", "dog"],
+        computers: {cool: true, drives: ["hard", "flash"]}
+      }).should == "house=bricks&animals%5B0%5D=cat&animals%5B1%5D=dog&computers%5Bcool%5D=true&computers%5Bdrives%5D%5B0%5D=hard&computers%5Bdrives%5D%5B1%5D=flash"
+
+      # and with a hash instead of an array
+      TheBigDB::Helpers::serialize_query_params({
+        house: "bricks",
+        animals: {"0" => "cat", "1" => "dog"},
+        computers: {cool: true, drives: ["hard", "flash"]}
+      }).should == "house=bricks&animals%5B0%5D=cat&animals%5B1%5D=dog&computers%5Bcool%5D=true&computers%5Bdrives%5D%5B0%5D=hard&computers%5Bdrives%5D%5B1%5D=flash"
+    end
+  end
+
+  describe "flatten_params_keys" do
+    it "works with simple a=b&c=d params" do
+      TheBigDB::Helpers::flatten_params_keys(a: "b", c: "d").should == {"a" => "b", "c" => "d"}
+    end
+
+    it "works with more complex imbricated params" do
+      TheBigDB::Helpers::flatten_params_keys({
+        house: "bricks",
+        animals: ["cat", "dog"],
+        computers: {cool: true, drives: ["hard", "flash"]}
+      }).should == {
+        "house" => "bricks",
+        "animals[0]" => "cat",
+        "animals[1]" => "dog",
+        "computers[cool]" => "true",
+        "computers[drives][0]" => "hard",
+        "computers[drives][1]" => "flash"
+      }
+
+      # and with a hash instead of an array
+      TheBigDB::Helpers::flatten_params_keys({
+        house: "bricks",
+        animals: {"0" => "cat", "1" => "dog"},
+        computers: {cool: true, drives: ["hard", "flash"]}
+      }).should == {
+        "house" => "bricks",
+        "animals[0]" => "cat",
+        "animals[1]" => "dog",
+        "computers[cool]" => "true",
+        "computers[drives][0]" => "hard",
+        "computers[drives][1]" => "flash"
+      }
+    end
+  end
+
+  describe "stringify_keys" do
+    it "works with simple mixed hash" do
+      TheBigDB::Helpers::stringify_keys({
+        :a => "foo",
+        "b" => "bar",
+        "a" => "foo2"
+      }).should == {
+        "a" => "foo2",
+        "b" => "bar"
+      }
+    end
+  end
+end

data/spec/request_spec.rb

@@ -82,6 +82,15 @@ describe "executing" do
     end
   end
 
+  context "failing requests" do
+    it "can raise an exception" do
+      stub_request(:get, /#{TheBigDB.api_host}/).to_return(:body => "invalid json")
+
+      TheBigDB.raise_on_api_status_error = true
+      lambda { TheBigDB.send_request(:get, "/") }.should raise_error(TheBigDB::Request::ApiStatusError, "0000")
+    end
+  end
+
   context "GET requests" do
     context "with basic params" do
       before do
@@ -253,63 +262,4 @@ describe "executing" do
       end
     end
   end
-end
-
-describe "Request helper" do
-  describe "serialize_query_params" do
-    it "works with simple a=b&c=d params" do
-      TheBigDB::Request.serialize_query_params(a: "b", c: "d").should == "a=b&c=d"
-    end
-
-    it "works with more complex imbricated params" do
-      TheBigDB::Request.serialize_query_params({
-        house: "bricks",
-        animals: ["cat", "dog"],
-        computers: {cool: true, drives: ["hard", "flash"]}
-      }).should == "house=bricks&animals%5B0%5D=cat&animals%5B1%5D=dog&computers%5Bcool%5D=true&computers%5Bdrives%5D%5B0%5D=hard&computers%5Bdrives%5D%5B1%5D=flash"
-
-      # and with a hash instead of an array
-      TheBigDB::Request.serialize_query_params({
-        house: "bricks",
-        animals: {"0" => "cat", "1" => "dog"},
-        computers: {cool: true, drives: ["hard", "flash"]}
-      }).should == "house=bricks&animals%5B0%5D=cat&animals%5B1%5D=dog&computers%5Bcool%5D=true&computers%5Bdrives%5D%5B0%5D=hard&computers%5Bdrives%5D%5B1%5D=flash"
-    end
-  end
-
-  describe "flatten_params_keys" do
-    it "works with simple a=b&c=d params" do
-      TheBigDB::Request.flatten_params_keys(a: "b", c: "d").should == {"a" => "b", "c" => "d"}
-    end
-
-    it "works with more complex imbricated params" do
-      TheBigDB::Request.flatten_params_keys({
-        house: "bricks",
-        animals: ["cat", "dog"],
-        computers: {cool: true, drives: ["hard", "flash"]}
-      }).should == {
-        "house" => "bricks",
-        "animals[0]" => "cat",
-        "animals[1]" => "dog",
-        "computers[cool]" => "true",
-        "computers[drives][0]" => "hard",
-        "computers[drives][1]" => "flash"
-      }
-
-      # and with a hash instead of an array
-      TheBigDB::Request.flatten_params_keys({
-        house: "bricks",
-        animals: {"0" => "cat", "1" => "dog"},
-        computers: {cool: true, drives: ["hard", "flash"]}
-      }).should == {
-        "house" => "bricks",
-        "animals[0]" => "cat",
-        "animals[1]" => "dog",
-        "computers[cool]" => "true",
-        "computers[drives][0]" => "hard",
-        "computers[drives][1]" => "flash"
-      }
-    end
-  end
-end
-
+end

data/spec/resources/statement_spec.rb

@@ -3,27 +3,77 @@ require "spec_helper"
 describe "Statement" do
   context "basic request executing" do
     before do
-      stub_request(:get, /#{TheBigDB.api_host}\/v#{TheBigDB.api_version}\/statements\/search/).to_return(:body => '{"server_says": "hello world"}')
+      stub_request(:get, @request_path.call("search")).to_return(:body => '{"server_says": "hello world"}')
 
       @request = TheBigDB::Statement(:search, nodes: ["a", "b"])
     end
 
     it "sets the correct data_sent instance variable" do
       @request.data_sent.should == {
-          "headers" => Hash[@request.http_request.to_hash.map{|k,v| [k, v.join] }],
-          "host" => TheBigDB.api_host,
-          "port" => TheBigDB.api_port,
-          "path" => "/v#{TheBigDB.api_version}/statements/search",
-          "method" => "GET",
-          "params" => {"nodes" => {"0" => "a", "1" => "b"}}
-        }
+        "headers" => Hash[@request.http_request.to_hash.map{|k,v| [k, v.join] }],
+        "host" => TheBigDB.api_host,
+        "port" => TheBigDB.api_port,
+        "path" => "/v#{TheBigDB.api_version}/statements/search",
+        "method" => "GET",
+        "params" => {"nodes" => {"0" => "a", "1" => "b"}}
+      }
     end
 
     it "sets the correct data_received instance variable" do
       @request.data_received.should include({
-          "headers" => Hash[@request.http_response.to_hash.map{|k,v| [k, v.join] }],
-          "content" => {"server_says" => "hello world"}
-        })
+        "headers" => Hash[@request.http_response.to_hash.map{|k,v| [k, v.join] }],
+        "content" => {"server_says" => "hello world"}
+      })
     end
   end
+end
+
+describe "StatementRequest" do
+  before do
+  end
+
+  it "makes normal requests" do
+    @search = TheBigDB.search("a", "b", {match: "blue"})
+    @search.with(page: 2)
+    @search.params.should == {"nodes" => ["a", "b", {match: "blue"}], "page" => 2}
+  end
+
+  it "cache the response unless the params are modified, or asked to" do
+    stub_request(:get, @request_path.call("search")).to_return(:body => '{status: "success", statements: []}')
+
+    response = TheBigDB.search("a", "b", {match: "blue"}).with(page: 2)
+    response.execute
+    response.execute
+
+    response = TheBigDB.search("a", "b", {match: "red"}).with(page: 2)
+    response.execute
+    response.execute!
+
+    a_request(:get, @request_path.call("search"))
+      .with(query: hash_including({"nodes" => ["a", "b", {match: "blue"}], "page" => "2"})).should have_been_made.once
+
+    a_request(:get, @request_path.call("search"))
+      .with(query: hash_including({"nodes" => ["a", "b", {match: "red"}], "page" => "2"})).should have_been_made.times(2)
+  end
+
+  it "has standard actions correctly binded" do
+    stub_request(:get, @request_path.call("search")).to_return(:body => '{status: "success", statements: []}')
+    stub_request(:get, @request_path.call("show")).to_return(:body => '{status: "success"}')
+    stub_request(:post, @request_path.call("create")).to_return(:body => '{status: "success"}')
+    stub_request(:post, @request_path.call("upvote")).to_return(:body => '{status: "success"}')
+    stub_request(:post, @request_path.call("downvote")).to_return(:body => '{status: "success"}')
+
+    TheBigDB.search("a", "b", {match: "blue"}).execute
+    TheBigDB.show("foobar").execute
+    TheBigDB.create("foobar").execute
+    TheBigDB.upvote("foobar").execute
+    TheBigDB.downvote("foobar").execute
+
+    a_request(:get, @request_path.call("search")).should have_been_made.once
+    a_request(:get, @request_path.call("show")).should have_been_made.once
+    a_request(:post, @request_path.call("create")).should have_been_made.once
+    a_request(:post, @request_path.call("upvote")).should have_been_made.once
+    a_request(:post, @request_path.call("downvote")).should have_been_made.once
+  end
+
 end

data/spec/spec_helper.rb

@@ -8,6 +8,8 @@ RSpec.configure do |config|
   config.before(:each) do
     TheBigDB::DEFAULT_CONFIGURATION["api_host"] = "fake.test.host"
     TheBigDB.reset_default_configuration
+
+    @request_path = ->(action){ /#{TheBigDB.api_host}\/v#{TheBigDB.api_version}\/statements\/#{action}/ }
   end
 
   config.after(:each) do

data/thebigdb.gemspec

@@ -4,7 +4,6 @@ require "thebigdb/version"
 Gem::Specification.new do |s|
   s.name = "thebigdb"
   s.version = TheBigDB::VERSION::STRING
-  s.date = "2013-03-12"
   s.summary = "Ruby bindings for TheBigDB API"
   s.description = "TheBigDB a simply structured open database of real life facts. See http://thebigdb.com for details."
   s.authors = ["Christophe Maximin"]
@@ -15,6 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency "rack", "~> 1.4"
 
+  s.add_development_dependency "rake", "~> 10.0.3"
   s.add_development_dependency "rspec", "~> 2.12"
   s.add_development_dependency "guard-rspec", "~> 2.3"
   s.add_development_dependency "rb-inotify"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thebigdb
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2013-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -27,6 +27,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +148,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - Gemfile.lock
 - Guardfile
@@ -140,15 +157,15 @@ files:
 - Rakefile
 - lib/thebigdb.rb
 - lib/thebigdb/aliases.rb
+- lib/thebigdb/helpers.rb
 - lib/thebigdb/module_attribute_accessors.rb
 - lib/thebigdb/request.rb
 - lib/thebigdb/resources/statement.rb
-- lib/thebigdb/resources/toolbox.rb
 - lib/thebigdb/resources/user.rb
 - lib/thebigdb/version.rb
+- spec/helpers_spec.rb
 - spec/request_spec.rb
 - spec/resources/statement_spec.rb
-- spec/resources/toolbox_spec.rb
 - spec/resources/user_spec.rb
 - spec/spec_helper.rb
 - spec/thebigdb_spec.rb
@@ -178,9 +195,9 @@ signing_key:
 specification_version: 3
 summary: Ruby bindings for TheBigDB API
 test_files:
+- spec/helpers_spec.rb
 - spec/request_spec.rb
 - spec/resources/statement_spec.rb
-- spec/resources/toolbox_spec.rb
 - spec/resources/user_spec.rb
 - spec/spec_helper.rb
 - spec/thebigdb_spec.rb

data/lib/thebigdb/resources/toolbox.rb

@@ -1,12 +0,0 @@
-module TheBigDB
-  module Toolbox
-    def self.Unit(action, params)
-      method = "GET"
-      path = "/toolbox/units/#{action}"
-
-      request = TheBigDB::Request.new
-      request.prepare(method, path, params)
-      request.execute
-    end
-  end
-end

data/spec/resources/toolbox_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe "Toolbox Units" do
-  context "basic request executing" do
-    before do
-      stub_request(:get, /#{TheBigDB.api_host}\/v#{TheBigDB.api_version}\/toolbox\/units\/convert/).to_return(:body => '{"server_says": "hello world"}')
-
-      @request = TheBigDB::Toolbox::Unit(:convert, :value => "100 ly", :new_unit => "cm")
-    end
-
-    it "sets the correct data_sent instance variable" do
-      @request.data_sent.should == {
-          "headers" => Hash[@request.http_request.to_hash.map{|k,v| [k, v.join] }],
-          "host" => TheBigDB.api_host,
-          "port" => TheBigDB.api_port,
-          "path" => "/v#{TheBigDB.api_version}/toolbox/units/convert",
-          "method" => "GET",
-          "params" => {"value" => "100 ly", "new_unit" => "cm"}
-        }
-    end
-
-    it "sets the correct data_received instance variable" do
-      @request.data_received.should include({
-          "headers" => Hash[@request.http_response.to_hash.map{|k,v| [k, v.join] }],
-          "content" => {"server_says" => "hello world"}
-        })
-    end
-  end
-end